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

#include "py.Windows.UI.Xaml.Shapes.h"


namespace py::cpp::Windows::UI::Xaml::Shapes
{
    // ----- Ellipse class --------------------

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

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Windows::UI::Xaml::Shapes::Ellipse 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_Ellipse(py::wrapper::Windows::UI::Xaml::Shapes::Ellipse* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

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

    static PyMethodDef _methods_Ellipse[] = {
        { "_assign_array_", _assign_array_Ellipse, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Ellipse), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Ellipse[] = {
        { }
    };

    static PyType_Slot _type_slots_Ellipse[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Ellipse) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Ellipse) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Ellipse) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Ellipse) },
        { },
    };

    static PyType_Spec type_spec_Ellipse =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Ellipse",
        sizeof(py::wrapper::Windows::UI::Xaml::Shapes::Ellipse),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Ellipse
    };

    // ----- Line class --------------------

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

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Windows::UI::Xaml::Shapes::Line 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_Line(py::wrapper::Windows::UI::Xaml::Shapes::Line* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

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

    static int Line_put_Y2(py::wrapper::Windows::UI::Xaml::Shapes::Line* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Line", L"Y2"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this 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.Y2(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

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

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

    static int Line_put_Y1(py::wrapper::Windows::UI::Xaml::Shapes::Line* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Line", L"Y1"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this 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.Y1(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

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

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

    static int Line_put_X2(py::wrapper::Windows::UI::Xaml::Shapes::Line* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Line", L"X2"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this 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.X2(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

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

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

    static int Line_put_X1(py::wrapper::Windows::UI::Xaml::Shapes::Line* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Line", L"X1"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this 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.X1(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Line::X1Property());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Line::X2Property());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Line::Y1Property());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Line::Y2Property());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

    static PyMethodDef _methods_Line[] = {
        { "_assign_array_", _assign_array_Line, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Line), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Line[] = {
        { "y2", reinterpret_cast<getter>(Line_get_Y2), reinterpret_cast<setter>(Line_put_Y2), nullptr, nullptr },
        { "y1", reinterpret_cast<getter>(Line_get_Y1), reinterpret_cast<setter>(Line_put_Y1), nullptr, nullptr },
        { "x2", reinterpret_cast<getter>(Line_get_X2), reinterpret_cast<setter>(Line_put_X2), nullptr, nullptr },
        { "x1", reinterpret_cast<getter>(Line_get_X1), reinterpret_cast<setter>(Line_put_X1), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Line[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Line) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Line) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Line) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Line) },
        { },
    };

    static PyType_Spec type_spec_Line =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Line",
        sizeof(py::wrapper::Windows::UI::Xaml::Shapes::Line),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Line
    };

    static PyGetSetDef getset_Line_Static[] = {
        { "x1_property", reinterpret_cast<getter>(Line_get_X1Property), nullptr, nullptr, nullptr },
        { "x2_property", reinterpret_cast<getter>(Line_get_X2Property), nullptr, nullptr, nullptr },
        { "y1_property", reinterpret_cast<getter>(Line_get_Y1Property), nullptr, nullptr, nullptr },
        { "y2_property", reinterpret_cast<getter>(Line_get_Y2Property), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Line_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Line_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Line_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Line_Static) },
        { }
    };

    static PyType_Spec type_spec_Line_Static =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Line_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Line_Static
    };

    // ----- Path class --------------------

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

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Windows::UI::Xaml::Shapes::Path 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_Path(py::wrapper::Windows::UI::Xaml::Shapes::Path* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Path_get_Data(py::wrapper::Windows::UI::Xaml::Shapes::Path* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Path", 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 Path_put_Data(py::wrapper::Windows::UI::Xaml::Shapes::Path* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Path", 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::Windows::UI::Xaml::Media::Geometry>(arg);

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

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Path::DataProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

    static PyMethodDef _methods_Path[] = {
        { "_assign_array_", _assign_array_Path, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Path), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Path[] = {
        { "data", reinterpret_cast<getter>(Path_get_Data), reinterpret_cast<setter>(Path_put_Data), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Path[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Path) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Path) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Path) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Path) },
        { },
    };

    static PyType_Spec type_spec_Path =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Path",
        sizeof(py::wrapper::Windows::UI::Xaml::Shapes::Path),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Path
    };

    static PyGetSetDef getset_Path_Static[] = {
        { "data_property", reinterpret_cast<getter>(Path_get_DataProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Path_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Path_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Path_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Path_Static) },
        { }
    };

    static PyType_Spec type_spec_Path_Static =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Path_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Path_Static
    };

    // ----- Polygon class --------------------

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

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Windows::UI::Xaml::Shapes::Polygon 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_Polygon(py::wrapper::Windows::UI::Xaml::Shapes::Polygon* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

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

    static int Polygon_put_Points(py::wrapper::Windows::UI::Xaml::Shapes::Polygon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Polygon", L"Points"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Media::PointCollection>(arg);

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

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

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

    static int Polygon_put_FillRule(py::wrapper::Windows::UI::Xaml::Shapes::Polygon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Polygon", L"FillRule"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Media::FillRule>(arg);

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

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Polygon::FillRuleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Polygon::PointsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

    static PyMethodDef _methods_Polygon[] = {
        { "_assign_array_", _assign_array_Polygon, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Polygon), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Polygon[] = {
        { "points", reinterpret_cast<getter>(Polygon_get_Points), reinterpret_cast<setter>(Polygon_put_Points), nullptr, nullptr },
        { "fill_rule", reinterpret_cast<getter>(Polygon_get_FillRule), reinterpret_cast<setter>(Polygon_put_FillRule), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Polygon[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Polygon) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Polygon) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Polygon) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Polygon) },
        { },
    };

    static PyType_Spec type_spec_Polygon =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Polygon",
        sizeof(py::wrapper::Windows::UI::Xaml::Shapes::Polygon),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Polygon
    };

    static PyGetSetDef getset_Polygon_Static[] = {
        { "fill_rule_property", reinterpret_cast<getter>(Polygon_get_FillRuleProperty), nullptr, nullptr, nullptr },
        { "points_property", reinterpret_cast<getter>(Polygon_get_PointsProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Polygon_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Polygon_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Polygon_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Polygon_Static) },
        { }
    };

    static PyType_Spec type_spec_Polygon_Static =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Polygon_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Polygon_Static
    };

    // ----- Polyline class --------------------

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

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Windows::UI::Xaml::Shapes::Polyline 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_Polyline(py::wrapper::Windows::UI::Xaml::Shapes::Polyline* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

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

    static int Polyline_put_Points(py::wrapper::Windows::UI::Xaml::Shapes::Polyline* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Polyline", L"Points"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Media::PointCollection>(arg);

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

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

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

    static int Polyline_put_FillRule(py::wrapper::Windows::UI::Xaml::Shapes::Polyline* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Polyline", L"FillRule"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Media::FillRule>(arg);

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

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Polyline::FillRuleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Polyline::PointsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

    static PyMethodDef _methods_Polyline[] = {
        { "_assign_array_", _assign_array_Polyline, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Polyline), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Polyline[] = {
        { "points", reinterpret_cast<getter>(Polyline_get_Points), reinterpret_cast<setter>(Polyline_put_Points), nullptr, nullptr },
        { "fill_rule", reinterpret_cast<getter>(Polyline_get_FillRule), reinterpret_cast<setter>(Polyline_put_FillRule), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Polyline[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Polyline) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Polyline) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Polyline) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Polyline) },
        { },
    };

    static PyType_Spec type_spec_Polyline =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Polyline",
        sizeof(py::wrapper::Windows::UI::Xaml::Shapes::Polyline),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Polyline
    };

    static PyGetSetDef getset_Polyline_Static[] = {
        { "fill_rule_property", reinterpret_cast<getter>(Polyline_get_FillRuleProperty), nullptr, nullptr, nullptr },
        { "points_property", reinterpret_cast<getter>(Polyline_get_PointsProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Polyline_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Polyline_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Polyline_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Polyline_Static) },
        { }
    };

    static PyType_Spec type_spec_Polyline_Static =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Polyline_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Polyline_Static
    };

    // ----- Rectangle class --------------------

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

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Windows::UI::Xaml::Shapes::Rectangle 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_Rectangle(py::wrapper::Windows::UI::Xaml::Shapes::Rectangle* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

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

    static int Rectangle_put_RadiusY(py::wrapper::Windows::UI::Xaml::Shapes::Rectangle* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Rectangle", L"RadiusY"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this 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.RadiusY(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

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

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

    static int Rectangle_put_RadiusX(py::wrapper::Windows::UI::Xaml::Shapes::Rectangle* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Rectangle", L"RadiusX"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this 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.RadiusX(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Rectangle::RadiusXProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Rectangle::RadiusYProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

    static PyMethodDef _methods_Rectangle[] = {
        { "_assign_array_", _assign_array_Rectangle, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Rectangle), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Rectangle[] = {
        { "radius_y", reinterpret_cast<getter>(Rectangle_get_RadiusY), reinterpret_cast<setter>(Rectangle_put_RadiusY), nullptr, nullptr },
        { "radius_x", reinterpret_cast<getter>(Rectangle_get_RadiusX), reinterpret_cast<setter>(Rectangle_put_RadiusX), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Rectangle[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Rectangle) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Rectangle) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Rectangle) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Rectangle) },
        { },
    };

    static PyType_Spec type_spec_Rectangle =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Rectangle",
        sizeof(py::wrapper::Windows::UI::Xaml::Shapes::Rectangle),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Rectangle
    };

    static PyGetSetDef getset_Rectangle_Static[] = {
        { "radius_x_property", reinterpret_cast<getter>(Rectangle_get_RadiusXProperty), nullptr, nullptr, nullptr },
        { "radius_y_property", reinterpret_cast<getter>(Rectangle_get_RadiusYProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Rectangle_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Rectangle_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Rectangle_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Rectangle_Static) },
        { }
    };

    static PyType_Spec type_spec_Rectangle_Static =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Rectangle_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Rectangle_Static
    };

    // ----- Shape class --------------------

    static PyObject* _new_Shape(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::UI::Xaml::Shapes::Shape>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::UI::Xaml::Shapes::Shape>::type_name);
        return nullptr;
    }

    static void _dealloc_Shape(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Shape_GetAlphaMask(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.UI.Xaml.Shapes.Shape", 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* Shape_get_StrokeThickness(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Shape", L"StrokeThickness"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Shape_put_StrokeThickness(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Shape", L"StrokeThickness"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this 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.StrokeThickness(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

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

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

    static int Shape_put_StrokeStartLineCap(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Shape", L"StrokeStartLineCap"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Media::PenLineCap>(arg);

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

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

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

    static int Shape_put_StrokeMiterLimit(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Shape", L"StrokeMiterLimit"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this 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.StrokeMiterLimit(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

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

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

    static int Shape_put_StrokeLineJoin(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Shape", L"StrokeLineJoin"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Media::PenLineJoin>(arg);

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

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

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

    static int Shape_put_StrokeEndLineCap(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Shape", L"StrokeEndLineCap"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Media::PenLineCap>(arg);

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

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

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

    static int Shape_put_StrokeDashOffset(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Shape", L"StrokeDashOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this 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.StrokeDashOffset(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

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

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

    static int Shape_put_StrokeDashCap(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Shape", L"StrokeDashCap"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Media::PenLineCap>(arg);

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

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

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

    static int Shape_put_StrokeDashArray(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Shape", L"StrokeDashArray"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Media::DoubleCollection>(arg);

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

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

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

    static int Shape_put_Stroke(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Shape", L"Stroke"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Media::Brush>(arg);

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

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

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

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

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

    static int Shape_put_Fill(py::wrapper::Windows::UI::Xaml::Shapes::Shape* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.UI.Xaml.Shapes.Shape", L"Fill"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Media::Brush>(arg);

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

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

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

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Shape::FillProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Shape::StretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Shape::StrokeDashArrayProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Shape::StrokeDashCapProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Shape::StrokeDashOffsetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Shape::StrokeEndLineCapProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Shape::StrokeLineJoinProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Shape::StrokeMiterLimitProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Shape::StrokeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Shape::StrokeStartLineCapProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            return py::convert(winrt::Windows::UI::Xaml::Shapes::Shape::StrokeThicknessProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

    static PyMethodDef _methods_Shape[] = {
        { "get_alpha_mask", reinterpret_cast<PyCFunction>(Shape_GetAlphaMask), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_Shape, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Shape), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Shape[] = {
        { "stroke_thickness", reinterpret_cast<getter>(Shape_get_StrokeThickness), reinterpret_cast<setter>(Shape_put_StrokeThickness), nullptr, nullptr },
        { "stroke_start_line_cap", reinterpret_cast<getter>(Shape_get_StrokeStartLineCap), reinterpret_cast<setter>(Shape_put_StrokeStartLineCap), nullptr, nullptr },
        { "stroke_miter_limit", reinterpret_cast<getter>(Shape_get_StrokeMiterLimit), reinterpret_cast<setter>(Shape_put_StrokeMiterLimit), nullptr, nullptr },
        { "stroke_line_join", reinterpret_cast<getter>(Shape_get_StrokeLineJoin), reinterpret_cast<setter>(Shape_put_StrokeLineJoin), nullptr, nullptr },
        { "stroke_end_line_cap", reinterpret_cast<getter>(Shape_get_StrokeEndLineCap), reinterpret_cast<setter>(Shape_put_StrokeEndLineCap), nullptr, nullptr },
        { "stroke_dash_offset", reinterpret_cast<getter>(Shape_get_StrokeDashOffset), reinterpret_cast<setter>(Shape_put_StrokeDashOffset), nullptr, nullptr },
        { "stroke_dash_cap", reinterpret_cast<getter>(Shape_get_StrokeDashCap), reinterpret_cast<setter>(Shape_put_StrokeDashCap), nullptr, nullptr },
        { "stroke_dash_array", reinterpret_cast<getter>(Shape_get_StrokeDashArray), reinterpret_cast<setter>(Shape_put_StrokeDashArray), nullptr, nullptr },
        { "stroke", reinterpret_cast<getter>(Shape_get_Stroke), reinterpret_cast<setter>(Shape_put_Stroke), nullptr, nullptr },
        { "stretch", reinterpret_cast<getter>(Shape_get_Stretch), reinterpret_cast<setter>(Shape_put_Stretch), nullptr, nullptr },
        { "fill", reinterpret_cast<getter>(Shape_get_Fill), reinterpret_cast<setter>(Shape_put_Fill), nullptr, nullptr },
        { "geometry_transform", reinterpret_cast<getter>(Shape_get_GeometryTransform), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Shape[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Shape) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Shape) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Shape) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Shape) },
        { },
    };

    static PyType_Spec type_spec_Shape =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Shape",
        sizeof(py::wrapper::Windows::UI::Xaml::Shapes::Shape),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Shape
    };

    static PyGetSetDef getset_Shape_Static[] = {
        { "fill_property", reinterpret_cast<getter>(Shape_get_FillProperty), nullptr, nullptr, nullptr },
        { "stretch_property", reinterpret_cast<getter>(Shape_get_StretchProperty), nullptr, nullptr, nullptr },
        { "stroke_dash_array_property", reinterpret_cast<getter>(Shape_get_StrokeDashArrayProperty), nullptr, nullptr, nullptr },
        { "stroke_dash_cap_property", reinterpret_cast<getter>(Shape_get_StrokeDashCapProperty), nullptr, nullptr, nullptr },
        { "stroke_dash_offset_property", reinterpret_cast<getter>(Shape_get_StrokeDashOffsetProperty), nullptr, nullptr, nullptr },
        { "stroke_end_line_cap_property", reinterpret_cast<getter>(Shape_get_StrokeEndLineCapProperty), nullptr, nullptr, nullptr },
        { "stroke_line_join_property", reinterpret_cast<getter>(Shape_get_StrokeLineJoinProperty), nullptr, nullptr, nullptr },
        { "stroke_miter_limit_property", reinterpret_cast<getter>(Shape_get_StrokeMiterLimitProperty), nullptr, nullptr, nullptr },
        { "stroke_property", reinterpret_cast<getter>(Shape_get_StrokeProperty), nullptr, nullptr, nullptr },
        { "stroke_start_line_cap_property", reinterpret_cast<getter>(Shape_get_StrokeStartLineCapProperty), nullptr, nullptr, nullptr },
        { "stroke_thickness_property", reinterpret_cast<getter>(Shape_get_StrokeThicknessProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Shape_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Shape_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Shape_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Shape_Static) },
        { }
    };

    static PyType_Spec type_spec_Shape_Static =
    {
        "winrt._winrt_windows_ui_xaml_shapes.Shape_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Shape_Static
    };

    // ----- Windows.UI.Xaml.Shapes Initialization --------------------
    PyDoc_STRVAR(module_doc, "Windows::UI::Xaml::Shapes");


    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winrt_windows_ui_xaml_shapes",
           module_doc,
           0,
           nullptr,
           nullptr,
           nullptr,
           nullptr,
           nullptr};

} // py::cpp::Windows::UI::Xaml::Shapes

PyMODINIT_FUNC PyInit__winrt_windows_ui_xaml_shapes(void) noexcept
{
    using namespace py::cpp::Windows::UI::Xaml::Shapes;

    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_Ellipse, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Line_Static{PyType_FromSpec(&type_spec_Line_Static)};
    if (!type_Line_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Line, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Line_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Path_Static{PyType_FromSpec(&type_spec_Path_Static)};
    if (!type_Path_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Path, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Path_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Polygon_Static{PyType_FromSpec(&type_spec_Polygon_Static)};
    if (!type_Polygon_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Polygon, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Polygon_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Polyline_Static{PyType_FromSpec(&type_spec_Polyline_Static)};
    if (!type_Polyline_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Polyline, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Polyline_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Rectangle_Static{PyType_FromSpec(&type_spec_Rectangle_Static)};
    if (!type_Rectangle_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Rectangle, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Rectangle_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Shape_Static{PyType_FromSpec(&type_spec_Shape_Static)};
    if (!type_Shape_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Shape, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Shape_Static.get())) == -1)
    {
        return nullptr;
    }


    return module.detach();
}
