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

#include "pybase.h"
#include "py.Windows.Graphics.Holographic.h"


PyObject* py::converter<winrt::Windows::Graphics::Holographic::HolographicAdapterId>::convert(winrt::Windows::Graphics::Holographic::HolographicAdapterId instance) noexcept
{
    auto type = py::get_python_type<winrt::Windows::Graphics::Holographic::HolographicAdapterId>();
    if (!type)
    {
        return nullptr;
    }

    return py::wrap_struct(instance, type);
}
winrt::Windows::Graphics::Holographic::HolographicAdapterId py::converter<winrt::Windows::Graphics::Holographic::HolographicAdapterId>::convert_to(PyObject* obj)
{
    throw_if_pyobj_null(obj);

    auto type =  py::get_python_type<winrt::Windows::Graphics::Holographic::HolographicAdapterId>();

    if (!type) {
        throw python_exception();
    }

    if (Py_TYPE(obj) == type)
    {
        return reinterpret_cast<py::winrt_struct_wrapper<winrt::Windows::Graphics::Holographic::HolographicAdapterId>*>(obj)->obj;
    }

    PyErr_SetString(PyExc_TypeError, "expecting winrt::Windows::Graphics::Holographic::HolographicAdapterId");
    throw python_exception();
}

PyObject* py::converter<winrt::Windows::Graphics::Holographic::HolographicFrameId>::convert(winrt::Windows::Graphics::Holographic::HolographicFrameId instance) noexcept
{
    auto type = py::get_python_type<winrt::Windows::Graphics::Holographic::HolographicFrameId>();
    if (!type)
    {
        return nullptr;
    }

    return py::wrap_struct(instance, type);
}
winrt::Windows::Graphics::Holographic::HolographicFrameId py::converter<winrt::Windows::Graphics::Holographic::HolographicFrameId>::convert_to(PyObject* obj)
{
    throw_if_pyobj_null(obj);

    auto type =  py::get_python_type<winrt::Windows::Graphics::Holographic::HolographicFrameId>();

    if (!type) {
        throw python_exception();
    }

    if (Py_TYPE(obj) == type)
    {
        return reinterpret_cast<py::winrt_struct_wrapper<winrt::Windows::Graphics::Holographic::HolographicFrameId>*>(obj)->obj;
    }

    PyErr_SetString(PyExc_TypeError, "expecting winrt::Windows::Graphics::Holographic::HolographicFrameId");
    throw python_exception();
}

PyObject* py::converter<winrt::Windows::Graphics::Holographic::HolographicStereoTransform>::convert(winrt::Windows::Graphics::Holographic::HolographicStereoTransform instance) noexcept
{
    auto type = py::get_python_type<winrt::Windows::Graphics::Holographic::HolographicStereoTransform>();
    if (!type)
    {
        return nullptr;
    }

    return py::wrap_struct(instance, type);
}
winrt::Windows::Graphics::Holographic::HolographicStereoTransform py::converter<winrt::Windows::Graphics::Holographic::HolographicStereoTransform>::convert_to(PyObject* obj)
{
    throw_if_pyobj_null(obj);

    auto type =  py::get_python_type<winrt::Windows::Graphics::Holographic::HolographicStereoTransform>();

    if (!type) {
        throw python_exception();
    }

    if (Py_TYPE(obj) == type)
    {
        return reinterpret_cast<py::winrt_struct_wrapper<winrt::Windows::Graphics::Holographic::HolographicStereoTransform>*>(obj)->obj;
    }

    PyErr_SetString(PyExc_TypeError, "expecting winrt::Windows::Graphics::Holographic::HolographicStereoTransform");
    throw python_exception();
}

namespace py::cpp::Windows::Graphics::Holographic
{
    struct module_state
    {
        PyObject* type_HolographicDepthReprojectionMethod;
        PyObject* type_HolographicFramePresentResult;
        PyObject* type_HolographicFramePresentWaitBehavior;
        PyObject* type_HolographicReprojectionMode;
        PyObject* type_HolographicSpaceUserPresence;
        PyObject* type_HolographicViewConfigurationKind;
        PyTypeObject* type_HolographicCamera;
        PyTypeObject* type_HolographicCameraPose;
        PyTypeObject* type_HolographicCameraRenderingParameters;
        PyTypeObject* type_HolographicCameraViewportParameters;
        PyTypeObject* type_HolographicDisplay;
        PyTypeObject* type_HolographicFrame;
        PyTypeObject* type_HolographicFramePrediction;
        PyTypeObject* type_HolographicFramePresentationMonitor;
        PyTypeObject* type_HolographicFramePresentationReport;
        PyTypeObject* type_HolographicFrameRenderingReport;
        PyTypeObject* type_HolographicFrameScanoutMonitor;
        PyTypeObject* type_HolographicFrameScanoutReport;
        PyTypeObject* type_HolographicQuadLayer;
        PyTypeObject* type_HolographicQuadLayerUpdateParameters;
        PyTypeObject* type_HolographicSpace;
        PyTypeObject* type_HolographicSpaceCameraAddedEventArgs;
        PyTypeObject* type_HolographicSpaceCameraRemovedEventArgs;
        PyTypeObject* type_HolographicViewConfiguration;
        PyTypeObject* type_HolographicAdapterId;
        PyTypeObject* type_HolographicFrameId;
        PyTypeObject* type_HolographicStereoTransform;
    };

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

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

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

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


        Py_RETURN_NONE;
    }

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

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

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

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


        Py_RETURN_NONE;
    }

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

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

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

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


        Py_RETURN_NONE;
    }

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

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

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

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


        Py_RETURN_NONE;
    }

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

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

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

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


        Py_RETURN_NONE;
    }

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

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

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

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


        Py_RETURN_NONE;
    }

    // ----- HolographicCamera class --------------------
    static constexpr const char* const type_name_HolographicCamera = "HolographicCamera";

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

    static void _dealloc_HolographicCamera(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicCamera_SetFarPlaneDistance(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"SetFarPlaneDistance", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* HolographicCamera_SetNearPlaneDistance(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"SetNearPlaneDistance", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* HolographicCamera_get_ViewportScaleFactor(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"ViewportScaleFactor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int HolographicCamera_put_ViewportScaleFactor(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"ViewportScaleFactor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

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

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

    static PyObject* HolographicCamera_get_Id(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"Id"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCamera_get_IsStereo(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"IsStereo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCamera_get_RenderTargetSize(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"RenderTargetSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCamera_get_Display(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"Display"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCamera_get_LeftViewportParameters(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"LeftViewportParameters"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCamera_get_RightViewportParameters(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"RightViewportParameters"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCamera_get_IsPrimaryLayerEnabled(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"IsPrimaryLayerEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int HolographicCamera_put_IsPrimaryLayerEnabled(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"IsPrimaryLayerEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

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

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

    static PyObject* HolographicCamera_get_MaxQuadLayerCount(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"MaxQuadLayerCount"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCamera_get_QuadLayers(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"QuadLayers"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCamera_get_CanOverrideViewport(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"CanOverrideViewport"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCamera_get_IsHardwareContentProtectionEnabled(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"IsHardwareContentProtectionEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int HolographicCamera_put_IsHardwareContentProtectionEnabled(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"IsHardwareContentProtectionEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

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

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

    static PyObject* HolographicCamera_get_IsHardwareContentProtectionSupported(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"IsHardwareContentProtectionSupported"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCamera_get_ViewConfiguration(py::wrapper::Windows::Graphics::Holographic::HolographicCamera* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCamera", L"ViewConfiguration"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicCamera(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicCamera>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicCamera(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicCamera>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicCamera[] = {
        { "set_far_plane_distance", reinterpret_cast<PyCFunction>(HolographicCamera_SetFarPlaneDistance), METH_VARARGS, nullptr },
        { "set_near_plane_distance", reinterpret_cast<PyCFunction>(HolographicCamera_SetNearPlaneDistance), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HolographicCamera, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicCamera), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicCamera[] = {
        { "viewport_scale_factor", reinterpret_cast<getter>(HolographicCamera_get_ViewportScaleFactor), reinterpret_cast<setter>(HolographicCamera_put_ViewportScaleFactor), nullptr, nullptr },
        { "id", reinterpret_cast<getter>(HolographicCamera_get_Id), nullptr, nullptr, nullptr },
        { "is_stereo", reinterpret_cast<getter>(HolographicCamera_get_IsStereo), nullptr, nullptr, nullptr },
        { "render_target_size", reinterpret_cast<getter>(HolographicCamera_get_RenderTargetSize), nullptr, nullptr, nullptr },
        { "display", reinterpret_cast<getter>(HolographicCamera_get_Display), nullptr, nullptr, nullptr },
        { "left_viewport_parameters", reinterpret_cast<getter>(HolographicCamera_get_LeftViewportParameters), nullptr, nullptr, nullptr },
        { "right_viewport_parameters", reinterpret_cast<getter>(HolographicCamera_get_RightViewportParameters), nullptr, nullptr, nullptr },
        { "is_primary_layer_enabled", reinterpret_cast<getter>(HolographicCamera_get_IsPrimaryLayerEnabled), reinterpret_cast<setter>(HolographicCamera_put_IsPrimaryLayerEnabled), nullptr, nullptr },
        { "max_quad_layer_count", reinterpret_cast<getter>(HolographicCamera_get_MaxQuadLayerCount), nullptr, nullptr, nullptr },
        { "quad_layers", reinterpret_cast<getter>(HolographicCamera_get_QuadLayers), nullptr, nullptr, nullptr },
        { "can_override_viewport", reinterpret_cast<getter>(HolographicCamera_get_CanOverrideViewport), nullptr, nullptr, nullptr },
        { "is_hardware_content_protection_enabled", reinterpret_cast<getter>(HolographicCamera_get_IsHardwareContentProtectionEnabled), reinterpret_cast<setter>(HolographicCamera_put_IsHardwareContentProtectionEnabled), nullptr, nullptr },
        { "is_hardware_content_protection_supported", reinterpret_cast<getter>(HolographicCamera_get_IsHardwareContentProtectionSupported), nullptr, nullptr, nullptr },
        { "view_configuration", reinterpret_cast<getter>(HolographicCamera_get_ViewConfiguration), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicCamera[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicCamera) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicCamera) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicCamera) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicCamera) },
        { },
    };

    static PyType_Spec type_spec_HolographicCamera =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicCamera",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicCamera),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicCamera
    };

    // ----- HolographicCameraPose class --------------------
    static constexpr const char* const type_name_HolographicCameraPose = "HolographicCameraPose";

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

    static void _dealloc_HolographicCameraPose(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicCameraPose_OverrideProjectionTransform(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCameraPose", L"OverrideProjectionTransform", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::Holographic::HolographicStereoTransform>(args, 0);

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

    static PyObject* HolographicCameraPose_OverrideViewTransform(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCameraPose", L"OverrideViewTransform", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Perception::Spatial::SpatialCoordinateSystem>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Graphics::Holographic::HolographicStereoTransform>(args, 1);

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

    static PyObject* HolographicCameraPose_OverrideViewport(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCameraPose", L"OverrideViewport", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

    static PyObject* HolographicCameraPose_TryGetCullingFrustum(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCameraPose", L"TryGetCullingFrustum", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Perception::Spatial::SpatialCoordinateSystem>(args, 0);

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

    static PyObject* HolographicCameraPose_TryGetViewTransform(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCameraPose", L"TryGetViewTransform", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Perception::Spatial::SpatialCoordinateSystem>(args, 0);

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

    static PyObject* HolographicCameraPose_TryGetVisibleFrustum(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCameraPose", L"TryGetVisibleFrustum", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Perception::Spatial::SpatialCoordinateSystem>(args, 0);

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

    static PyObject* HolographicCameraPose_get_FarPlaneDistance(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraPose", L"FarPlaneDistance"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCameraPose_get_HolographicCamera(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraPose", L"HolographicCamera"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCameraPose_get_NearPlaneDistance(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraPose", L"NearPlaneDistance"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCameraPose_get_ProjectionTransform(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraPose", L"ProjectionTransform"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCameraPose_get_Viewport(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraPose", L"Viewport"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicCameraPose(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicCameraPose>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicCameraPose(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicCameraPose>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicCameraPose[] = {
        { "override_projection_transform", reinterpret_cast<PyCFunction>(HolographicCameraPose_OverrideProjectionTransform), METH_VARARGS, nullptr },
        { "override_view_transform", reinterpret_cast<PyCFunction>(HolographicCameraPose_OverrideViewTransform), METH_VARARGS, nullptr },
        { "override_viewport", reinterpret_cast<PyCFunction>(HolographicCameraPose_OverrideViewport), METH_VARARGS, nullptr },
        { "try_get_culling_frustum", reinterpret_cast<PyCFunction>(HolographicCameraPose_TryGetCullingFrustum), METH_VARARGS, nullptr },
        { "try_get_view_transform", reinterpret_cast<PyCFunction>(HolographicCameraPose_TryGetViewTransform), METH_VARARGS, nullptr },
        { "try_get_visible_frustum", reinterpret_cast<PyCFunction>(HolographicCameraPose_TryGetVisibleFrustum), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HolographicCameraPose, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicCameraPose), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicCameraPose[] = {
        { "far_plane_distance", reinterpret_cast<getter>(HolographicCameraPose_get_FarPlaneDistance), nullptr, nullptr, nullptr },
        { "holographic_camera", reinterpret_cast<getter>(HolographicCameraPose_get_HolographicCamera), nullptr, nullptr, nullptr },
        { "near_plane_distance", reinterpret_cast<getter>(HolographicCameraPose_get_NearPlaneDistance), nullptr, nullptr, nullptr },
        { "projection_transform", reinterpret_cast<getter>(HolographicCameraPose_get_ProjectionTransform), nullptr, nullptr, nullptr },
        { "viewport", reinterpret_cast<getter>(HolographicCameraPose_get_Viewport), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicCameraPose[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicCameraPose) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicCameraPose) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicCameraPose) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicCameraPose) },
        { },
    };

    static PyType_Spec type_spec_HolographicCameraPose =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicCameraPose",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicCameraPose),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicCameraPose
    };

    // ----- HolographicCameraRenderingParameters class --------------------
    static constexpr const char* const type_name_HolographicCameraRenderingParameters = "HolographicCameraRenderingParameters";

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

    static void _dealloc_HolographicCameraRenderingParameters(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicCameraRenderingParameters_CommitDirect3D11DepthBuffer(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"CommitDirect3D11DepthBuffer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::DirectX::Direct3D11::IDirect3DSurface>(args, 0);

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

    static PyObject* HolographicCameraRenderingParameters_SetFocusPoint(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"SetFocusPoint", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Perception::Spatial::SpatialCoordinateSystem>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Numerics::float3>(args, 1);

                self->obj.SetFocusPoint(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"SetFocusPoint", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Perception::Spatial::SpatialCoordinateSystem>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Numerics::float3>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Foundation::Numerics::float3>(args, 2);

                self->obj.SetFocusPoint(param0, param1, param2);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 4)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"SetFocusPoint", 4))
            {
                py::set_arg_count_version_error(4);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Perception::Spatial::SpatialCoordinateSystem>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Numerics::float3>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Foundation::Numerics::float3>(args, 2);
                auto param3 = py::convert_to<winrt::Windows::Foundation::Numerics::float3>(args, 3);

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

    static PyObject* HolographicCameraRenderingParameters_get_Direct3D11BackBuffer(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"Direct3D11BackBuffer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCameraRenderingParameters_get_Direct3D11Device(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"Direct3D11Device"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCameraRenderingParameters_get_ReprojectionMode(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"ReprojectionMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int HolographicCameraRenderingParameters_put_ReprojectionMode(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"ReprojectionMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Graphics::Holographic::HolographicReprojectionMode>(arg);

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

    static PyObject* HolographicCameraRenderingParameters_get_IsContentProtectionEnabled(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"IsContentProtectionEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int HolographicCameraRenderingParameters_put_IsContentProtectionEnabled(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"IsContentProtectionEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

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

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

    static PyObject* HolographicCameraRenderingParameters_get_DepthReprojectionMethod(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"DepthReprojectionMethod"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int HolographicCameraRenderingParameters_put_DepthReprojectionMethod(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraRenderingParameters", L"DepthReprojectionMethod"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Graphics::Holographic::HolographicDepthReprojectionMethod>(arg);

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

    static PyObject* _assign_array_HolographicCameraRenderingParameters(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicCameraRenderingParameters>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicCameraRenderingParameters(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicCameraRenderingParameters>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicCameraRenderingParameters[] = {
        { "commit_direct3_d11_depth_buffer", reinterpret_cast<PyCFunction>(HolographicCameraRenderingParameters_CommitDirect3D11DepthBuffer), METH_VARARGS, nullptr },
        { "set_focus_point", reinterpret_cast<PyCFunction>(HolographicCameraRenderingParameters_SetFocusPoint), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HolographicCameraRenderingParameters, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicCameraRenderingParameters), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicCameraRenderingParameters[] = {
        { "direct3_d11_back_buffer", reinterpret_cast<getter>(HolographicCameraRenderingParameters_get_Direct3D11BackBuffer), nullptr, nullptr, nullptr },
        { "direct3_d11_device", reinterpret_cast<getter>(HolographicCameraRenderingParameters_get_Direct3D11Device), nullptr, nullptr, nullptr },
        { "reprojection_mode", reinterpret_cast<getter>(HolographicCameraRenderingParameters_get_ReprojectionMode), reinterpret_cast<setter>(HolographicCameraRenderingParameters_put_ReprojectionMode), nullptr, nullptr },
        { "is_content_protection_enabled", reinterpret_cast<getter>(HolographicCameraRenderingParameters_get_IsContentProtectionEnabled), reinterpret_cast<setter>(HolographicCameraRenderingParameters_put_IsContentProtectionEnabled), nullptr, nullptr },
        { "depth_reprojection_method", reinterpret_cast<getter>(HolographicCameraRenderingParameters_get_DepthReprojectionMethod), reinterpret_cast<setter>(HolographicCameraRenderingParameters_put_DepthReprojectionMethod), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicCameraRenderingParameters[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicCameraRenderingParameters) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicCameraRenderingParameters) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicCameraRenderingParameters) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicCameraRenderingParameters) },
        { },
    };

    static PyType_Spec type_spec_HolographicCameraRenderingParameters =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicCameraRenderingParameters",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicCameraRenderingParameters),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicCameraRenderingParameters
    };

    // ----- HolographicCameraViewportParameters class --------------------
    static constexpr const char* const type_name_HolographicCameraViewportParameters = "HolographicCameraViewportParameters";

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

    static void _dealloc_HolographicCameraViewportParameters(py::wrapper::Windows::Graphics::Holographic::HolographicCameraViewportParameters* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicCameraViewportParameters_get_HiddenAreaMesh(py::wrapper::Windows::Graphics::Holographic::HolographicCameraViewportParameters* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraViewportParameters", L"HiddenAreaMesh"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicCameraViewportParameters_get_VisibleAreaMesh(py::wrapper::Windows::Graphics::Holographic::HolographicCameraViewportParameters* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicCameraViewportParameters", L"VisibleAreaMesh"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicCameraViewportParameters(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicCameraViewportParameters>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicCameraViewportParameters(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicCameraViewportParameters>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicCameraViewportParameters[] = {
        { "_assign_array_", _assign_array_HolographicCameraViewportParameters, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicCameraViewportParameters), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicCameraViewportParameters[] = {
        { "hidden_area_mesh", reinterpret_cast<getter>(HolographicCameraViewportParameters_get_HiddenAreaMesh), nullptr, nullptr, nullptr },
        { "visible_area_mesh", reinterpret_cast<getter>(HolographicCameraViewportParameters_get_VisibleAreaMesh), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicCameraViewportParameters[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicCameraViewportParameters) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicCameraViewportParameters) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicCameraViewportParameters) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicCameraViewportParameters) },
        { },
    };

    static PyType_Spec type_spec_HolographicCameraViewportParameters =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicCameraViewportParameters",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicCameraViewportParameters),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicCameraViewportParameters
    };

    // ----- HolographicDisplay class --------------------
    static constexpr const char* const type_name_HolographicDisplay = "HolographicDisplay";

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

    static void _dealloc_HolographicDisplay(py::wrapper::Windows::Graphics::Holographic::HolographicDisplay* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicDisplay", L"GetDefault", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::Graphics::Holographic::HolographicDisplay::GetDefault());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HolographicDisplay_TryGetViewConfiguration(py::wrapper::Windows::Graphics::Holographic::HolographicDisplay* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicDisplay", L"TryGetViewConfiguration", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::Holographic::HolographicViewConfigurationKind>(args, 0);

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

    static PyObject* HolographicDisplay_get_AdapterId(py::wrapper::Windows::Graphics::Holographic::HolographicDisplay* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicDisplay", L"AdapterId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicDisplay_get_DisplayName(py::wrapper::Windows::Graphics::Holographic::HolographicDisplay* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicDisplay", L"DisplayName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicDisplay_get_IsOpaque(py::wrapper::Windows::Graphics::Holographic::HolographicDisplay* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicDisplay", L"IsOpaque"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicDisplay_get_IsStereo(py::wrapper::Windows::Graphics::Holographic::HolographicDisplay* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicDisplay", L"IsStereo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicDisplay_get_MaxViewportSize(py::wrapper::Windows::Graphics::Holographic::HolographicDisplay* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicDisplay", L"MaxViewportSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicDisplay_get_SpatialLocator(py::wrapper::Windows::Graphics::Holographic::HolographicDisplay* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicDisplay", L"SpatialLocator"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicDisplay_get_RefreshRate(py::wrapper::Windows::Graphics::Holographic::HolographicDisplay* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicDisplay", L"RefreshRate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicDisplay(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicDisplay>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicDisplay(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicDisplay>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicDisplay[] = {
        { "get_default", reinterpret_cast<PyCFunction>(HolographicDisplay_GetDefault), METH_VARARGS | METH_STATIC, nullptr },
        { "try_get_view_configuration", reinterpret_cast<PyCFunction>(HolographicDisplay_TryGetViewConfiguration), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HolographicDisplay, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicDisplay), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicDisplay[] = {
        { "adapter_id", reinterpret_cast<getter>(HolographicDisplay_get_AdapterId), nullptr, nullptr, nullptr },
        { "display_name", reinterpret_cast<getter>(HolographicDisplay_get_DisplayName), nullptr, nullptr, nullptr },
        { "is_opaque", reinterpret_cast<getter>(HolographicDisplay_get_IsOpaque), nullptr, nullptr, nullptr },
        { "is_stereo", reinterpret_cast<getter>(HolographicDisplay_get_IsStereo), nullptr, nullptr, nullptr },
        { "max_viewport_size", reinterpret_cast<getter>(HolographicDisplay_get_MaxViewportSize), nullptr, nullptr, nullptr },
        { "spatial_locator", reinterpret_cast<getter>(HolographicDisplay_get_SpatialLocator), nullptr, nullptr, nullptr },
        { "refresh_rate", reinterpret_cast<getter>(HolographicDisplay_get_RefreshRate), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicDisplay[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicDisplay) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicDisplay) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicDisplay) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicDisplay) },
        { },
    };

    static PyType_Spec type_spec_HolographicDisplay =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicDisplay",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicDisplay),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicDisplay
    };

    // ----- HolographicFrame class --------------------
    static constexpr const char* const type_name_HolographicFrame = "HolographicFrame";

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

    static void _dealloc_HolographicFrame(py::wrapper::Windows::Graphics::Holographic::HolographicFrame* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicFrame_GetQuadLayerUpdateParameters(py::wrapper::Windows::Graphics::Holographic::HolographicFrame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicFrame", L"GetQuadLayerUpdateParameters", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::Holographic::HolographicQuadLayer>(args, 0);

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

    static PyObject* HolographicFrame_GetRenderingParameters(py::wrapper::Windows::Graphics::Holographic::HolographicFrame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicFrame", L"GetRenderingParameters", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::Holographic::HolographicCameraPose>(args, 0);

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

    static PyObject* HolographicFrame_PresentUsingCurrentPrediction(py::wrapper::Windows::Graphics::Holographic::HolographicFrame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicFrame", L"PresentUsingCurrentPrediction", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.PresentUsingCurrentPrediction());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicFrame", L"PresentUsingCurrentPrediction", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::Holographic::HolographicFramePresentWaitBehavior>(args, 0);

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

    static PyObject* HolographicFrame_UpdateCurrentPrediction(py::wrapper::Windows::Graphics::Holographic::HolographicFrame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicFrame", L"UpdateCurrentPrediction", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* HolographicFrame_WaitForFrameToFinish(py::wrapper::Windows::Graphics::Holographic::HolographicFrame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicFrame", L"WaitForFrameToFinish", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* HolographicFrame_get_AddedCameras(py::wrapper::Windows::Graphics::Holographic::HolographicFrame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrame", L"AddedCameras"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFrame_get_CurrentPrediction(py::wrapper::Windows::Graphics::Holographic::HolographicFrame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrame", L"CurrentPrediction"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

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

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

    static PyObject* HolographicFrame_get_RemovedCameras(py::wrapper::Windows::Graphics::Holographic::HolographicFrame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrame", L"RemovedCameras"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFrame_get_Id(py::wrapper::Windows::Graphics::Holographic::HolographicFrame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrame", L"Id"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicFrame(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicFrame>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicFrame(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicFrame>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicFrame[] = {
        { "get_quad_layer_update_parameters", reinterpret_cast<PyCFunction>(HolographicFrame_GetQuadLayerUpdateParameters), METH_VARARGS, nullptr },
        { "get_rendering_parameters", reinterpret_cast<PyCFunction>(HolographicFrame_GetRenderingParameters), METH_VARARGS, nullptr },
        { "present_using_current_prediction", reinterpret_cast<PyCFunction>(HolographicFrame_PresentUsingCurrentPrediction), METH_VARARGS, nullptr },
        { "update_current_prediction", reinterpret_cast<PyCFunction>(HolographicFrame_UpdateCurrentPrediction), METH_VARARGS, nullptr },
        { "wait_for_frame_to_finish", reinterpret_cast<PyCFunction>(HolographicFrame_WaitForFrameToFinish), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HolographicFrame, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicFrame), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicFrame[] = {
        { "added_cameras", reinterpret_cast<getter>(HolographicFrame_get_AddedCameras), nullptr, nullptr, nullptr },
        { "current_prediction", reinterpret_cast<getter>(HolographicFrame_get_CurrentPrediction), nullptr, nullptr, nullptr },
        { "duration", reinterpret_cast<getter>(HolographicFrame_get_Duration), nullptr, nullptr, nullptr },
        { "removed_cameras", reinterpret_cast<getter>(HolographicFrame_get_RemovedCameras), nullptr, nullptr, nullptr },
        { "id", reinterpret_cast<getter>(HolographicFrame_get_Id), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicFrame[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicFrame) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicFrame) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicFrame) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicFrame) },
        { },
    };

    static PyType_Spec type_spec_HolographicFrame =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicFrame",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicFrame),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicFrame
    };

    // ----- HolographicFramePrediction class --------------------
    static constexpr const char* const type_name_HolographicFramePrediction = "HolographicFramePrediction";

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

    static void _dealloc_HolographicFramePrediction(py::wrapper::Windows::Graphics::Holographic::HolographicFramePrediction* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicFramePrediction_get_CameraPoses(py::wrapper::Windows::Graphics::Holographic::HolographicFramePrediction* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFramePrediction", L"CameraPoses"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFramePrediction_get_Timestamp(py::wrapper::Windows::Graphics::Holographic::HolographicFramePrediction* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFramePrediction", L"Timestamp"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicFramePrediction(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicFramePrediction>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicFramePrediction(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicFramePrediction>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicFramePrediction[] = {
        { "_assign_array_", _assign_array_HolographicFramePrediction, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicFramePrediction), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicFramePrediction[] = {
        { "camera_poses", reinterpret_cast<getter>(HolographicFramePrediction_get_CameraPoses), nullptr, nullptr, nullptr },
        { "timestamp", reinterpret_cast<getter>(HolographicFramePrediction_get_Timestamp), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicFramePrediction[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicFramePrediction) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicFramePrediction) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicFramePrediction) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicFramePrediction) },
        { },
    };

    static PyType_Spec type_spec_HolographicFramePrediction =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicFramePrediction",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicFramePrediction),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicFramePrediction
    };

    // ----- HolographicFramePresentationMonitor class --------------------
    static constexpr const char* const type_name_HolographicFramePresentationMonitor = "HolographicFramePresentationMonitor";

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

    static void _dealloc_HolographicFramePresentationMonitor(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationMonitor* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicFramePresentationMonitor_Close(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationMonitor* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicFramePresentationMonitor", L"Close", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* HolographicFramePresentationMonitor_ReadReports(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationMonitor* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicFramePresentationMonitor", L"ReadReports", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* _assign_array_HolographicFramePresentationMonitor(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicFramePresentationMonitor>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicFramePresentationMonitor(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicFramePresentationMonitor>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_HolographicFramePresentationMonitor(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationMonitor* self) noexcept
    {
        Py_INCREF(self);
        return reinterpret_cast<PyObject*>(self);
    }

    static PyObject* _exit_HolographicFramePresentationMonitor(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationMonitor* self) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicFramePresentationMonitor[] = {
        { "close", reinterpret_cast<PyCFunction>(HolographicFramePresentationMonitor_Close), METH_VARARGS, nullptr },
        { "read_reports", reinterpret_cast<PyCFunction>(HolographicFramePresentationMonitor_ReadReports), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HolographicFramePresentationMonitor, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicFramePresentationMonitor), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_HolographicFramePresentationMonitor), METH_NOARGS, nullptr },
        { "__exit__",  reinterpret_cast<PyCFunction>(_exit_HolographicFramePresentationMonitor), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicFramePresentationMonitor[] = {
        { }
    };

    static PyType_Slot _type_slots_HolographicFramePresentationMonitor[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicFramePresentationMonitor) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicFramePresentationMonitor) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicFramePresentationMonitor) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicFramePresentationMonitor) },
        { },
    };

    static PyType_Spec type_spec_HolographicFramePresentationMonitor =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicFramePresentationMonitor",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationMonitor),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicFramePresentationMonitor
    };

    // ----- HolographicFramePresentationReport class --------------------
    static constexpr const char* const type_name_HolographicFramePresentationReport = "HolographicFramePresentationReport";

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

    static void _dealloc_HolographicFramePresentationReport(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationReport* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicFramePresentationReport_get_AppGpuDuration(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFramePresentationReport", L"AppGpuDuration"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFramePresentationReport_get_AppGpuOverrun(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFramePresentationReport", L"AppGpuOverrun"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFramePresentationReport_get_CompositorGpuDuration(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFramePresentationReport", L"CompositorGpuDuration"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFramePresentationReport_get_MissedPresentationOpportunityCount(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFramePresentationReport", L"MissedPresentationOpportunityCount"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFramePresentationReport_get_PresentationCount(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFramePresentationReport", L"PresentationCount"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicFramePresentationReport(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicFramePresentationReport>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicFramePresentationReport(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicFramePresentationReport>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicFramePresentationReport[] = {
        { "_assign_array_", _assign_array_HolographicFramePresentationReport, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicFramePresentationReport), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicFramePresentationReport[] = {
        { "app_gpu_duration", reinterpret_cast<getter>(HolographicFramePresentationReport_get_AppGpuDuration), nullptr, nullptr, nullptr },
        { "app_gpu_overrun", reinterpret_cast<getter>(HolographicFramePresentationReport_get_AppGpuOverrun), nullptr, nullptr, nullptr },
        { "compositor_gpu_duration", reinterpret_cast<getter>(HolographicFramePresentationReport_get_CompositorGpuDuration), nullptr, nullptr, nullptr },
        { "missed_presentation_opportunity_count", reinterpret_cast<getter>(HolographicFramePresentationReport_get_MissedPresentationOpportunityCount), nullptr, nullptr, nullptr },
        { "presentation_count", reinterpret_cast<getter>(HolographicFramePresentationReport_get_PresentationCount), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicFramePresentationReport[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicFramePresentationReport) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicFramePresentationReport) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicFramePresentationReport) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicFramePresentationReport) },
        { },
    };

    static PyType_Spec type_spec_HolographicFramePresentationReport =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicFramePresentationReport",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicFramePresentationReport),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicFramePresentationReport
    };

    // ----- HolographicFrameRenderingReport class --------------------
    static constexpr const char* const type_name_HolographicFrameRenderingReport = "HolographicFrameRenderingReport";

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

    static void _dealloc_HolographicFrameRenderingReport(py::wrapper::Windows::Graphics::Holographic::HolographicFrameRenderingReport* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicFrameRenderingReport_get_FrameId(py::wrapper::Windows::Graphics::Holographic::HolographicFrameRenderingReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrameRenderingReport", L"FrameId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFrameRenderingReport_get_MissedLatchCount(py::wrapper::Windows::Graphics::Holographic::HolographicFrameRenderingReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrameRenderingReport", L"MissedLatchCount"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFrameRenderingReport_get_SystemRelativeActualGpuFinishTime(py::wrapper::Windows::Graphics::Holographic::HolographicFrameRenderingReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrameRenderingReport", L"SystemRelativeActualGpuFinishTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFrameRenderingReport_get_SystemRelativeFrameReadyTime(py::wrapper::Windows::Graphics::Holographic::HolographicFrameRenderingReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrameRenderingReport", L"SystemRelativeFrameReadyTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFrameRenderingReport_get_SystemRelativeTargetLatchTime(py::wrapper::Windows::Graphics::Holographic::HolographicFrameRenderingReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrameRenderingReport", L"SystemRelativeTargetLatchTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicFrameRenderingReport(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicFrameRenderingReport>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicFrameRenderingReport(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicFrameRenderingReport>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicFrameRenderingReport[] = {
        { "_assign_array_", _assign_array_HolographicFrameRenderingReport, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicFrameRenderingReport), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicFrameRenderingReport[] = {
        { "frame_id", reinterpret_cast<getter>(HolographicFrameRenderingReport_get_FrameId), nullptr, nullptr, nullptr },
        { "missed_latch_count", reinterpret_cast<getter>(HolographicFrameRenderingReport_get_MissedLatchCount), nullptr, nullptr, nullptr },
        { "system_relative_actual_gpu_finish_time", reinterpret_cast<getter>(HolographicFrameRenderingReport_get_SystemRelativeActualGpuFinishTime), nullptr, nullptr, nullptr },
        { "system_relative_frame_ready_time", reinterpret_cast<getter>(HolographicFrameRenderingReport_get_SystemRelativeFrameReadyTime), nullptr, nullptr, nullptr },
        { "system_relative_target_latch_time", reinterpret_cast<getter>(HolographicFrameRenderingReport_get_SystemRelativeTargetLatchTime), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicFrameRenderingReport[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicFrameRenderingReport) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicFrameRenderingReport) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicFrameRenderingReport) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicFrameRenderingReport) },
        { },
    };

    static PyType_Spec type_spec_HolographicFrameRenderingReport =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicFrameRenderingReport",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicFrameRenderingReport),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicFrameRenderingReport
    };

    // ----- HolographicFrameScanoutMonitor class --------------------
    static constexpr const char* const type_name_HolographicFrameScanoutMonitor = "HolographicFrameScanoutMonitor";

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

    static void _dealloc_HolographicFrameScanoutMonitor(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutMonitor* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicFrameScanoutMonitor_Close(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutMonitor* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicFrameScanoutMonitor", L"Close", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* HolographicFrameScanoutMonitor_ReadReports(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutMonitor* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicFrameScanoutMonitor", L"ReadReports", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* _assign_array_HolographicFrameScanoutMonitor(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicFrameScanoutMonitor>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicFrameScanoutMonitor(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicFrameScanoutMonitor>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_HolographicFrameScanoutMonitor(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutMonitor* self) noexcept
    {
        Py_INCREF(self);
        return reinterpret_cast<PyObject*>(self);
    }

    static PyObject* _exit_HolographicFrameScanoutMonitor(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutMonitor* self) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicFrameScanoutMonitor[] = {
        { "close", reinterpret_cast<PyCFunction>(HolographicFrameScanoutMonitor_Close), METH_VARARGS, nullptr },
        { "read_reports", reinterpret_cast<PyCFunction>(HolographicFrameScanoutMonitor_ReadReports), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HolographicFrameScanoutMonitor, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicFrameScanoutMonitor), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_HolographicFrameScanoutMonitor), METH_NOARGS, nullptr },
        { "__exit__",  reinterpret_cast<PyCFunction>(_exit_HolographicFrameScanoutMonitor), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicFrameScanoutMonitor[] = {
        { }
    };

    static PyType_Slot _type_slots_HolographicFrameScanoutMonitor[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicFrameScanoutMonitor) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicFrameScanoutMonitor) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicFrameScanoutMonitor) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicFrameScanoutMonitor) },
        { },
    };

    static PyType_Spec type_spec_HolographicFrameScanoutMonitor =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicFrameScanoutMonitor",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutMonitor),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicFrameScanoutMonitor
    };

    // ----- HolographicFrameScanoutReport class --------------------
    static constexpr const char* const type_name_HolographicFrameScanoutReport = "HolographicFrameScanoutReport";

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

    static void _dealloc_HolographicFrameScanoutReport(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutReport* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicFrameScanoutReport_get_MissedScanoutCount(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrameScanoutReport", L"MissedScanoutCount"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFrameScanoutReport_get_RenderingReport(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrameScanoutReport", L"RenderingReport"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFrameScanoutReport_get_SystemRelativeLatchTime(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrameScanoutReport", L"SystemRelativeLatchTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFrameScanoutReport_get_SystemRelativePhotonTime(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrameScanoutReport", L"SystemRelativePhotonTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicFrameScanoutReport_get_SystemRelativeScanoutStartTime(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutReport* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicFrameScanoutReport", L"SystemRelativeScanoutStartTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicFrameScanoutReport(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicFrameScanoutReport>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicFrameScanoutReport(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicFrameScanoutReport>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicFrameScanoutReport[] = {
        { "_assign_array_", _assign_array_HolographicFrameScanoutReport, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicFrameScanoutReport), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicFrameScanoutReport[] = {
        { "missed_scanout_count", reinterpret_cast<getter>(HolographicFrameScanoutReport_get_MissedScanoutCount), nullptr, nullptr, nullptr },
        { "rendering_report", reinterpret_cast<getter>(HolographicFrameScanoutReport_get_RenderingReport), nullptr, nullptr, nullptr },
        { "system_relative_latch_time", reinterpret_cast<getter>(HolographicFrameScanoutReport_get_SystemRelativeLatchTime), nullptr, nullptr, nullptr },
        { "system_relative_photon_time", reinterpret_cast<getter>(HolographicFrameScanoutReport_get_SystemRelativePhotonTime), nullptr, nullptr, nullptr },
        { "system_relative_scanout_start_time", reinterpret_cast<getter>(HolographicFrameScanoutReport_get_SystemRelativeScanoutStartTime), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicFrameScanoutReport[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicFrameScanoutReport) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicFrameScanoutReport) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicFrameScanoutReport) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicFrameScanoutReport) },
        { },
    };

    static PyType_Spec type_spec_HolographicFrameScanoutReport =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicFrameScanoutReport",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicFrameScanoutReport),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicFrameScanoutReport
    };

    // ----- HolographicQuadLayer class --------------------
    static constexpr const char* const type_name_HolographicQuadLayer = "HolographicQuadLayer";

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

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

                winrt::Windows::Graphics::Holographic::HolographicQuadLayer instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Size>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Graphics::DirectX::DirectXPixelFormat>(args, 1);

                winrt::Windows::Graphics::Holographic::HolographicQuadLayer instance{ param0, param1 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_HolographicQuadLayer(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayer* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicQuadLayer_Close(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicQuadLayer", L"Close", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* HolographicQuadLayer_get_PixelFormat(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicQuadLayer", L"PixelFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicQuadLayer_get_Size(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicQuadLayer", L"Size"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicQuadLayer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicQuadLayer>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicQuadLayer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicQuadLayer>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_HolographicQuadLayer(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayer* self) noexcept
    {
        Py_INCREF(self);
        return reinterpret_cast<PyObject*>(self);
    }

    static PyObject* _exit_HolographicQuadLayer(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayer* self) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicQuadLayer[] = {
        { "close", reinterpret_cast<PyCFunction>(HolographicQuadLayer_Close), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HolographicQuadLayer, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicQuadLayer), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_HolographicQuadLayer), METH_NOARGS, nullptr },
        { "__exit__",  reinterpret_cast<PyCFunction>(_exit_HolographicQuadLayer), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicQuadLayer[] = {
        { "pixel_format", reinterpret_cast<getter>(HolographicQuadLayer_get_PixelFormat), nullptr, nullptr, nullptr },
        { "size", reinterpret_cast<getter>(HolographicQuadLayer_get_Size), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicQuadLayer[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicQuadLayer) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicQuadLayer) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicQuadLayer) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicQuadLayer) },
        { },
    };

    static PyType_Spec type_spec_HolographicQuadLayer =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicQuadLayer",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayer),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicQuadLayer
    };

    // ----- HolographicQuadLayerUpdateParameters class --------------------
    static constexpr const char* const type_name_HolographicQuadLayerUpdateParameters = "HolographicQuadLayerUpdateParameters";

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

    static void _dealloc_HolographicQuadLayerUpdateParameters(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicQuadLayerUpdateParameters_AcquireBufferToUpdateContent(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicQuadLayerUpdateParameters", L"AcquireBufferToUpdateContent", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* HolographicQuadLayerUpdateParameters_AcquireBufferToUpdateContentWithHardwareProtection(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicQuadLayerUpdateParameters", L"AcquireBufferToUpdateContentWithHardwareProtection", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* HolographicQuadLayerUpdateParameters_UpdateContentProtectionEnabled(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicQuadLayerUpdateParameters", L"UpdateContentProtectionEnabled", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* HolographicQuadLayerUpdateParameters_UpdateExtents(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicQuadLayerUpdateParameters", L"UpdateExtents", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* HolographicQuadLayerUpdateParameters_UpdateLocationWithDisplayRelativeMode(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicQuadLayerUpdateParameters", L"UpdateLocationWithDisplayRelativeMode", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Numerics::float3>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Numerics::quaternion>(args, 1);

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

    static PyObject* HolographicQuadLayerUpdateParameters_UpdateLocationWithStationaryMode(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicQuadLayerUpdateParameters", L"UpdateLocationWithStationaryMode", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Perception::Spatial::SpatialCoordinateSystem>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Numerics::float3>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Foundation::Numerics::quaternion>(args, 2);

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

    static PyObject* HolographicQuadLayerUpdateParameters_UpdateViewport(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicQuadLayerUpdateParameters", L"UpdateViewport", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* HolographicQuadLayerUpdateParameters_get_CanAcquireWithHardwareProtection(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicQuadLayerUpdateParameters", L"CanAcquireWithHardwareProtection"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicQuadLayerUpdateParameters(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicQuadLayerUpdateParameters(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicQuadLayerUpdateParameters[] = {
        { "acquire_buffer_to_update_content", reinterpret_cast<PyCFunction>(HolographicQuadLayerUpdateParameters_AcquireBufferToUpdateContent), METH_VARARGS, nullptr },
        { "acquire_buffer_to_update_content_with_hardware_protection", reinterpret_cast<PyCFunction>(HolographicQuadLayerUpdateParameters_AcquireBufferToUpdateContentWithHardwareProtection), METH_VARARGS, nullptr },
        { "update_content_protection_enabled", reinterpret_cast<PyCFunction>(HolographicQuadLayerUpdateParameters_UpdateContentProtectionEnabled), METH_VARARGS, nullptr },
        { "update_extents", reinterpret_cast<PyCFunction>(HolographicQuadLayerUpdateParameters_UpdateExtents), METH_VARARGS, nullptr },
        { "update_location_with_display_relative_mode", reinterpret_cast<PyCFunction>(HolographicQuadLayerUpdateParameters_UpdateLocationWithDisplayRelativeMode), METH_VARARGS, nullptr },
        { "update_location_with_stationary_mode", reinterpret_cast<PyCFunction>(HolographicQuadLayerUpdateParameters_UpdateLocationWithStationaryMode), METH_VARARGS, nullptr },
        { "update_viewport", reinterpret_cast<PyCFunction>(HolographicQuadLayerUpdateParameters_UpdateViewport), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HolographicQuadLayerUpdateParameters, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicQuadLayerUpdateParameters), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicQuadLayerUpdateParameters[] = {
        { "can_acquire_with_hardware_protection", reinterpret_cast<getter>(HolographicQuadLayerUpdateParameters_get_CanAcquireWithHardwareProtection), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicQuadLayerUpdateParameters[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicQuadLayerUpdateParameters) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicQuadLayerUpdateParameters) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicQuadLayerUpdateParameters) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicQuadLayerUpdateParameters) },
        { },
    };

    static PyType_Spec type_spec_HolographicQuadLayerUpdateParameters =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicQuadLayerUpdateParameters",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicQuadLayerUpdateParameters
    };

    // ----- HolographicSpace class --------------------
    static constexpr const char* const type_name_HolographicSpace = "HolographicSpace";

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

    static void _dealloc_HolographicSpace(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"CreateForCoreWindow", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::UI::Core::CoreWindow>(args, 0);

                return py::convert(winrt::Windows::Graphics::Holographic::HolographicSpace::CreateForCoreWindow(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HolographicSpace_CreateFramePresentationMonitor(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"CreateFramePresentationMonitor", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* HolographicSpace_CreateFrameScanoutMonitor(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"CreateFrameScanoutMonitor", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* HolographicSpace_CreateNextFrame(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"CreateNextFrame", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* HolographicSpace_SetDirect3D11Device(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"SetDirect3D11Device", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::DirectX::Direct3D11::IDirect3DDevice>(args, 0);

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

    static PyObject* HolographicSpace_WaitForNextFrameReady(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"WaitForNextFrameReady", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* HolographicSpace_WaitForNextFrameReadyWithHeadStart(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"WaitForNextFrameReadyWithHeadStart", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* HolographicSpace_get_PrimaryAdapterId(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"PrimaryAdapterId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicSpace_get_UserPresence(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"UserPresence"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicSpace_get_IsAvailable(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"IsAvailable"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Windows::Graphics::Holographic::HolographicSpace::IsAvailable());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HolographicSpace_get_IsSupported(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"IsSupported"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Windows::Graphics::Holographic::HolographicSpace::IsSupported());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HolographicSpace_get_IsConfigured(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"IsConfigured"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Windows::Graphics::Holographic::HolographicSpace::IsConfigured());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HolographicSpace_add_CameraAdded(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"CameraAdded"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Graphics::Holographic::HolographicSpace, winrt::Windows::Graphics::Holographic::HolographicSpaceCameraAddedEventArgs>>(arg);

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

    static PyObject* HolographicSpace_remove_CameraAdded(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"CameraAdded"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* HolographicSpace_add_CameraRemoved(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"CameraRemoved"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Graphics::Holographic::HolographicSpace, winrt::Windows::Graphics::Holographic::HolographicSpaceCameraRemovedEventArgs>>(arg);

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

    static PyObject* HolographicSpace_remove_CameraRemoved(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"CameraRemoved"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* HolographicSpace_add_UserPresenceChanged(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"UserPresenceChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Graphics::Holographic::HolographicSpace, winrt::Windows::Foundation::IInspectable>>(arg);

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

    static PyObject* HolographicSpace_remove_UserPresenceChanged(py::wrapper::Windows::Graphics::Holographic::HolographicSpace* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"UserPresenceChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* HolographicSpace_add_IsAvailableChanged(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"IsAvailableChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

            return py::convert(winrt::Windows::Graphics::Holographic::HolographicSpace::IsAvailableChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HolographicSpace_remove_IsAvailableChanged(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Holographic.HolographicSpace", L"IsAvailableChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

            winrt::Windows::Graphics::Holographic::HolographicSpace::IsAvailableChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_HolographicSpace(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicSpace>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicSpace(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicSpace>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicSpace[] = {
        { "create_for_core_window", reinterpret_cast<PyCFunction>(HolographicSpace_CreateForCoreWindow), METH_VARARGS | METH_STATIC, nullptr },
        { "create_frame_presentation_monitor", reinterpret_cast<PyCFunction>(HolographicSpace_CreateFramePresentationMonitor), METH_VARARGS, nullptr },
        { "create_frame_scanout_monitor", reinterpret_cast<PyCFunction>(HolographicSpace_CreateFrameScanoutMonitor), METH_VARARGS, nullptr },
        { "create_next_frame", reinterpret_cast<PyCFunction>(HolographicSpace_CreateNextFrame), METH_VARARGS, nullptr },
        { "set_direct3_d11_device", reinterpret_cast<PyCFunction>(HolographicSpace_SetDirect3D11Device), METH_VARARGS, nullptr },
        { "wait_for_next_frame_ready", reinterpret_cast<PyCFunction>(HolographicSpace_WaitForNextFrameReady), METH_VARARGS, nullptr },
        { "wait_for_next_frame_ready_with_head_start", reinterpret_cast<PyCFunction>(HolographicSpace_WaitForNextFrameReadyWithHeadStart), METH_VARARGS, nullptr },
        { "add_camera_added", reinterpret_cast<PyCFunction>(HolographicSpace_add_CameraAdded), METH_O, nullptr },
        { "remove_camera_added", reinterpret_cast<PyCFunction>(HolographicSpace_remove_CameraAdded), METH_O, nullptr },
        { "add_camera_removed", reinterpret_cast<PyCFunction>(HolographicSpace_add_CameraRemoved), METH_O, nullptr },
        { "remove_camera_removed", reinterpret_cast<PyCFunction>(HolographicSpace_remove_CameraRemoved), METH_O, nullptr },
        { "add_user_presence_changed", reinterpret_cast<PyCFunction>(HolographicSpace_add_UserPresenceChanged), METH_O, nullptr },
        { "remove_user_presence_changed", reinterpret_cast<PyCFunction>(HolographicSpace_remove_UserPresenceChanged), METH_O, nullptr },
        { "add_is_available_changed", reinterpret_cast<PyCFunction>(HolographicSpace_add_IsAvailableChanged), METH_O | METH_STATIC, nullptr },
        { "remove_is_available_changed", reinterpret_cast<PyCFunction>(HolographicSpace_remove_IsAvailableChanged), METH_O | METH_STATIC, nullptr },
        { "_assign_array_", _assign_array_HolographicSpace, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicSpace), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicSpace[] = {
        { "primary_adapter_id", reinterpret_cast<getter>(HolographicSpace_get_PrimaryAdapterId), nullptr, nullptr, nullptr },
        { "user_presence", reinterpret_cast<getter>(HolographicSpace_get_UserPresence), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicSpace[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicSpace) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicSpace) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicSpace) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicSpace) },
        { },
    };

    static PyType_Spec type_spec_HolographicSpace =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicSpace",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicSpace),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicSpace
    };

    static PyGetSetDef getset_HolographicSpace_Meta[] = {
        { "is_available", reinterpret_cast<getter>(HolographicSpace_get_IsAvailable), nullptr, nullptr, nullptr },
        { "is_supported", reinterpret_cast<getter>(HolographicSpace_get_IsSupported), nullptr, nullptr, nullptr },
        { "is_configured", reinterpret_cast<getter>(HolographicSpace_get_IsConfigured), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot type_slots_HolographicSpace_Meta[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_HolographicSpace_Meta) },
        { }
    };

    static PyType_Spec type_spec_HolographicSpace_Meta =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicSpace_Meta",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_HolographicSpace_Meta
    };

    // ----- HolographicSpaceCameraAddedEventArgs class --------------------
    static constexpr const char* const type_name_HolographicSpaceCameraAddedEventArgs = "HolographicSpaceCameraAddedEventArgs";

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

    static void _dealloc_HolographicSpaceCameraAddedEventArgs(py::wrapper::Windows::Graphics::Holographic::HolographicSpaceCameraAddedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicSpaceCameraAddedEventArgs_GetDeferral(py::wrapper::Windows::Graphics::Holographic::HolographicSpaceCameraAddedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* HolographicSpaceCameraAddedEventArgs_get_Camera(py::wrapper::Windows::Graphics::Holographic::HolographicSpaceCameraAddedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs", L"Camera"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicSpaceCameraAddedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicSpaceCameraAddedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicSpaceCameraAddedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicSpaceCameraAddedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicSpaceCameraAddedEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(HolographicSpaceCameraAddedEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HolographicSpaceCameraAddedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicSpaceCameraAddedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicSpaceCameraAddedEventArgs[] = {
        { "camera", reinterpret_cast<getter>(HolographicSpaceCameraAddedEventArgs_get_Camera), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicSpaceCameraAddedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicSpaceCameraAddedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicSpaceCameraAddedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicSpaceCameraAddedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicSpaceCameraAddedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_HolographicSpaceCameraAddedEventArgs =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicSpaceCameraAddedEventArgs",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicSpaceCameraAddedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicSpaceCameraAddedEventArgs
    };

    // ----- HolographicSpaceCameraRemovedEventArgs class --------------------
    static constexpr const char* const type_name_HolographicSpaceCameraRemovedEventArgs = "HolographicSpaceCameraRemovedEventArgs";

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

    static void _dealloc_HolographicSpaceCameraRemovedEventArgs(py::wrapper::Windows::Graphics::Holographic::HolographicSpaceCameraRemovedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicSpaceCameraRemovedEventArgs_get_Camera(py::wrapper::Windows::Graphics::Holographic::HolographicSpaceCameraRemovedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs", L"Camera"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicSpaceCameraRemovedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicSpaceCameraRemovedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicSpaceCameraRemovedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicSpaceCameraRemovedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicSpaceCameraRemovedEventArgs[] = {
        { "_assign_array_", _assign_array_HolographicSpaceCameraRemovedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicSpaceCameraRemovedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicSpaceCameraRemovedEventArgs[] = {
        { "camera", reinterpret_cast<getter>(HolographicSpaceCameraRemovedEventArgs_get_Camera), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicSpaceCameraRemovedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicSpaceCameraRemovedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicSpaceCameraRemovedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicSpaceCameraRemovedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicSpaceCameraRemovedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_HolographicSpaceCameraRemovedEventArgs =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicSpaceCameraRemovedEventArgs",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicSpaceCameraRemovedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicSpaceCameraRemovedEventArgs
    };

    // ----- HolographicViewConfiguration class --------------------
    static constexpr const char* const type_name_HolographicViewConfiguration = "HolographicViewConfiguration";

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

    static void _dealloc_HolographicViewConfiguration(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self) noexcept
    {
        auto tp = Py_TYPE(self);

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

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

    static PyObject* HolographicViewConfiguration_RequestRenderTargetSize(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"RequestRenderTargetSize", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* HolographicViewConfiguration_get_PixelFormat(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"PixelFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int HolographicViewConfiguration_put_PixelFormat(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"PixelFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Graphics::DirectX::DirectXPixelFormat>(arg);

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

    static PyObject* HolographicViewConfiguration_get_IsEnabled(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"IsEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int HolographicViewConfiguration_put_IsEnabled(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"IsEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

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

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

    static PyObject* HolographicViewConfiguration_get_Display(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"Display"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicViewConfiguration_get_IsStereo(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"IsStereo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicViewConfiguration_get_Kind(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"Kind"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicViewConfiguration_get_NativeRenderTargetSize(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"NativeRenderTargetSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicViewConfiguration_get_RefreshRate(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"RefreshRate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicViewConfiguration_get_RenderTargetSize(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"RenderTargetSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicViewConfiguration_get_SupportedPixelFormats(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"SupportedPixelFormats"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* HolographicViewConfiguration_get_SupportedDepthReprojectionMethods(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Holographic.HolographicViewConfiguration", L"SupportedDepthReprojectionMethods"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_HolographicViewConfiguration(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Holographic::HolographicViewConfiguration>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HolographicViewConfiguration(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Graphics::Holographic::HolographicViewConfiguration>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HolographicViewConfiguration[] = {
        { "request_render_target_size", reinterpret_cast<PyCFunction>(HolographicViewConfiguration_RequestRenderTargetSize), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HolographicViewConfiguration, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HolographicViewConfiguration), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HolographicViewConfiguration[] = {
        { "pixel_format", reinterpret_cast<getter>(HolographicViewConfiguration_get_PixelFormat), reinterpret_cast<setter>(HolographicViewConfiguration_put_PixelFormat), nullptr, nullptr },
        { "is_enabled", reinterpret_cast<getter>(HolographicViewConfiguration_get_IsEnabled), reinterpret_cast<setter>(HolographicViewConfiguration_put_IsEnabled), nullptr, nullptr },
        { "display", reinterpret_cast<getter>(HolographicViewConfiguration_get_Display), nullptr, nullptr, nullptr },
        { "is_stereo", reinterpret_cast<getter>(HolographicViewConfiguration_get_IsStereo), nullptr, nullptr, nullptr },
        { "kind", reinterpret_cast<getter>(HolographicViewConfiguration_get_Kind), nullptr, nullptr, nullptr },
        { "native_render_target_size", reinterpret_cast<getter>(HolographicViewConfiguration_get_NativeRenderTargetSize), nullptr, nullptr, nullptr },
        { "refresh_rate", reinterpret_cast<getter>(HolographicViewConfiguration_get_RefreshRate), nullptr, nullptr, nullptr },
        { "render_target_size", reinterpret_cast<getter>(HolographicViewConfiguration_get_RenderTargetSize), nullptr, nullptr, nullptr },
        { "supported_pixel_formats", reinterpret_cast<getter>(HolographicViewConfiguration_get_SupportedPixelFormats), nullptr, nullptr, nullptr },
        { "supported_depth_reprojection_methods", reinterpret_cast<getter>(HolographicViewConfiguration_get_SupportedDepthReprojectionMethods), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicViewConfiguration[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicViewConfiguration) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicViewConfiguration) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HolographicViewConfiguration) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicViewConfiguration) },
        { },
    };

    static PyType_Spec type_spec_HolographicViewConfiguration =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicViewConfiguration",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicViewConfiguration),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicViewConfiguration
    };

    // ----- HolographicAdapterId struct --------------------
    static constexpr const char* const type_name_HolographicAdapterId = "HolographicAdapterId";

    PyObject* _new_HolographicAdapterId(PyTypeObject* type, PyObject* args, PyObject* kwds)
    {
        auto tuple_size = PyTuple_Size(args);

        if ((tuple_size == 0) && (kwds == nullptr))
        {
            try
            {
                winrt::Windows::Graphics::Holographic::HolographicAdapterId return_value{};
                return py::convert(return_value);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }

        uint32_t _LowPart{};
        int32_t _HighPart{};

        static const char* kwlist[] = {"low_part", "high_part", nullptr};
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "Ii", const_cast<char**>(kwlist), &_LowPart, &_HighPart))
        {
            return nullptr;
        }

        try
        {
            winrt::Windows::Graphics::Holographic::HolographicAdapterId return_value{ _LowPart, _HighPart };
            return py::convert(return_value);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static void _dealloc_HolographicAdapterId(py::wrapper::Windows::Graphics::Holographic::HolographicAdapterId* self) noexcept
    {
    }

    static PyObject* HolographicAdapterId_get_LowPart(py::wrapper::Windows::Graphics::Holographic::HolographicAdapterId* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LowPart);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HolographicAdapterId_set_LowPart(py::wrapper::Windows::Graphics::Holographic::HolographicAdapterId* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            self->obj.LowPart = py::converter<uint32_t>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* HolographicAdapterId_get_HighPart(py::wrapper::Windows::Graphics::Holographic::HolographicAdapterId* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.HighPart);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HolographicAdapterId_set_HighPart(py::wrapper::Windows::Graphics::Holographic::HolographicAdapterId* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            self->obj.HighPart = py::converter<int32_t>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyGetSetDef _getset_HolographicAdapterId[] = {
        { "low_part", reinterpret_cast<getter>(HolographicAdapterId_get_LowPart), reinterpret_cast<setter>(HolographicAdapterId_set_LowPart), nullptr, nullptr },
        { "high_part", reinterpret_cast<getter>(HolographicAdapterId_get_HighPart), reinterpret_cast<setter>(HolographicAdapterId_set_HighPart), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicAdapterId[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicAdapterId) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicAdapterId) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicAdapterId) },
        { },
    };

    static PyType_Spec type_spec_HolographicAdapterId =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicAdapterId",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicAdapterId),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicAdapterId
    };

    // ----- HolographicFrameId struct --------------------
    static constexpr const char* const type_name_HolographicFrameId = "HolographicFrameId";

    PyObject* _new_HolographicFrameId(PyTypeObject* type, PyObject* args, PyObject* kwds)
    {
        auto tuple_size = PyTuple_Size(args);

        if ((tuple_size == 0) && (kwds == nullptr))
        {
            try
            {
                winrt::Windows::Graphics::Holographic::HolographicFrameId return_value{};
                return py::convert(return_value);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }

        uint64_t _Value{};

        static const char* kwlist[] = {"value", nullptr};
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "K", const_cast<char**>(kwlist), &_Value))
        {
            return nullptr;
        }

        try
        {
            winrt::Windows::Graphics::Holographic::HolographicFrameId return_value{ _Value };
            return py::convert(return_value);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static void _dealloc_HolographicFrameId(py::wrapper::Windows::Graphics::Holographic::HolographicFrameId* self) noexcept
    {
    }

    static PyObject* HolographicFrameId_get_Value(py::wrapper::Windows::Graphics::Holographic::HolographicFrameId* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Value);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HolographicFrameId_set_Value(py::wrapper::Windows::Graphics::Holographic::HolographicFrameId* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            self->obj.Value = py::converter<uint64_t>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyGetSetDef _getset_HolographicFrameId[] = {
        { "value", reinterpret_cast<getter>(HolographicFrameId_get_Value), reinterpret_cast<setter>(HolographicFrameId_set_Value), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicFrameId[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicFrameId) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicFrameId) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicFrameId) },
        { },
    };

    static PyType_Spec type_spec_HolographicFrameId =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicFrameId",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicFrameId),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicFrameId
    };

    // ----- HolographicStereoTransform struct --------------------
    static constexpr const char* const type_name_HolographicStereoTransform = "HolographicStereoTransform";

    PyObject* _new_HolographicStereoTransform(PyTypeObject* type, PyObject* args, PyObject* kwds)
    {
        auto tuple_size = PyTuple_Size(args);

        if ((tuple_size == 0) && (kwds == nullptr))
        {
            try
            {
                winrt::Windows::Graphics::Holographic::HolographicStereoTransform return_value{};
                return py::convert(return_value);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }

        PyObject* _Left{};
        PyObject* _Right{};

        static const char* kwlist[] = {"left", "right", nullptr};
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO", const_cast<char**>(kwlist), &_Left, &_Right))
        {
            return nullptr;
        }

        try
        {
            winrt::Windows::Graphics::Holographic::HolographicStereoTransform return_value{ py::converter<winrt::Windows::Foundation::Numerics::float4x4>::convert_to(_Left), py::converter<winrt::Windows::Foundation::Numerics::float4x4>::convert_to(_Right) };
            return py::convert(return_value);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static void _dealloc_HolographicStereoTransform(py::wrapper::Windows::Graphics::Holographic::HolographicStereoTransform* self) noexcept
    {
    }

    static PyObject* HolographicStereoTransform_get_Left(py::wrapper::Windows::Graphics::Holographic::HolographicStereoTransform* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Left);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HolographicStereoTransform_set_Left(py::wrapper::Windows::Graphics::Holographic::HolographicStereoTransform* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            self->obj.Left = py::converter<winrt::Windows::Foundation::Numerics::float4x4>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* HolographicStereoTransform_get_Right(py::wrapper::Windows::Graphics::Holographic::HolographicStereoTransform* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Right);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HolographicStereoTransform_set_Right(py::wrapper::Windows::Graphics::Holographic::HolographicStereoTransform* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            self->obj.Right = py::converter<winrt::Windows::Foundation::Numerics::float4x4>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyGetSetDef _getset_HolographicStereoTransform[] = {
        { "left", reinterpret_cast<getter>(HolographicStereoTransform_get_Left), reinterpret_cast<setter>(HolographicStereoTransform_set_Left), nullptr, nullptr },
        { "right", reinterpret_cast<getter>(HolographicStereoTransform_get_Right), reinterpret_cast<setter>(HolographicStereoTransform_set_Right), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HolographicStereoTransform[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HolographicStereoTransform) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HolographicStereoTransform) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HolographicStereoTransform) },
        { },
    };

    static PyType_Spec type_spec_HolographicStereoTransform =
    {
        "_winsdk_Windows_Graphics_Holographic.HolographicStereoTransform",
        sizeof(py::wrapper::Windows::Graphics::Holographic::HolographicStereoTransform),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HolographicStereoTransform
    };

    // ----- Windows.Graphics.Holographic Initialization --------------------
    PyDoc_STRVAR(module_doc, "Windows::Graphics::Holographic");

    static PyMethodDef module_methods[] = {
        {"_register_HolographicDepthReprojectionMethod", register_HolographicDepthReprojectionMethod, METH_O, "registers type"},
        {"_register_HolographicFramePresentResult", register_HolographicFramePresentResult, METH_O, "registers type"},
        {"_register_HolographicFramePresentWaitBehavior", register_HolographicFramePresentWaitBehavior, METH_O, "registers type"},
        {"_register_HolographicReprojectionMode", register_HolographicReprojectionMode, METH_O, "registers type"},
        {"_register_HolographicSpaceUserPresence", register_HolographicSpaceUserPresence, METH_O, "registers type"},
        {"_register_HolographicViewConfigurationKind", register_HolographicViewConfigurationKind, METH_O, "registers type"},
        {}};


    static int module_traverse(PyObject* module, visitproc visit, void* arg) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));

        if (!state)
        {
            return 0;
        }

        Py_VISIT(state->type_HolographicDepthReprojectionMethod);
        Py_VISIT(state->type_HolographicFramePresentResult);
        Py_VISIT(state->type_HolographicFramePresentWaitBehavior);
        Py_VISIT(state->type_HolographicReprojectionMode);
        Py_VISIT(state->type_HolographicSpaceUserPresence);
        Py_VISIT(state->type_HolographicViewConfigurationKind);
        Py_VISIT(state->type_HolographicCamera);
        Py_VISIT(state->type_HolographicCameraPose);
        Py_VISIT(state->type_HolographicCameraRenderingParameters);
        Py_VISIT(state->type_HolographicCameraViewportParameters);
        Py_VISIT(state->type_HolographicDisplay);
        Py_VISIT(state->type_HolographicFrame);
        Py_VISIT(state->type_HolographicFramePrediction);
        Py_VISIT(state->type_HolographicFramePresentationMonitor);
        Py_VISIT(state->type_HolographicFramePresentationReport);
        Py_VISIT(state->type_HolographicFrameRenderingReport);
        Py_VISIT(state->type_HolographicFrameScanoutMonitor);
        Py_VISIT(state->type_HolographicFrameScanoutReport);
        Py_VISIT(state->type_HolographicQuadLayer);
        Py_VISIT(state->type_HolographicQuadLayerUpdateParameters);
        Py_VISIT(state->type_HolographicSpace);
        Py_VISIT(state->type_HolographicSpaceCameraAddedEventArgs);
        Py_VISIT(state->type_HolographicSpaceCameraRemovedEventArgs);
        Py_VISIT(state->type_HolographicViewConfiguration);
        Py_VISIT(state->type_HolographicAdapterId);
        Py_VISIT(state->type_HolographicFrameId);
        Py_VISIT(state->type_HolographicStereoTransform);

        return 0;
    }

    static int module_clear(PyObject* module) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));

        if (!state)
        {
            return 0;
        }

        Py_CLEAR(state->type_HolographicDepthReprojectionMethod);
        Py_CLEAR(state->type_HolographicFramePresentResult);
        Py_CLEAR(state->type_HolographicFramePresentWaitBehavior);
        Py_CLEAR(state->type_HolographicReprojectionMode);
        Py_CLEAR(state->type_HolographicSpaceUserPresence);
        Py_CLEAR(state->type_HolographicViewConfigurationKind);
        Py_CLEAR(state->type_HolographicCamera);
        Py_CLEAR(state->type_HolographicCameraPose);
        Py_CLEAR(state->type_HolographicCameraRenderingParameters);
        Py_CLEAR(state->type_HolographicCameraViewportParameters);
        Py_CLEAR(state->type_HolographicDisplay);
        Py_CLEAR(state->type_HolographicFrame);
        Py_CLEAR(state->type_HolographicFramePrediction);
        Py_CLEAR(state->type_HolographicFramePresentationMonitor);
        Py_CLEAR(state->type_HolographicFramePresentationReport);
        Py_CLEAR(state->type_HolographicFrameRenderingReport);
        Py_CLEAR(state->type_HolographicFrameScanoutMonitor);
        Py_CLEAR(state->type_HolographicFrameScanoutReport);
        Py_CLEAR(state->type_HolographicQuadLayer);
        Py_CLEAR(state->type_HolographicQuadLayerUpdateParameters);
        Py_CLEAR(state->type_HolographicSpace);
        Py_CLEAR(state->type_HolographicSpaceCameraAddedEventArgs);
        Py_CLEAR(state->type_HolographicSpaceCameraRemovedEventArgs);
        Py_CLEAR(state->type_HolographicViewConfiguration);
        Py_CLEAR(state->type_HolographicAdapterId);
        Py_CLEAR(state->type_HolographicFrameId);
        Py_CLEAR(state->type_HolographicStereoTransform);

        return 0;
    }


    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winsdk_Windows_Graphics_Holographic",
           module_doc,
           sizeof(module_state),
           module_methods,
           nullptr,
           module_traverse,
           module_clear,
           nullptr};

} // py::cpp::Windows::Graphics::Holographic

PyMODINIT_FUNC PyInit__winsdk_Windows_Graphics_Holographic(void) noexcept
{
    using namespace py::cpp::Windows::Graphics::Holographic;

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

    if (!module)
    {
        return nullptr;
    }

    auto object_type = py::get_python_type<py::Object>();
    if (!object_type)
    {
        return nullptr;
    }

    py::pyobj_handle bases{PyTuple_Pack(1, object_type)};

    if (!bases)
    {
        return nullptr;
    }

    py::pyobj_handle collections_abc_module{PyImport_ImportModule("collections.abc")};

    if (!collections_abc_module)
    {
        return nullptr;
    }

    py::pyobj_handle sequence_type{PyObject_GetAttrString(collections_abc_module.get(), "Sequence")};

    if (!sequence_type)
    {
        return nullptr;
    }

    py::pyobj_handle sequence_bases{PyTuple_Pack(2, object_type, sequence_type.get())};

    if (!sequence_bases)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_sequence_type{PyObject_GetAttrString(collections_abc_module.get(), "MutableSequence")};

    if (!mutable_sequence_type)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_sequence_bases{PyTuple_Pack(2, object_type, mutable_sequence_type.get())};

    if (!mutable_sequence_bases)
    {
        return nullptr;
    }

    py::pyobj_handle mapping_type{PyObject_GetAttrString(collections_abc_module.get(), "Mapping")};

    if (!mapping_type)
    {
        return nullptr;
    }

    py::pyobj_handle mapping_bases{PyTuple_Pack(2, object_type, mapping_type.get())};

    if (!mapping_bases)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_mapping_type{PyObject_GetAttrString(collections_abc_module.get(), "MutableMapping")};

    if (!mutable_mapping_type)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_mapping_bases{PyTuple_Pack(2, object_type, mutable_mapping_type.get())};

    if (!mutable_mapping_bases)
    {
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module.get()));
    assert(state);

    state->type_HolographicCamera = py::register_python_type(module.get(), type_name_HolographicCamera, &type_spec_HolographicCamera, bases.get(), nullptr);
    if (!state->type_HolographicCamera)
    {
        return nullptr;
    }

    state->type_HolographicCameraPose = py::register_python_type(module.get(), type_name_HolographicCameraPose, &type_spec_HolographicCameraPose, bases.get(), nullptr);
    if (!state->type_HolographicCameraPose)
    {
        return nullptr;
    }

    state->type_HolographicCameraRenderingParameters = py::register_python_type(module.get(), type_name_HolographicCameraRenderingParameters, &type_spec_HolographicCameraRenderingParameters, bases.get(), nullptr);
    if (!state->type_HolographicCameraRenderingParameters)
    {
        return nullptr;
    }

    state->type_HolographicCameraViewportParameters = py::register_python_type(module.get(), type_name_HolographicCameraViewportParameters, &type_spec_HolographicCameraViewportParameters, bases.get(), nullptr);
    if (!state->type_HolographicCameraViewportParameters)
    {
        return nullptr;
    }

    state->type_HolographicDisplay = py::register_python_type(module.get(), type_name_HolographicDisplay, &type_spec_HolographicDisplay, bases.get(), nullptr);
    if (!state->type_HolographicDisplay)
    {
        return nullptr;
    }

    state->type_HolographicFrame = py::register_python_type(module.get(), type_name_HolographicFrame, &type_spec_HolographicFrame, bases.get(), nullptr);
    if (!state->type_HolographicFrame)
    {
        return nullptr;
    }

    state->type_HolographicFramePrediction = py::register_python_type(module.get(), type_name_HolographicFramePrediction, &type_spec_HolographicFramePrediction, bases.get(), nullptr);
    if (!state->type_HolographicFramePrediction)
    {
        return nullptr;
    }

    state->type_HolographicFramePresentationMonitor = py::register_python_type(module.get(), type_name_HolographicFramePresentationMonitor, &type_spec_HolographicFramePresentationMonitor, bases.get(), nullptr);
    if (!state->type_HolographicFramePresentationMonitor)
    {
        return nullptr;
    }

    state->type_HolographicFramePresentationReport = py::register_python_type(module.get(), type_name_HolographicFramePresentationReport, &type_spec_HolographicFramePresentationReport, bases.get(), nullptr);
    if (!state->type_HolographicFramePresentationReport)
    {
        return nullptr;
    }

    state->type_HolographicFrameRenderingReport = py::register_python_type(module.get(), type_name_HolographicFrameRenderingReport, &type_spec_HolographicFrameRenderingReport, bases.get(), nullptr);
    if (!state->type_HolographicFrameRenderingReport)
    {
        return nullptr;
    }

    state->type_HolographicFrameScanoutMonitor = py::register_python_type(module.get(), type_name_HolographicFrameScanoutMonitor, &type_spec_HolographicFrameScanoutMonitor, bases.get(), nullptr);
    if (!state->type_HolographicFrameScanoutMonitor)
    {
        return nullptr;
    }

    state->type_HolographicFrameScanoutReport = py::register_python_type(module.get(), type_name_HolographicFrameScanoutReport, &type_spec_HolographicFrameScanoutReport, bases.get(), nullptr);
    if (!state->type_HolographicFrameScanoutReport)
    {
        return nullptr;
    }

    state->type_HolographicQuadLayer = py::register_python_type(module.get(), type_name_HolographicQuadLayer, &type_spec_HolographicQuadLayer, bases.get(), nullptr);
    if (!state->type_HolographicQuadLayer)
    {
        return nullptr;
    }

    state->type_HolographicQuadLayerUpdateParameters = py::register_python_type(module.get(), type_name_HolographicQuadLayerUpdateParameters, &type_spec_HolographicQuadLayerUpdateParameters, bases.get(), nullptr);
    if (!state->type_HolographicQuadLayerUpdateParameters)
    {
        return nullptr;
    }

    py::pyobj_handle type_HolographicSpace_Meta{PyType_FromSpec(&type_spec_HolographicSpace_Meta)};
    if (!type_HolographicSpace_Meta)
    {
        return nullptr;
    }

    state->type_HolographicSpace = py::register_python_type(module.get(), type_name_HolographicSpace, &type_spec_HolographicSpace, bases.get(), reinterpret_cast<PyTypeObject*>(type_HolographicSpace_Meta.get()));
    if (!state->type_HolographicSpace)
    {
        return nullptr;
    }

    state->type_HolographicSpaceCameraAddedEventArgs = py::register_python_type(module.get(), type_name_HolographicSpaceCameraAddedEventArgs, &type_spec_HolographicSpaceCameraAddedEventArgs, bases.get(), nullptr);
    if (!state->type_HolographicSpaceCameraAddedEventArgs)
    {
        return nullptr;
    }

    state->type_HolographicSpaceCameraRemovedEventArgs = py::register_python_type(module.get(), type_name_HolographicSpaceCameraRemovedEventArgs, &type_spec_HolographicSpaceCameraRemovedEventArgs, bases.get(), nullptr);
    if (!state->type_HolographicSpaceCameraRemovedEventArgs)
    {
        return nullptr;
    }

    state->type_HolographicViewConfiguration = py::register_python_type(module.get(), type_name_HolographicViewConfiguration, &type_spec_HolographicViewConfiguration, bases.get(), nullptr);
    if (!state->type_HolographicViewConfiguration)
    {
        return nullptr;
    }

    state->type_HolographicAdapterId = py::register_python_type(module.get(), type_name_HolographicAdapterId, &type_spec_HolographicAdapterId, bases.get(), nullptr);
    if (!state->type_HolographicAdapterId)
    {
        return nullptr;
    }

    state->type_HolographicFrameId = py::register_python_type(module.get(), type_name_HolographicFrameId, &type_spec_HolographicFrameId, bases.get(), nullptr);
    if (!state->type_HolographicFrameId)
    {
        return nullptr;
    }

    state->type_HolographicStereoTransform = py::register_python_type(module.get(), type_name_HolographicStereoTransform, &type_spec_HolographicStereoTransform, bases.get(), nullptr);
    if (!state->type_HolographicStereoTransform)
    {
        return nullptr;
    }


    return module.detach();
}

PyObject* py::py_type<winrt::Windows::Graphics::Holographic::HolographicDepthReprojectionMethod>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicDepthReprojectionMethod;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicDepthReprojectionMethod is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Graphics::Holographic::HolographicFramePresentResult>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicFramePresentResult;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicFramePresentResult is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Graphics::Holographic::HolographicFramePresentWaitBehavior>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicFramePresentWaitBehavior;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicFramePresentWaitBehavior is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Graphics::Holographic::HolographicReprojectionMode>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicReprojectionMode;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicReprojectionMode is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Graphics::Holographic::HolographicSpaceUserPresence>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicSpaceUserPresence;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicSpaceUserPresence is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Graphics::Holographic::HolographicViewConfigurationKind>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicViewConfigurationKind;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicViewConfigurationKind is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicCamera>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicCamera;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicCamera is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicCameraPose>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicCameraPose;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicCameraPose is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicCameraRenderingParameters>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicCameraRenderingParameters;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicCameraRenderingParameters is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicCameraViewportParameters>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicCameraViewportParameters;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicCameraViewportParameters is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicDisplay>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicDisplay;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicDisplay is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicFrame>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicFrame;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicFrame is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicFramePrediction>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicFramePrediction;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicFramePrediction is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicFramePresentationMonitor>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicFramePresentationMonitor;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicFramePresentationMonitor is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicFramePresentationReport>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicFramePresentationReport;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicFramePresentationReport is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicFrameRenderingReport>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicFrameRenderingReport;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicFrameRenderingReport is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicFrameScanoutMonitor>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicFrameScanoutMonitor;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicFrameScanoutMonitor is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicFrameScanoutReport>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicFrameScanoutReport;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicFrameScanoutReport is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicQuadLayer>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicQuadLayer;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicQuadLayer is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicQuadLayerUpdateParameters;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicQuadLayerUpdateParameters is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicSpace>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicSpace;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicSpace is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicSpaceCameraAddedEventArgs>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicSpaceCameraAddedEventArgs;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicSpaceCameraAddedEventArgs is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicSpaceCameraRemovedEventArgs>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicSpaceCameraRemovedEventArgs;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicSpaceCameraRemovedEventArgs is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicViewConfiguration>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicViewConfiguration;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicViewConfiguration is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicAdapterId>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicAdapterId;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicAdapterId is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicFrameId>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicFrameId;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicFrameId is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Holographic::HolographicStereoTransform>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Holographic;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Holographic");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_HolographicStereoTransform;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Holographic::HolographicStereoTransform is not registered");
        return nullptr;
    }

    return python_type;
}
