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

#include "py.Microsoft.UI.Xaml.Media.Media3D.h"

namespace py::cpp::Microsoft::UI::Xaml::Media::Media3D
{
    // ----- CompositeTransform3D class --------------------

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

        auto arg_count = PyTuple_GET_SIZE(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D 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_CompositeTransform3D(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CompositeTransform3D_get_TranslateZ(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"TranslateZ");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.TranslateZ();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_TranslateZ(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"TranslateZ");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.TranslateZ(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_TranslateY(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"TranslateY");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.TranslateY();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_TranslateY(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"TranslateY");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.TranslateY(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_TranslateX(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"TranslateX");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.TranslateX();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_TranslateX(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"TranslateX");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.TranslateX(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_ScaleZ(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"ScaleZ");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.ScaleZ();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_ScaleZ(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"ScaleZ");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.ScaleZ(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_ScaleY(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"ScaleY");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.ScaleY();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_ScaleY(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"ScaleY");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.ScaleY(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_ScaleX(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"ScaleX");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.ScaleX();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_ScaleX(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"ScaleX");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.ScaleX(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_RotationZ(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"RotationZ");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.RotationZ();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_RotationZ(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"RotationZ");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.RotationZ(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_RotationY(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"RotationY");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.RotationY();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_RotationY(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"RotationY");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.RotationY(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_RotationX(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"RotationX");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.RotationX();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_RotationX(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"RotationX");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.RotationX(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_CenterZ(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"CenterZ");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.CenterZ();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_CenterZ(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"CenterZ");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.CenterZ(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_CenterY(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"CenterY");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.CenterY();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_CenterY(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"CenterY");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.CenterY(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_CenterX(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"CenterX");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.CenterX();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int CompositeTransform3D_put_CenterX(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"CenterX");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.CenterX(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CompositeTransform3D_get_CenterXProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"CenterXProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::CenterXProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CompositeTransform3D_get_CenterYProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"CenterYProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::CenterYProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CompositeTransform3D_get_CenterZProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"CenterZProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::CenterZProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CompositeTransform3D_get_RotationXProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"RotationXProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::RotationXProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CompositeTransform3D_get_RotationYProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"RotationYProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::RotationYProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CompositeTransform3D_get_RotationZProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"RotationZProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::RotationZProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CompositeTransform3D_get_ScaleXProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"ScaleXProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::ScaleXProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CompositeTransform3D_get_ScaleYProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"ScaleYProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::ScaleYProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CompositeTransform3D_get_ScaleZProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"ScaleZProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::ScaleZProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CompositeTransform3D_get_TranslateXProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"TranslateXProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::TranslateXProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CompositeTransform3D_get_TranslateYProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"TranslateYProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::TranslateYProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CompositeTransform3D_get_TranslateZProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.CompositeTransform3D", L"TranslateZProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D::TranslateZProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

    static PyMethodDef _methods_CompositeTransform3D[] = {
        { "_assign_array_", _assign_array_CompositeTransform3D, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CompositeTransform3D), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_CompositeTransform3D[] = {
        { "translate_z", reinterpret_cast<getter>(CompositeTransform3D_get_TranslateZ), reinterpret_cast<setter>(CompositeTransform3D_put_TranslateZ), nullptr, nullptr },
        { "translate_y", reinterpret_cast<getter>(CompositeTransform3D_get_TranslateY), reinterpret_cast<setter>(CompositeTransform3D_put_TranslateY), nullptr, nullptr },
        { "translate_x", reinterpret_cast<getter>(CompositeTransform3D_get_TranslateX), reinterpret_cast<setter>(CompositeTransform3D_put_TranslateX), nullptr, nullptr },
        { "scale_z", reinterpret_cast<getter>(CompositeTransform3D_get_ScaleZ), reinterpret_cast<setter>(CompositeTransform3D_put_ScaleZ), nullptr, nullptr },
        { "scale_y", reinterpret_cast<getter>(CompositeTransform3D_get_ScaleY), reinterpret_cast<setter>(CompositeTransform3D_put_ScaleY), nullptr, nullptr },
        { "scale_x", reinterpret_cast<getter>(CompositeTransform3D_get_ScaleX), reinterpret_cast<setter>(CompositeTransform3D_put_ScaleX), nullptr, nullptr },
        { "rotation_z", reinterpret_cast<getter>(CompositeTransform3D_get_RotationZ), reinterpret_cast<setter>(CompositeTransform3D_put_RotationZ), nullptr, nullptr },
        { "rotation_y", reinterpret_cast<getter>(CompositeTransform3D_get_RotationY), reinterpret_cast<setter>(CompositeTransform3D_put_RotationY), nullptr, nullptr },
        { "rotation_x", reinterpret_cast<getter>(CompositeTransform3D_get_RotationX), reinterpret_cast<setter>(CompositeTransform3D_put_RotationX), nullptr, nullptr },
        { "center_z", reinterpret_cast<getter>(CompositeTransform3D_get_CenterZ), reinterpret_cast<setter>(CompositeTransform3D_put_CenterZ), nullptr, nullptr },
        { "center_y", reinterpret_cast<getter>(CompositeTransform3D_get_CenterY), reinterpret_cast<setter>(CompositeTransform3D_put_CenterY), nullptr, nullptr },
        { "center_x", reinterpret_cast<getter>(CompositeTransform3D_get_CenterX), reinterpret_cast<setter>(CompositeTransform3D_put_CenterX), nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_CompositeTransform3D[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_CompositeTransform3D) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CompositeTransform3D) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CompositeTransform3D) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CompositeTransform3D) },
        { }};

    static PyType_Spec type_spec_CompositeTransform3D = {
        "winui3._winui3_microsoft_ui_xaml_media_media3d.CompositeTransform3D",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::CompositeTransform3D),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CompositeTransform3D};

    static PyGetSetDef getset_CompositeTransform3D_Static[] = {
        { "center_x_property", reinterpret_cast<getter>(CompositeTransform3D_get_CenterXProperty), nullptr, nullptr, nullptr },
        { "center_y_property", reinterpret_cast<getter>(CompositeTransform3D_get_CenterYProperty), nullptr, nullptr, nullptr },
        { "center_z_property", reinterpret_cast<getter>(CompositeTransform3D_get_CenterZProperty), nullptr, nullptr, nullptr },
        { "rotation_x_property", reinterpret_cast<getter>(CompositeTransform3D_get_RotationXProperty), nullptr, nullptr, nullptr },
        { "rotation_y_property", reinterpret_cast<getter>(CompositeTransform3D_get_RotationYProperty), nullptr, nullptr, nullptr },
        { "rotation_z_property", reinterpret_cast<getter>(CompositeTransform3D_get_RotationZProperty), nullptr, nullptr, nullptr },
        { "scale_x_property", reinterpret_cast<getter>(CompositeTransform3D_get_ScaleXProperty), nullptr, nullptr, nullptr },
        { "scale_y_property", reinterpret_cast<getter>(CompositeTransform3D_get_ScaleYProperty), nullptr, nullptr, nullptr },
        { "scale_z_property", reinterpret_cast<getter>(CompositeTransform3D_get_ScaleZProperty), nullptr, nullptr, nullptr },
        { "translate_x_property", reinterpret_cast<getter>(CompositeTransform3D_get_TranslateXProperty), nullptr, nullptr, nullptr },
        { "translate_y_property", reinterpret_cast<getter>(CompositeTransform3D_get_TranslateYProperty), nullptr, nullptr, nullptr },
        { "translate_z_property", reinterpret_cast<getter>(CompositeTransform3D_get_TranslateZProperty), nullptr, nullptr, nullptr },
        { }};

    static PyMethodDef methods_CompositeTransform3D_Static[] = {
        { }};

    static PyType_Slot type_slots_CompositeTransform3D_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_CompositeTransform3D_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_CompositeTransform3D_Static) },
        { }
    };

    static PyType_Spec type_spec_CompositeTransform3D_Static = {
        "winui3._winui3_microsoft_ui_xaml_media_media3d.CompositeTransform3D_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_CompositeTransform3D_Static};

    // ----- Matrix3DHelper class --------------------

    static PyObject* _new_Matrix3DHelper(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3DHelper>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3DHelper>::type_name);
        return nullptr;
    }

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

    static PyObject* Matrix3DHelper_FromElements(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

        if (arg_count == 16)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Media.Media3D.Matrix3DHelper", L"FromElements", 16);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(16);
                    return nullptr;
                }

                auto param0 = py::convert_to<double>(args, 0);
                auto param1 = py::convert_to<double>(args, 1);
                auto param2 = py::convert_to<double>(args, 2);
                auto param3 = py::convert_to<double>(args, 3);
                auto param4 = py::convert_to<double>(args, 4);
                auto param5 = py::convert_to<double>(args, 5);
                auto param6 = py::convert_to<double>(args, 6);
                auto param7 = py::convert_to<double>(args, 7);
                auto param8 = py::convert_to<double>(args, 8);
                auto param9 = py::convert_to<double>(args, 9);
                auto param10 = py::convert_to<double>(args, 10);
                auto param11 = py::convert_to<double>(args, 11);
                auto param12 = py::convert_to<double>(args, 12);
                auto param13 = py::convert_to<double>(args, 13);
                auto param14 = py::convert_to<double>(args, 14);
                auto param15 = py::convert_to<double>(args, 15);

                return py::convert([&]()
                {
                    auto _gil = release_gil();
                    return winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3DHelper::FromElements(param0, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15);
                }());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Matrix3DHelper_GetHasInverse(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

        if (arg_count == 1)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Media.Media3D.Matrix3DHelper", L"GetHasInverse", 1);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(1);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3D>(args, 0);

                return py::convert([&]()
                {
                    auto _gil = release_gil();
                    return winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3DHelper::GetHasInverse(param0);
                }());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Matrix3DHelper_GetIsIdentity(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

        if (arg_count == 1)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Media.Media3D.Matrix3DHelper", L"GetIsIdentity", 1);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(1);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3D>(args, 0);

                return py::convert([&]()
                {
                    auto _gil = release_gil();
                    return winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3DHelper::GetIsIdentity(param0);
                }());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Matrix3DHelper_Invert(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

        if (arg_count == 1)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Media.Media3D.Matrix3DHelper", L"Invert", 1);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(1);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3D>(args, 0);

                return py::convert([&]()
                {
                    auto _gil = release_gil();
                    return winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3DHelper::Invert(param0);
                }());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Matrix3DHelper_Multiply(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

        if (arg_count == 2)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Media.Media3D.Matrix3DHelper", L"Multiply", 2);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(2);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3D>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3D>(args, 1);

                return py::convert([&]()
                {
                    auto _gil = release_gil();
                    return winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3DHelper::Multiply(param0, param1);
                }());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Matrix3DHelper_get_Identity(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.Matrix3DHelper", L"Identity");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3DHelper::Identity();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

    static PyMethodDef _methods_Matrix3DHelper[] = {
        { "_assign_array_", _assign_array_Matrix3DHelper, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Matrix3DHelper), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_Matrix3DHelper[] = {
        { }};

    static PyType_Slot _type_slots_Matrix3DHelper[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_Matrix3DHelper) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Matrix3DHelper) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Matrix3DHelper) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Matrix3DHelper) },
        { }};

    static PyType_Spec type_spec_Matrix3DHelper = {
        "winui3._winui3_microsoft_ui_xaml_media_media3d.Matrix3DHelper",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3DHelper),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Matrix3DHelper};

    static PyGetSetDef getset_Matrix3DHelper_Static[] = {
        { "identity", reinterpret_cast<getter>(Matrix3DHelper_get_Identity), nullptr, nullptr, nullptr },
        { }};

    static PyMethodDef methods_Matrix3DHelper_Static[] = {
        { "from_elements", reinterpret_cast<PyCFunction>(Matrix3DHelper_FromElements), METH_VARARGS, nullptr },
        { "get_has_inverse", reinterpret_cast<PyCFunction>(Matrix3DHelper_GetHasInverse), METH_VARARGS, nullptr },
        { "get_is_identity", reinterpret_cast<PyCFunction>(Matrix3DHelper_GetIsIdentity), METH_VARARGS, nullptr },
        { "invert", reinterpret_cast<PyCFunction>(Matrix3DHelper_Invert), METH_VARARGS, nullptr },
        { "multiply", reinterpret_cast<PyCFunction>(Matrix3DHelper_Multiply), METH_VARARGS, nullptr },
        { }};

    static PyType_Slot type_slots_Matrix3DHelper_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Matrix3DHelper_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Matrix3DHelper_Static) },
        { }
    };

    static PyType_Spec type_spec_Matrix3DHelper_Static = {
        "winui3._winui3_microsoft_ui_xaml_media_media3d.Matrix3DHelper_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Matrix3DHelper_Static};

    // ----- PerspectiveTransform3D class --------------------

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

        auto arg_count = PyTuple_GET_SIZE(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D 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_PerspectiveTransform3D(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PerspectiveTransform3D_get_OffsetY(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.PerspectiveTransform3D", L"OffsetY");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.OffsetY();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PerspectiveTransform3D_put_OffsetY(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.PerspectiveTransform3D", L"OffsetY");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.OffsetY(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PerspectiveTransform3D_get_OffsetX(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.PerspectiveTransform3D", L"OffsetX");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.OffsetX();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PerspectiveTransform3D_put_OffsetX(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.PerspectiveTransform3D", L"OffsetX");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.OffsetX(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PerspectiveTransform3D_get_Depth(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.PerspectiveTransform3D", L"Depth");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return self->obj.Depth();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PerspectiveTransform3D_put_Depth(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!arg)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.PerspectiveTransform3D", L"Depth");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<double>(arg);

            {
                auto _gil = release_gil();
                self->obj.Depth(param0);
            }

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PerspectiveTransform3D_get_DepthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.PerspectiveTransform3D", L"DepthProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D::DepthProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PerspectiveTransform3D_get_OffsetXProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.PerspectiveTransform3D", L"OffsetXProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D::OffsetXProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PerspectiveTransform3D_get_OffsetYProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Media.Media3D.PerspectiveTransform3D", L"OffsetYProperty");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert([&]()
            {
                auto _gil = release_gil();
                return winrt::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D::OffsetYProperty();
            }());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

    static PyMethodDef _methods_PerspectiveTransform3D[] = {
        { "_assign_array_", _assign_array_PerspectiveTransform3D, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PerspectiveTransform3D), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_PerspectiveTransform3D[] = {
        { "offset_y", reinterpret_cast<getter>(PerspectiveTransform3D_get_OffsetY), reinterpret_cast<setter>(PerspectiveTransform3D_put_OffsetY), nullptr, nullptr },
        { "offset_x", reinterpret_cast<getter>(PerspectiveTransform3D_get_OffsetX), reinterpret_cast<setter>(PerspectiveTransform3D_put_OffsetX), nullptr, nullptr },
        { "depth", reinterpret_cast<getter>(PerspectiveTransform3D_get_Depth), reinterpret_cast<setter>(PerspectiveTransform3D_put_Depth), nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_PerspectiveTransform3D[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_PerspectiveTransform3D) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PerspectiveTransform3D) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PerspectiveTransform3D) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PerspectiveTransform3D) },
        { }};

    static PyType_Spec type_spec_PerspectiveTransform3D = {
        "winui3._winui3_microsoft_ui_xaml_media_media3d.PerspectiveTransform3D",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::PerspectiveTransform3D),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PerspectiveTransform3D};

    static PyGetSetDef getset_PerspectiveTransform3D_Static[] = {
        { "depth_property", reinterpret_cast<getter>(PerspectiveTransform3D_get_DepthProperty), nullptr, nullptr, nullptr },
        { "offset_x_property", reinterpret_cast<getter>(PerspectiveTransform3D_get_OffsetXProperty), nullptr, nullptr, nullptr },
        { "offset_y_property", reinterpret_cast<getter>(PerspectiveTransform3D_get_OffsetYProperty), nullptr, nullptr, nullptr },
        { }};

    static PyMethodDef methods_PerspectiveTransform3D_Static[] = {
        { }};

    static PyType_Slot type_slots_PerspectiveTransform3D_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_PerspectiveTransform3D_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_PerspectiveTransform3D_Static) },
        { }
    };

    static PyType_Spec type_spec_PerspectiveTransform3D_Static = {
        "winui3._winui3_microsoft_ui_xaml_media_media3d.PerspectiveTransform3D_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_PerspectiveTransform3D_Static};

    // ----- Transform3D class --------------------

    struct PyWinrtTransform3D;
    using BasePyWinrtTransform3D = winrt::Microsoft::UI::Xaml::Media::Media3D::Transform3DT<PyWinrtTransform3D, py::IPywinrtObject>;

    struct PyWinrtTransform3D : py::py_obj_ref, BasePyWinrtTransform3D
    {

        int32_t __stdcall GetPyObject(PyObject*& obj) override
        {
            obj = py::py_obj_ref::get_py_obj();
            return 0;
        }

        int32_t __stdcall GetComposableInner(winrt::Windows::Foundation::IInspectable& inner) override
        {
            inner = m_inner;
            return winrt::impl::error_ok;
        }

        static void toggle_reference(PyWinrtTransform3D* instance, bool is_last_reference)
        {
            py::py_obj_ref::toggle_reference(instance, is_last_reference);
        }

        int32_t query_interface_tearoff(winrt::guid const& id, void** result) const noexcept override
        {
            return py::py_obj_ref::query_interface_tearoff(id, result);
        }

        std::vector<winrt::guid> get_iids_tearoff() const noexcept override
        {
            return py::py_obj_ref::get_iids_tearoff();
        }
    };

    static PyObject* _new_Transform3D(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Media::Media3D::Transform3D>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Media::Media3D::Transform3D>::type_name);
        return nullptr;
    }

    static void _dealloc_Transform3D(py::winrt_wrapper<winrt::Windows::Foundation::IInspectable>* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

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

    static PyMethodDef _methods_Transform3D[] = {
        { "_assign_array_", _assign_array_Transform3D, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Transform3D), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_Transform3D[] = {
        { }};

    static PyType_Slot _type_slots_Transform3D[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_Transform3D) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Transform3D) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Transform3D) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Transform3D) },
        { }};

    static PyType_Spec type_spec_Transform3D = {
        "winui3._winui3_microsoft_ui_xaml_media_media3d.Transform3D",
        sizeof(py::winrt_wrapper<winrt::Windows::Foundation::IInspectable>),
        0,
        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
        _type_slots_Transform3D};

    static PyGetSetDef getset_Transform3D_Static[] = {
        { }};

    static PyMethodDef methods_Transform3D_Static[] = {
        { }};

    static PyType_Slot type_slots_Transform3D_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Transform3D_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Transform3D_Static) },
        { }
    };

    static PyType_Spec type_spec_Transform3D_Static = {
        "winui3._winui3_microsoft_ui_xaml_media_media3d.Transform3D_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
        type_slots_Transform3D_Static};

    // ----- Matrix3D struct --------------------

    winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3D Matrix3D_from_tuple(PyObject* tuple)
    {
        if (PyTuple_GET_SIZE(tuple) != 16)
        {
            PyErr_SetString(PyExc_TypeError, "Incorrect number of fields");
            throw python_exception();
        }

        winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3D result{};

        result.M11 = py::convert_to<double>(tuple, 0);
        result.M12 = py::convert_to<double>(tuple, 1);
        result.M13 = py::convert_to<double>(tuple, 2);
        result.M14 = py::convert_to<double>(tuple, 3);
        result.M21 = py::convert_to<double>(tuple, 4);
        result.M22 = py::convert_to<double>(tuple, 5);
        result.M23 = py::convert_to<double>(tuple, 6);
        result.M24 = py::convert_to<double>(tuple, 7);
        result.M31 = py::convert_to<double>(tuple, 8);
        result.M32 = py::convert_to<double>(tuple, 9);
        result.M33 = py::convert_to<double>(tuple, 10);
        result.M34 = py::convert_to<double>(tuple, 11);
        result.OffsetX = py::convert_to<double>(tuple, 12);
        result.OffsetY = py::convert_to<double>(tuple, 13);
        result.OffsetZ = py::convert_to<double>(tuple, 14);
        result.M44 = py::convert_to<double>(tuple, 15);

        return result;
    }

    PyObject* _new_Matrix3D(PyTypeObject* subclass, PyObject* args, PyObject* kwds) noexcept
    {
        pyobj_handle self_obj{(subclass->tp_alloc(subclass, 0))};
        if (!self_obj)
        {
            return nullptr;
        }

        auto self = reinterpret_cast<winrt_struct_wrapper<winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3D>*>(self_obj.get());
        std::construct_at(&self->obj);

        auto tuple_size = PyTuple_GET_SIZE(args);
        if ((tuple_size == 0) && (!kwds))
        {
            return self_obj.detach();
        }

        double _M11{};
        double _M12{};
        double _M13{};
        double _M14{};
        double _M21{};
        double _M22{};
        double _M23{};
        double _M24{};
        double _M31{};
        double _M32{};
        double _M33{};
        double _M34{};
        double _OffsetX{};
        double _OffsetY{};
        double _OffsetZ{};
        double _M44{};

        static const char* kwlist[] = {"m11", "m12", "m13", "m14", "m21", "m22", "m23", "m24", "m31", "m32", "m33", "m34", "offset_x", "offset_y", "offset_z", "m44", nullptr};
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "|dddddddddddddddd", const_cast<char**>(kwlist), &_M11, &_M12, &_M13, &_M14, &_M21, &_M22, &_M23, &_M24, &_M31, &_M32, &_M33, &_M34, &_OffsetX, &_OffsetY, &_OffsetZ, &_M44))
        {
            return nullptr;
        }

        try
        {
            self->obj.M11 = _M11;
            self->obj.M12 = _M12;
            self->obj.M13 = _M13;
            self->obj.M14 = _M14;
            self->obj.M21 = _M21;
            self->obj.M22 = _M22;
            self->obj.M23 = _M23;
            self->obj.M24 = _M24;
            self->obj.M31 = _M31;
            self->obj.M32 = _M32;
            self->obj.M33 = _M33;
            self->obj.M34 = _M34;
            self->obj.OffsetX = _OffsetX;
            self->obj.OffsetY = _OffsetY;
            self->obj.OffsetZ = _OffsetZ;
            self->obj.M44 = _M44;

            return self_obj.detach();
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

    PyObject* _replace_Matrix3D(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, PyObject* args, PyObject* kwds) noexcept
    {
        try
        {
            double _M11{self->obj.M11};
            double _M12{self->obj.M12};
            double _M13{self->obj.M13};
            double _M14{self->obj.M14};
            double _M21{self->obj.M21};
            double _M22{self->obj.M22};
            double _M23{self->obj.M23};
            double _M24{self->obj.M24};
            double _M31{self->obj.M31};
            double _M32{self->obj.M32};
            double _M33{self->obj.M33};
            double _M34{self->obj.M34};
            double _OffsetX{self->obj.OffsetX};
            double _OffsetY{self->obj.OffsetY};
            double _OffsetZ{self->obj.OffsetZ};
            double _M44{self->obj.M44};

            static const char* kwlist[] = {"m11", "m12", "m13", "m14", "m21", "m22", "m23", "m24", "m31", "m32", "m33", "m34", "offset_x", "offset_y", "offset_z", "m44", nullptr};
            if (!PyArg_ParseTupleAndKeywords(args, kwds, "|$dddddddddddddddd", const_cast<char**>(kwlist), &_M11, &_M12, &_M13, &_M14, &_M21, &_M22, &_M23, &_M24, &_M31, &_M32, &_M33, &_M34, &_OffsetX, &_OffsetY, &_OffsetZ, &_M44))
            {
                return nullptr;
            }

            auto copy = self->obj;
            copy.M11 = _M11;
            copy.M12 = _M12;
            copy.M13 = _M13;
            copy.M14 = _M14;
            copy.M21 = _M21;
            copy.M22 = _M22;
            copy.M23 = _M23;
            copy.M24 = _M24;
            copy.M31 = _M31;
            copy.M32 = _M32;
            copy.M33 = _M33;
            copy.M34 = _M34;
            copy.OffsetX = _OffsetX;
            copy.OffsetY = _OffsetY;
            copy.OffsetZ = _OffsetZ;
            copy.M44 = _M44;

            return convert(copy);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    PyObject* unpack_Matrix3D(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, PyObject* /*unused*/) noexcept
    {
        py::pyobj_handle M11{convert(self->obj.M11)};
        if (!M11)
        {
            return nullptr;
        }

        py::pyobj_handle M12{convert(self->obj.M12)};
        if (!M12)
        {
            return nullptr;
        }

        py::pyobj_handle M13{convert(self->obj.M13)};
        if (!M13)
        {
            return nullptr;
        }

        py::pyobj_handle M14{convert(self->obj.M14)};
        if (!M14)
        {
            return nullptr;
        }

        py::pyobj_handle M21{convert(self->obj.M21)};
        if (!M21)
        {
            return nullptr;
        }

        py::pyobj_handle M22{convert(self->obj.M22)};
        if (!M22)
        {
            return nullptr;
        }

        py::pyobj_handle M23{convert(self->obj.M23)};
        if (!M23)
        {
            return nullptr;
        }

        py::pyobj_handle M24{convert(self->obj.M24)};
        if (!M24)
        {
            return nullptr;
        }

        py::pyobj_handle M31{convert(self->obj.M31)};
        if (!M31)
        {
            return nullptr;
        }

        py::pyobj_handle M32{convert(self->obj.M32)};
        if (!M32)
        {
            return nullptr;
        }

        py::pyobj_handle M33{convert(self->obj.M33)};
        if (!M33)
        {
            return nullptr;
        }

        py::pyobj_handle M34{convert(self->obj.M34)};
        if (!M34)
        {
            return nullptr;
        }

        py::pyobj_handle OffsetX{convert(self->obj.OffsetX)};
        if (!OffsetX)
        {
            return nullptr;
        }

        py::pyobj_handle OffsetY{convert(self->obj.OffsetY)};
        if (!OffsetY)
        {
            return nullptr;
        }

        py::pyobj_handle OffsetZ{convert(self->obj.OffsetZ)};
        if (!OffsetZ)
        {
            return nullptr;
        }

        py::pyobj_handle M44{convert(self->obj.M44)};
        if (!M44)
        {
            return nullptr;
        }

        pyobj_handle tuple{PyTuple_New(16)};
        if (!tuple)
        {
            return nullptr;
        }

        PyTuple_SET_ITEM(tuple.get(), 0, M11.detach());
        PyTuple_SET_ITEM(tuple.get(), 1, M12.detach());
        PyTuple_SET_ITEM(tuple.get(), 2, M13.detach());
        PyTuple_SET_ITEM(tuple.get(), 3, M14.detach());
        PyTuple_SET_ITEM(tuple.get(), 4, M21.detach());
        PyTuple_SET_ITEM(tuple.get(), 5, M22.detach());
        PyTuple_SET_ITEM(tuple.get(), 6, M23.detach());
        PyTuple_SET_ITEM(tuple.get(), 7, M24.detach());
        PyTuple_SET_ITEM(tuple.get(), 8, M31.detach());
        PyTuple_SET_ITEM(tuple.get(), 9, M32.detach());
        PyTuple_SET_ITEM(tuple.get(), 10, M33.detach());
        PyTuple_SET_ITEM(tuple.get(), 11, M34.detach());
        PyTuple_SET_ITEM(tuple.get(), 12, OffsetX.detach());
        PyTuple_SET_ITEM(tuple.get(), 13, OffsetY.detach());
        PyTuple_SET_ITEM(tuple.get(), 14, OffsetZ.detach());
        PyTuple_SET_ITEM(tuple.get(), 15, M44.detach());

        return tuple.detach();
    }

    static PyMethodDef _methods_Matrix3D[] = {
        { "_assign_array_", _assign_array_Matrix3D, METH_O | METH_STATIC, nullptr },
        { "__replace__", reinterpret_cast<PyCFunction>(reinterpret_cast<void*>(_replace_Matrix3D)), METH_VARARGS | METH_KEYWORDS, nullptr },
        { "unpack", reinterpret_cast<PyCFunction>(unpack_Matrix3D), METH_NOARGS, nullptr },
        { }};

    static PyObject* Matrix3D_get_M11(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M11);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M12(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M12);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M13(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M13);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M14(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M14);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M21(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M21);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M22(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M22);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M23(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M23);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M24(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M24);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M31(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M31);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M32(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M32);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M33(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M33);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M34(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M34);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_OffsetX(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OffsetX);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_OffsetY(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OffsetY);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_OffsetZ(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OffsetZ);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Matrix3D_get_M44(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.M44);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyGetSetDef _getset_Matrix3D[] = {
        { "m11", reinterpret_cast<getter>(Matrix3D_get_M11), nullptr, nullptr, nullptr },
        { "m12", reinterpret_cast<getter>(Matrix3D_get_M12), nullptr, nullptr, nullptr },
        { "m13", reinterpret_cast<getter>(Matrix3D_get_M13), nullptr, nullptr, nullptr },
        { "m14", reinterpret_cast<getter>(Matrix3D_get_M14), nullptr, nullptr, nullptr },
        { "m21", reinterpret_cast<getter>(Matrix3D_get_M21), nullptr, nullptr, nullptr },
        { "m22", reinterpret_cast<getter>(Matrix3D_get_M22), nullptr, nullptr, nullptr },
        { "m23", reinterpret_cast<getter>(Matrix3D_get_M23), nullptr, nullptr, nullptr },
        { "m24", reinterpret_cast<getter>(Matrix3D_get_M24), nullptr, nullptr, nullptr },
        { "m31", reinterpret_cast<getter>(Matrix3D_get_M31), nullptr, nullptr, nullptr },
        { "m32", reinterpret_cast<getter>(Matrix3D_get_M32), nullptr, nullptr, nullptr },
        { "m33", reinterpret_cast<getter>(Matrix3D_get_M33), nullptr, nullptr, nullptr },
        { "m34", reinterpret_cast<getter>(Matrix3D_get_M34), nullptr, nullptr, nullptr },
        { "offset_x", reinterpret_cast<getter>(Matrix3D_get_OffsetX), nullptr, nullptr, nullptr },
        { "offset_y", reinterpret_cast<getter>(Matrix3D_get_OffsetY), nullptr, nullptr, nullptr },
        { "offset_z", reinterpret_cast<getter>(Matrix3D_get_OffsetZ), nullptr, nullptr, nullptr },
        { "m44", reinterpret_cast<getter>(Matrix3D_get_M44), nullptr, nullptr, nullptr },
        { }};

    static PyObject* _richcompare_Matrix3D(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D* self, PyObject* other, int op) noexcept
    {
        try
        {
            auto _other = py::convert_to<winrt::Microsoft::UI::Xaml::Media::Media3D::Matrix3D>(other);

            if (op == Py_EQ)
            {
                if (self->obj == _other)
                {
                    Py_RETURN_TRUE;
                }

                Py_RETURN_FALSE;
            }

            if (op == Py_NE)
            {
                if (self->obj != _other)
                {
                    Py_RETURN_TRUE;
                }

                Py_RETURN_FALSE;
            }

            Py_RETURN_NOTIMPLEMENTED;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _repr_Matrix3D(PyObject* self) noexcept
    {
        py::pyobj_handle M11{PyObject_GetAttrString(self, "m11")};
        if (!M11)
        {
            return nullptr;
        }

        py::pyobj_handle M12{PyObject_GetAttrString(self, "m12")};
        if (!M12)
        {
            return nullptr;
        }

        py::pyobj_handle M13{PyObject_GetAttrString(self, "m13")};
        if (!M13)
        {
            return nullptr;
        }

        py::pyobj_handle M14{PyObject_GetAttrString(self, "m14")};
        if (!M14)
        {
            return nullptr;
        }

        py::pyobj_handle M21{PyObject_GetAttrString(self, "m21")};
        if (!M21)
        {
            return nullptr;
        }

        py::pyobj_handle M22{PyObject_GetAttrString(self, "m22")};
        if (!M22)
        {
            return nullptr;
        }

        py::pyobj_handle M23{PyObject_GetAttrString(self, "m23")};
        if (!M23)
        {
            return nullptr;
        }

        py::pyobj_handle M24{PyObject_GetAttrString(self, "m24")};
        if (!M24)
        {
            return nullptr;
        }

        py::pyobj_handle M31{PyObject_GetAttrString(self, "m31")};
        if (!M31)
        {
            return nullptr;
        }

        py::pyobj_handle M32{PyObject_GetAttrString(self, "m32")};
        if (!M32)
        {
            return nullptr;
        }

        py::pyobj_handle M33{PyObject_GetAttrString(self, "m33")};
        if (!M33)
        {
            return nullptr;
        }

        py::pyobj_handle M34{PyObject_GetAttrString(self, "m34")};
        if (!M34)
        {
            return nullptr;
        }

        py::pyobj_handle OffsetX{PyObject_GetAttrString(self, "offset_x")};
        if (!OffsetX)
        {
            return nullptr;
        }

        py::pyobj_handle OffsetY{PyObject_GetAttrString(self, "offset_y")};
        if (!OffsetY)
        {
            return nullptr;
        }

        py::pyobj_handle OffsetZ{PyObject_GetAttrString(self, "offset_z")};
        if (!OffsetZ)
        {
            return nullptr;
        }

        py::pyobj_handle M44{PyObject_GetAttrString(self, "m44")};
        if (!M44)
        {
            return nullptr;
        }

        return PyUnicode_FromFormat("Matrix3D(m11=%R, m12=%R, m13=%R, m14=%R, m21=%R, m22=%R, m23=%R, m24=%R, m31=%R, m32=%R, m33=%R, m34=%R, offset_x=%R, offset_y=%R, offset_z=%R, m44=%R)", M11.get(), M12.get(), M13.get(), M14.get(), M21.get(), M22.get(), M23.get(), M24.get(), M31.get(), M32.get(), M33.get(), M34.get(), OffsetX.get(), OffsetY.get(), OffsetZ.get(), M44.get());
    }

    static PyType_Slot _type_slots_Matrix3D[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_Matrix3D) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Matrix3D) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Matrix3D) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Matrix3D) },
        { Py_tp_richcompare, reinterpret_cast<void*>(_richcompare_Matrix3D) },
        { Py_tp_repr, reinterpret_cast<void*>(_repr_Matrix3D) },
        { }};

    static PyType_Spec type_spec_Matrix3D = {
        "winui3._winui3_microsoft_ui_xaml_media_media3d.Matrix3D",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Media::Media3D::Matrix3D),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Matrix3D};

    // ----- Microsoft.UI.Xaml.Media.Media3D Initialization --------------------

    PyDoc_STRVAR(module_doc, "Microsoft.UI.Xaml.Media.Media3D");

    static PyModuleDef module_def = {
        PyModuleDef_HEAD_INIT,
        "_winui3_microsoft_ui_xaml_media_media3d",
        module_doc,
        0,
        nullptr,
        nullptr,
        nullptr,
        nullptr,
        nullptr};
} // py::cpp::Microsoft::UI::Xaml::Media::Media3D

PyMODINIT_FUNC PyInit__winui3_microsoft_ui_xaml_media_media3d(void) noexcept
{
    using namespace py::cpp::Microsoft::UI::Xaml::Media::Media3D;

    if (py::import_winrt_runtime() == -1)
    {
        return nullptr;
    }

    py::pyobj_handle module{PyModule_Create(&module_def)};

    if (!module)
    {
        return nullptr;
    }

    auto inspectable_meta_type = py::get_inspectable_meta_type();
    if (!inspectable_meta_type)
    {
        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;
    }

    py::pyobj_handle microsoft_ui_xaml_module{PyImport_ImportModule("winui3._winui3_microsoft_ui_xaml")};
    if (!microsoft_ui_xaml_module)
    {
        return nullptr;
    }

    py::pyobj_handle microsoft_ui_xaml_DependencyObject_type{PyObject_GetAttrString(microsoft_ui_xaml_module.get(), "DependencyObject")};
    if (!microsoft_ui_xaml_DependencyObject_type)
    {
        return nullptr;
    }

    py::pyobj_handle Transform3D_Static_bases{PyTuple_Pack(1, reinterpret_cast<PyObject*>(Py_TYPE(microsoft_ui_xaml_DependencyObject_type.get())))};
    if (!Transform3D_Static_bases)
    {
        return nullptr;
    }

    py::pyobj_handle type_Transform3D_Static{PyType_FromSpecWithBases(&type_spec_Transform3D_Static, Transform3D_Static_bases.get())};
    if (!type_Transform3D_Static)
    {
        return nullptr;
    }

    py::pyobj_handle Transform3D_bases{PyTuple_Pack(1, microsoft_ui_xaml_DependencyObject_type.get())};
    if (!Transform3D_bases)
    {
        return nullptr;
    }

    py::pytype_handle Transform3D_type{py::register_python_type(module.get(), &type_spec_Transform3D, Transform3D_bases.get(), reinterpret_cast<PyTypeObject*>(type_Transform3D_Static.get()))};
    if (!Transform3D_type)
    {
        return nullptr;
    }

    py::pyobj_handle CompositeTransform3D_Static_bases{PyTuple_Pack(1, reinterpret_cast<PyObject*>(Py_TYPE(Transform3D_type.get())))};
    if (!CompositeTransform3D_Static_bases)
    {
        return nullptr;
    }

    py::pyobj_handle type_CompositeTransform3D_Static{PyType_FromSpecWithBases(&type_spec_CompositeTransform3D_Static, CompositeTransform3D_Static_bases.get())};
    if (!type_CompositeTransform3D_Static)
    {
        return nullptr;
    }

    py::pyobj_handle CompositeTransform3D_bases{PyTuple_Pack(1, Transform3D_type.get())};
    if (!CompositeTransform3D_bases)
    {
        return nullptr;
    }

    py::pytype_handle CompositeTransform3D_type{py::register_python_type(module.get(), &type_spec_CompositeTransform3D, CompositeTransform3D_bases.get(), reinterpret_cast<PyTypeObject*>(type_CompositeTransform3D_Static.get()))};
    if (!CompositeTransform3D_type)
    {
        return nullptr;
    }

    py::pyobj_handle Matrix3DHelper_Static_bases{PyTuple_Pack(1, reinterpret_cast<PyObject*>(inspectable_meta_type))};
    if (!Matrix3DHelper_Static_bases)
    {
        return nullptr;
    }

    py::pyobj_handle type_Matrix3DHelper_Static{PyType_FromSpecWithBases(&type_spec_Matrix3DHelper_Static, Matrix3DHelper_Static_bases.get())};
    if (!type_Matrix3DHelper_Static)
    {
        return nullptr;
    }

    py::pytype_handle Matrix3DHelper_type{py::register_python_type(module.get(), &type_spec_Matrix3DHelper, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Matrix3DHelper_Static.get()))};
    if (!Matrix3DHelper_type)
    {
        return nullptr;
    }

    py::pyobj_handle PerspectiveTransform3D_Static_bases{PyTuple_Pack(1, reinterpret_cast<PyObject*>(Py_TYPE(Transform3D_type.get())))};
    if (!PerspectiveTransform3D_Static_bases)
    {
        return nullptr;
    }

    py::pyobj_handle type_PerspectiveTransform3D_Static{PyType_FromSpecWithBases(&type_spec_PerspectiveTransform3D_Static, PerspectiveTransform3D_Static_bases.get())};
    if (!type_PerspectiveTransform3D_Static)
    {
        return nullptr;
    }

    py::pyobj_handle PerspectiveTransform3D_bases{PyTuple_Pack(1, Transform3D_type.get())};
    if (!PerspectiveTransform3D_bases)
    {
        return nullptr;
    }

    py::pytype_handle PerspectiveTransform3D_type{py::register_python_type(module.get(), &type_spec_PerspectiveTransform3D, PerspectiveTransform3D_bases.get(), reinterpret_cast<PyTypeObject*>(type_PerspectiveTransform3D_Static.get()))};
    if (!PerspectiveTransform3D_type)
    {
        return nullptr;
    }

    py::pytype_handle Matrix3D_type{py::register_python_type(module.get(), &type_spec_Matrix3D, nullptr, nullptr)};
    if (!Matrix3D_type)
    {
        return nullptr;
    }

    py::pyobj_handle Matrix3D_from_tuple_capsule{PyCapsule_New(reinterpret_cast<void*>(Matrix3D_from_tuple),"winui3._winui3_microsoft_ui_xaml_media_media3d.Matrix3D_from_tuple", nullptr)};
    if (!Matrix3D_from_tuple_capsule)
    {
        return nullptr;
    }

    if (PyModule_AddObjectRef(module.get(), "Matrix3D_from_tuple", Matrix3D_from_tuple_capsule.get()) == -1)
    {
        return nullptr;
    }

    return module.detach();
}
