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

#include "pybase.h"
#include "py.Windows.Services.Maps.Guidance.h"


namespace py::cpp::Windows::Services::Maps::Guidance
{
    struct module_state
    {
        PyObject* type_GuidanceAudioMeasurementSystem;
        PyObject* type_GuidanceAudioNotificationKind;
        PyObject* type_GuidanceAudioNotifications;
        PyObject* type_GuidanceLaneMarkers;
        PyObject* type_GuidanceManeuverKind;
        PyObject* type_GuidanceMode;
        PyTypeObject* type_GuidanceAudioNotificationRequestedEventArgs;
        PyTypeObject* type_GuidanceLaneInfo;
        PyTypeObject* type_GuidanceManeuver;
        PyTypeObject* type_GuidanceMapMatchedCoordinate;
        PyTypeObject* type_GuidanceNavigator;
        PyTypeObject* type_GuidanceReroutedEventArgs;
        PyTypeObject* type_GuidanceRoadSegment;
        PyTypeObject* type_GuidanceRoadSignpost;
        PyTypeObject* type_GuidanceRoute;
        PyTypeObject* type_GuidanceTelemetryCollector;
        PyTypeObject* type_GuidanceUpdatedEventArgs;
    };

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

        if (state->type_GuidanceAudioMeasurementSystem)
        {
            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_GuidanceAudioMeasurementSystem = type;
        Py_INCREF(state->type_GuidanceAudioMeasurementSystem);


        Py_RETURN_NONE;
    }

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

        if (state->type_GuidanceAudioNotificationKind)
        {
            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_GuidanceAudioNotificationKind = type;
        Py_INCREF(state->type_GuidanceAudioNotificationKind);


        Py_RETURN_NONE;
    }

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

        if (state->type_GuidanceAudioNotifications)
        {
            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_GuidanceAudioNotifications = type;
        Py_INCREF(state->type_GuidanceAudioNotifications);


        Py_RETURN_NONE;
    }

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

        if (state->type_GuidanceLaneMarkers)
        {
            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_GuidanceLaneMarkers = type;
        Py_INCREF(state->type_GuidanceLaneMarkers);


        Py_RETURN_NONE;
    }

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

        if (state->type_GuidanceManeuverKind)
        {
            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_GuidanceManeuverKind = type;
        Py_INCREF(state->type_GuidanceManeuverKind);


        Py_RETURN_NONE;
    }

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

        if (state->type_GuidanceMode)
        {
            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_GuidanceMode = type;
        Py_INCREF(state->type_GuidanceMode);


        Py_RETURN_NONE;
    }

    // ----- GuidanceAudioNotificationRequestedEventArgs class --------------------
    static constexpr const char* const type_name_GuidanceAudioNotificationRequestedEventArgs = "GuidanceAudioNotificationRequestedEventArgs";

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

    static void _dealloc_GuidanceAudioNotificationRequestedEventArgs(py::wrapper::Windows::Services::Maps::Guidance::GuidanceAudioNotificationRequestedEventArgs* 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* GuidanceAudioNotificationRequestedEventArgs_get_AudioFilePaths(py::wrapper::Windows::Services::Maps::Guidance::GuidanceAudioNotificationRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs", L"AudioFilePaths"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceAudioNotificationRequestedEventArgs_get_AudioNotification(py::wrapper::Windows::Services::Maps::Guidance::GuidanceAudioNotificationRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs", L"AudioNotification"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceAudioNotificationRequestedEventArgs_get_AudioText(py::wrapper::Windows::Services::Maps::Guidance::GuidanceAudioNotificationRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs", L"AudioText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_GuidanceAudioNotificationRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Services::Maps::Guidance::GuidanceAudioNotificationRequestedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GuidanceAudioNotificationRequestedEventArgs(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::Services::Maps::Guidance::GuidanceAudioNotificationRequestedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GuidanceAudioNotificationRequestedEventArgs[] = {
        { "_assign_array_", _assign_array_GuidanceAudioNotificationRequestedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GuidanceAudioNotificationRequestedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GuidanceAudioNotificationRequestedEventArgs[] = {
        { "audio_file_paths", reinterpret_cast<getter>(GuidanceAudioNotificationRequestedEventArgs_get_AudioFilePaths), nullptr, nullptr, nullptr },
        { "audio_notification", reinterpret_cast<getter>(GuidanceAudioNotificationRequestedEventArgs_get_AudioNotification), nullptr, nullptr, nullptr },
        { "audio_text", reinterpret_cast<getter>(GuidanceAudioNotificationRequestedEventArgs_get_AudioText), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GuidanceAudioNotificationRequestedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GuidanceAudioNotificationRequestedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GuidanceAudioNotificationRequestedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GuidanceAudioNotificationRequestedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GuidanceAudioNotificationRequestedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_GuidanceAudioNotificationRequestedEventArgs =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceAudioNotificationRequestedEventArgs",
        sizeof(py::wrapper::Windows::Services::Maps::Guidance::GuidanceAudioNotificationRequestedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GuidanceAudioNotificationRequestedEventArgs
    };

    // ----- GuidanceLaneInfo class --------------------
    static constexpr const char* const type_name_GuidanceLaneInfo = "GuidanceLaneInfo";

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

    static void _dealloc_GuidanceLaneInfo(py::wrapper::Windows::Services::Maps::Guidance::GuidanceLaneInfo* 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* GuidanceLaneInfo_get_IsOnRoute(py::wrapper::Windows::Services::Maps::Guidance::GuidanceLaneInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceLaneInfo", L"IsOnRoute"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceLaneInfo_get_LaneMarkers(py::wrapper::Windows::Services::Maps::Guidance::GuidanceLaneInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceLaneInfo", L"LaneMarkers"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_GuidanceLaneInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Services::Maps::Guidance::GuidanceLaneInfo>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GuidanceLaneInfo(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::Services::Maps::Guidance::GuidanceLaneInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GuidanceLaneInfo[] = {
        { "_assign_array_", _assign_array_GuidanceLaneInfo, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GuidanceLaneInfo), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GuidanceLaneInfo[] = {
        { "is_on_route", reinterpret_cast<getter>(GuidanceLaneInfo_get_IsOnRoute), nullptr, nullptr, nullptr },
        { "lane_markers", reinterpret_cast<getter>(GuidanceLaneInfo_get_LaneMarkers), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GuidanceLaneInfo[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GuidanceLaneInfo) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GuidanceLaneInfo) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GuidanceLaneInfo) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GuidanceLaneInfo) },
        { },
    };

    static PyType_Spec type_spec_GuidanceLaneInfo =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceLaneInfo",
        sizeof(py::wrapper::Windows::Services::Maps::Guidance::GuidanceLaneInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GuidanceLaneInfo
    };

    // ----- GuidanceManeuver class --------------------
    static constexpr const char* const type_name_GuidanceManeuver = "GuidanceManeuver";

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

    static void _dealloc_GuidanceManeuver(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* 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* GuidanceManeuver_get_DepartureRoadName(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", L"DepartureRoadName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceManeuver_get_DepartureShortRoadName(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", L"DepartureShortRoadName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceManeuver_get_DistanceFromPreviousManeuver(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", L"DistanceFromPreviousManeuver"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceManeuver_get_DistanceFromRouteStart(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", L"DistanceFromRouteStart"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceManeuver_get_EndAngle(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", L"EndAngle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceManeuver_get_InstructionText(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", L"InstructionText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceManeuver_get_Kind(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", 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* GuidanceManeuver_get_NextRoadName(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", L"NextRoadName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceManeuver_get_NextShortRoadName(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", L"NextShortRoadName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceManeuver_get_RoadSignpost(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", L"RoadSignpost"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceManeuver_get_StartAngle(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", L"StartAngle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceManeuver_get_StartLocation(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceManeuver", L"StartLocation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_GuidanceManeuver(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Services::Maps::Guidance::GuidanceManeuver>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GuidanceManeuver(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::Services::Maps::Guidance::GuidanceManeuver>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GuidanceManeuver[] = {
        { "_assign_array_", _assign_array_GuidanceManeuver, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GuidanceManeuver), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GuidanceManeuver[] = {
        { "departure_road_name", reinterpret_cast<getter>(GuidanceManeuver_get_DepartureRoadName), nullptr, nullptr, nullptr },
        { "departure_short_road_name", reinterpret_cast<getter>(GuidanceManeuver_get_DepartureShortRoadName), nullptr, nullptr, nullptr },
        { "distance_from_previous_maneuver", reinterpret_cast<getter>(GuidanceManeuver_get_DistanceFromPreviousManeuver), nullptr, nullptr, nullptr },
        { "distance_from_route_start", reinterpret_cast<getter>(GuidanceManeuver_get_DistanceFromRouteStart), nullptr, nullptr, nullptr },
        { "end_angle", reinterpret_cast<getter>(GuidanceManeuver_get_EndAngle), nullptr, nullptr, nullptr },
        { "instruction_text", reinterpret_cast<getter>(GuidanceManeuver_get_InstructionText), nullptr, nullptr, nullptr },
        { "kind", reinterpret_cast<getter>(GuidanceManeuver_get_Kind), nullptr, nullptr, nullptr },
        { "next_road_name", reinterpret_cast<getter>(GuidanceManeuver_get_NextRoadName), nullptr, nullptr, nullptr },
        { "next_short_road_name", reinterpret_cast<getter>(GuidanceManeuver_get_NextShortRoadName), nullptr, nullptr, nullptr },
        { "road_signpost", reinterpret_cast<getter>(GuidanceManeuver_get_RoadSignpost), nullptr, nullptr, nullptr },
        { "start_angle", reinterpret_cast<getter>(GuidanceManeuver_get_StartAngle), nullptr, nullptr, nullptr },
        { "start_location", reinterpret_cast<getter>(GuidanceManeuver_get_StartLocation), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GuidanceManeuver[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GuidanceManeuver) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GuidanceManeuver) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GuidanceManeuver) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GuidanceManeuver) },
        { },
    };

    static PyType_Spec type_spec_GuidanceManeuver =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceManeuver",
        sizeof(py::wrapper::Windows::Services::Maps::Guidance::GuidanceManeuver),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GuidanceManeuver
    };

    // ----- GuidanceMapMatchedCoordinate class --------------------
    static constexpr const char* const type_name_GuidanceMapMatchedCoordinate = "GuidanceMapMatchedCoordinate";

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

    static void _dealloc_GuidanceMapMatchedCoordinate(py::wrapper::Windows::Services::Maps::Guidance::GuidanceMapMatchedCoordinate* 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* GuidanceMapMatchedCoordinate_get_CurrentHeading(py::wrapper::Windows::Services::Maps::Guidance::GuidanceMapMatchedCoordinate* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceMapMatchedCoordinate", L"CurrentHeading"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceMapMatchedCoordinate_get_CurrentSpeed(py::wrapper::Windows::Services::Maps::Guidance::GuidanceMapMatchedCoordinate* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceMapMatchedCoordinate", L"CurrentSpeed"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceMapMatchedCoordinate_get_IsOnStreet(py::wrapper::Windows::Services::Maps::Guidance::GuidanceMapMatchedCoordinate* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceMapMatchedCoordinate", L"IsOnStreet"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceMapMatchedCoordinate_get_Location(py::wrapper::Windows::Services::Maps::Guidance::GuidanceMapMatchedCoordinate* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceMapMatchedCoordinate", L"Location"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceMapMatchedCoordinate_get_Road(py::wrapper::Windows::Services::Maps::Guidance::GuidanceMapMatchedCoordinate* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceMapMatchedCoordinate", L"Road"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_GuidanceMapMatchedCoordinate(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Services::Maps::Guidance::GuidanceMapMatchedCoordinate>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GuidanceMapMatchedCoordinate(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::Services::Maps::Guidance::GuidanceMapMatchedCoordinate>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GuidanceMapMatchedCoordinate[] = {
        { "_assign_array_", _assign_array_GuidanceMapMatchedCoordinate, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GuidanceMapMatchedCoordinate), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GuidanceMapMatchedCoordinate[] = {
        { "current_heading", reinterpret_cast<getter>(GuidanceMapMatchedCoordinate_get_CurrentHeading), nullptr, nullptr, nullptr },
        { "current_speed", reinterpret_cast<getter>(GuidanceMapMatchedCoordinate_get_CurrentSpeed), nullptr, nullptr, nullptr },
        { "is_on_street", reinterpret_cast<getter>(GuidanceMapMatchedCoordinate_get_IsOnStreet), nullptr, nullptr, nullptr },
        { "location", reinterpret_cast<getter>(GuidanceMapMatchedCoordinate_get_Location), nullptr, nullptr, nullptr },
        { "road", reinterpret_cast<getter>(GuidanceMapMatchedCoordinate_get_Road), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GuidanceMapMatchedCoordinate[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GuidanceMapMatchedCoordinate) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GuidanceMapMatchedCoordinate) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GuidanceMapMatchedCoordinate) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GuidanceMapMatchedCoordinate) },
        { },
    };

    static PyType_Spec type_spec_GuidanceMapMatchedCoordinate =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceMapMatchedCoordinate",
        sizeof(py::wrapper::Windows::Services::Maps::Guidance::GuidanceMapMatchedCoordinate),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GuidanceMapMatchedCoordinate
    };

    // ----- GuidanceNavigator class --------------------
    static constexpr const char* const type_name_GuidanceNavigator = "GuidanceNavigator";

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

    static void _dealloc_GuidanceNavigator(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* 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* GuidanceNavigator_GetCurrent(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"GetCurrent", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::Services::Maps::Guidance::GuidanceNavigator::GetCurrent());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* GuidanceNavigator_Pause(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"Pause", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* GuidanceNavigator_RepeatLastAudioNotification(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"RepeatLastAudioNotification", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* GuidanceNavigator_Resume(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"Resume", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* GuidanceNavigator_SetGuidanceVoice(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"SetGuidanceVoice", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

    static PyObject* GuidanceNavigator_StartNavigating(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"StartNavigating", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Services::Maps::Guidance::GuidanceRoute>(args, 0);

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

    static PyObject* GuidanceNavigator_StartSimulating(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"StartSimulating", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Services::Maps::Guidance::GuidanceRoute>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

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

    static PyObject* GuidanceNavigator_StartTracking(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"StartTracking", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* GuidanceNavigator_Stop(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"Stop", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* GuidanceNavigator_UpdateUserLocation(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"UpdateUserLocation", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Devices::Geolocation::Geocoordinate>(args, 0);

                self->obj.UpdateUserLocation(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"UpdateUserLocation", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Devices::Geolocation::Geocoordinate>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Devices::Geolocation::BasicGeoposition>(args, 1);

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

    static PyObject* GuidanceNavigator_get_AudioNotifications(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"AudioNotifications"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int GuidanceNavigator_put_AudioNotifications(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"AudioNotifications"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Services::Maps::Guidance::GuidanceAudioNotifications>(arg);

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

    static PyObject* GuidanceNavigator_get_AudioMeasurementSystem(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"AudioMeasurementSystem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int GuidanceNavigator_put_AudioMeasurementSystem(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"AudioMeasurementSystem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version 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::Services::Maps::Guidance::GuidanceAudioMeasurementSystem>(arg);

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

    static PyObject* GuidanceNavigator_get_IsGuidanceAudioMuted(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"IsGuidanceAudioMuted"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* GuidanceNavigator_get_UseAppProvidedVoice(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"UseAppProvidedVoice"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Windows::Services::Maps::Guidance::GuidanceNavigator::UseAppProvidedVoice());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* GuidanceNavigator_add_DestinationReached(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"DestinationReached"))
        {
            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::Services::Maps::Guidance::GuidanceNavigator, winrt::Windows::Foundation::IInspectable>>(arg);

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

    static PyObject* GuidanceNavigator_remove_DestinationReached(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"DestinationReached"))
        {
            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.DestinationReached(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* GuidanceNavigator_add_GuidanceUpdated(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"GuidanceUpdated"))
        {
            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::Services::Maps::Guidance::GuidanceNavigator, winrt::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs>>(arg);

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

    static PyObject* GuidanceNavigator_remove_GuidanceUpdated(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"GuidanceUpdated"))
        {
            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.GuidanceUpdated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* GuidanceNavigator_add_RerouteFailed(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"RerouteFailed"))
        {
            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::Services::Maps::Guidance::GuidanceNavigator, winrt::Windows::Foundation::IInspectable>>(arg);

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

    static PyObject* GuidanceNavigator_remove_RerouteFailed(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"RerouteFailed"))
        {
            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.RerouteFailed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* GuidanceNavigator_add_Rerouted(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"Rerouted"))
        {
            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::Services::Maps::Guidance::GuidanceNavigator, winrt::Windows::Services::Maps::Guidance::GuidanceReroutedEventArgs>>(arg);

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

    static PyObject* GuidanceNavigator_remove_Rerouted(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"Rerouted"))
        {
            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.Rerouted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* GuidanceNavigator_add_Rerouting(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"Rerouting"))
        {
            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::Services::Maps::Guidance::GuidanceNavigator, winrt::Windows::Foundation::IInspectable>>(arg);

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

    static PyObject* GuidanceNavigator_remove_Rerouting(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"Rerouting"))
        {
            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.Rerouting(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* GuidanceNavigator_add_UserLocationLost(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"UserLocationLost"))
        {
            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::Services::Maps::Guidance::GuidanceNavigator, winrt::Windows::Foundation::IInspectable>>(arg);

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

    static PyObject* GuidanceNavigator_remove_UserLocationLost(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"UserLocationLost"))
        {
            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.UserLocationLost(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* GuidanceNavigator_add_UserLocationRestored(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"UserLocationRestored"))
        {
            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::Services::Maps::Guidance::GuidanceNavigator, winrt::Windows::Foundation::IInspectable>>(arg);

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

    static PyObject* GuidanceNavigator_remove_UserLocationRestored(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"UserLocationRestored"))
        {
            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.UserLocationRestored(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* GuidanceNavigator_add_AudioNotificationRequested(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"AudioNotificationRequested"))
        {
            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::Services::Maps::Guidance::GuidanceNavigator, winrt::Windows::Services::Maps::Guidance::GuidanceAudioNotificationRequestedEventArgs>>(arg);

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

    static PyObject* GuidanceNavigator_remove_AudioNotificationRequested(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Services.Maps.Guidance.GuidanceNavigator", L"AudioNotificationRequested"))
        {
            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.AudioNotificationRequested(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_GuidanceNavigator(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Services::Maps::Guidance::GuidanceNavigator>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GuidanceNavigator(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::Services::Maps::Guidance::GuidanceNavigator>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GuidanceNavigator[] = {
        { "get_current", reinterpret_cast<PyCFunction>(GuidanceNavigator_GetCurrent), METH_VARARGS | METH_STATIC, nullptr },
        { "pause", reinterpret_cast<PyCFunction>(GuidanceNavigator_Pause), METH_VARARGS, nullptr },
        { "repeat_last_audio_notification", reinterpret_cast<PyCFunction>(GuidanceNavigator_RepeatLastAudioNotification), METH_VARARGS, nullptr },
        { "resume", reinterpret_cast<PyCFunction>(GuidanceNavigator_Resume), METH_VARARGS, nullptr },
        { "set_guidance_voice", reinterpret_cast<PyCFunction>(GuidanceNavigator_SetGuidanceVoice), METH_VARARGS, nullptr },
        { "start_navigating", reinterpret_cast<PyCFunction>(GuidanceNavigator_StartNavigating), METH_VARARGS, nullptr },
        { "start_simulating", reinterpret_cast<PyCFunction>(GuidanceNavigator_StartSimulating), METH_VARARGS, nullptr },
        { "start_tracking", reinterpret_cast<PyCFunction>(GuidanceNavigator_StartTracking), METH_VARARGS, nullptr },
        { "stop", reinterpret_cast<PyCFunction>(GuidanceNavigator_Stop), METH_VARARGS, nullptr },
        { "update_user_location", reinterpret_cast<PyCFunction>(GuidanceNavigator_UpdateUserLocation), METH_VARARGS, nullptr },
        { "add_destination_reached", reinterpret_cast<PyCFunction>(GuidanceNavigator_add_DestinationReached), METH_O, nullptr },
        { "remove_destination_reached", reinterpret_cast<PyCFunction>(GuidanceNavigator_remove_DestinationReached), METH_O, nullptr },
        { "add_guidance_updated", reinterpret_cast<PyCFunction>(GuidanceNavigator_add_GuidanceUpdated), METH_O, nullptr },
        { "remove_guidance_updated", reinterpret_cast<PyCFunction>(GuidanceNavigator_remove_GuidanceUpdated), METH_O, nullptr },
        { "add_reroute_failed", reinterpret_cast<PyCFunction>(GuidanceNavigator_add_RerouteFailed), METH_O, nullptr },
        { "remove_reroute_failed", reinterpret_cast<PyCFunction>(GuidanceNavigator_remove_RerouteFailed), METH_O, nullptr },
        { "add_rerouted", reinterpret_cast<PyCFunction>(GuidanceNavigator_add_Rerouted), METH_O, nullptr },
        { "remove_rerouted", reinterpret_cast<PyCFunction>(GuidanceNavigator_remove_Rerouted), METH_O, nullptr },
        { "add_rerouting", reinterpret_cast<PyCFunction>(GuidanceNavigator_add_Rerouting), METH_O, nullptr },
        { "remove_rerouting", reinterpret_cast<PyCFunction>(GuidanceNavigator_remove_Rerouting), METH_O, nullptr },
        { "add_user_location_lost", reinterpret_cast<PyCFunction>(GuidanceNavigator_add_UserLocationLost), METH_O, nullptr },
        { "remove_user_location_lost", reinterpret_cast<PyCFunction>(GuidanceNavigator_remove_UserLocationLost), METH_O, nullptr },
        { "add_user_location_restored", reinterpret_cast<PyCFunction>(GuidanceNavigator_add_UserLocationRestored), METH_O, nullptr },
        { "remove_user_location_restored", reinterpret_cast<PyCFunction>(GuidanceNavigator_remove_UserLocationRestored), METH_O, nullptr },
        { "add_audio_notification_requested", reinterpret_cast<PyCFunction>(GuidanceNavigator_add_AudioNotificationRequested), METH_O, nullptr },
        { "remove_audio_notification_requested", reinterpret_cast<PyCFunction>(GuidanceNavigator_remove_AudioNotificationRequested), METH_O, nullptr },
        { "_assign_array_", _assign_array_GuidanceNavigator, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GuidanceNavigator), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GuidanceNavigator[] = {
        { "audio_notifications", reinterpret_cast<getter>(GuidanceNavigator_get_AudioNotifications), reinterpret_cast<setter>(GuidanceNavigator_put_AudioNotifications), nullptr, nullptr },
        { "audio_measurement_system", reinterpret_cast<getter>(GuidanceNavigator_get_AudioMeasurementSystem), reinterpret_cast<setter>(GuidanceNavigator_put_AudioMeasurementSystem), nullptr, nullptr },
        { "is_guidance_audio_muted", reinterpret_cast<getter>(GuidanceNavigator_get_IsGuidanceAudioMuted), reinterpret_cast<setter>(GuidanceNavigator_put_IsGuidanceAudioMuted), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GuidanceNavigator[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GuidanceNavigator) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GuidanceNavigator) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GuidanceNavigator) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GuidanceNavigator) },
        { },
    };

    static PyType_Spec type_spec_GuidanceNavigator =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceNavigator",
        sizeof(py::wrapper::Windows::Services::Maps::Guidance::GuidanceNavigator),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GuidanceNavigator
    };

    static PyGetSetDef getset_GuidanceNavigator_Meta[] = {
        { "use_app_provided_voice", reinterpret_cast<getter>(GuidanceNavigator_get_UseAppProvidedVoice), nullptr, nullptr, nullptr },
        { }
    };

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

    static PyType_Spec type_spec_GuidanceNavigator_Meta =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceNavigator_Meta",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_GuidanceNavigator_Meta
    };

    // ----- GuidanceReroutedEventArgs class --------------------
    static constexpr const char* const type_name_GuidanceReroutedEventArgs = "GuidanceReroutedEventArgs";

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

    static void _dealloc_GuidanceReroutedEventArgs(py::wrapper::Windows::Services::Maps::Guidance::GuidanceReroutedEventArgs* 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* GuidanceReroutedEventArgs_get_Route(py::wrapper::Windows::Services::Maps::Guidance::GuidanceReroutedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs", L"Route"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_GuidanceReroutedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Services::Maps::Guidance::GuidanceReroutedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GuidanceReroutedEventArgs(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::Services::Maps::Guidance::GuidanceReroutedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GuidanceReroutedEventArgs[] = {
        { "_assign_array_", _assign_array_GuidanceReroutedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GuidanceReroutedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GuidanceReroutedEventArgs[] = {
        { "route", reinterpret_cast<getter>(GuidanceReroutedEventArgs_get_Route), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GuidanceReroutedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GuidanceReroutedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GuidanceReroutedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GuidanceReroutedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GuidanceReroutedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_GuidanceReroutedEventArgs =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceReroutedEventArgs",
        sizeof(py::wrapper::Windows::Services::Maps::Guidance::GuidanceReroutedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GuidanceReroutedEventArgs
    };

    // ----- GuidanceRoadSegment class --------------------
    static constexpr const char* const type_name_GuidanceRoadSegment = "GuidanceRoadSegment";

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

    static void _dealloc_GuidanceRoadSegment(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment* 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* GuidanceRoadSegment_get_Id(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSegment", 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* GuidanceRoadSegment_get_IsHighway(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSegment", L"IsHighway"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSegment_get_IsTollRoad(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSegment", L"IsTollRoad"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSegment_get_IsTunnel(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSegment", L"IsTunnel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSegment_get_Path(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSegment", L"Path"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSegment_get_RoadName(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSegment", L"RoadName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSegment_get_ShortRoadName(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSegment", L"ShortRoadName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSegment_get_SpeedLimit(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSegment", L"SpeedLimit"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSegment_get_TravelTime(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSegment", L"TravelTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSegment_get_IsScenic(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSegment", L"IsScenic"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_GuidanceRoadSegment(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Services::Maps::Guidance::GuidanceRoadSegment>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GuidanceRoadSegment(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::Services::Maps::Guidance::GuidanceRoadSegment>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GuidanceRoadSegment[] = {
        { "_assign_array_", _assign_array_GuidanceRoadSegment, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GuidanceRoadSegment), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GuidanceRoadSegment[] = {
        { "id", reinterpret_cast<getter>(GuidanceRoadSegment_get_Id), nullptr, nullptr, nullptr },
        { "is_highway", reinterpret_cast<getter>(GuidanceRoadSegment_get_IsHighway), nullptr, nullptr, nullptr },
        { "is_toll_road", reinterpret_cast<getter>(GuidanceRoadSegment_get_IsTollRoad), nullptr, nullptr, nullptr },
        { "is_tunnel", reinterpret_cast<getter>(GuidanceRoadSegment_get_IsTunnel), nullptr, nullptr, nullptr },
        { "path", reinterpret_cast<getter>(GuidanceRoadSegment_get_Path), nullptr, nullptr, nullptr },
        { "road_name", reinterpret_cast<getter>(GuidanceRoadSegment_get_RoadName), nullptr, nullptr, nullptr },
        { "short_road_name", reinterpret_cast<getter>(GuidanceRoadSegment_get_ShortRoadName), nullptr, nullptr, nullptr },
        { "speed_limit", reinterpret_cast<getter>(GuidanceRoadSegment_get_SpeedLimit), nullptr, nullptr, nullptr },
        { "travel_time", reinterpret_cast<getter>(GuidanceRoadSegment_get_TravelTime), nullptr, nullptr, nullptr },
        { "is_scenic", reinterpret_cast<getter>(GuidanceRoadSegment_get_IsScenic), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GuidanceRoadSegment[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GuidanceRoadSegment) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GuidanceRoadSegment) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GuidanceRoadSegment) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GuidanceRoadSegment) },
        { },
    };

    static PyType_Spec type_spec_GuidanceRoadSegment =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceRoadSegment",
        sizeof(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSegment),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GuidanceRoadSegment
    };

    // ----- GuidanceRoadSignpost class --------------------
    static constexpr const char* const type_name_GuidanceRoadSignpost = "GuidanceRoadSignpost";

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

    static void _dealloc_GuidanceRoadSignpost(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSignpost* 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* GuidanceRoadSignpost_get_BackgroundColor(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSignpost* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSignpost", L"BackgroundColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSignpost_get_Exit(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSignpost* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSignpost", L"Exit"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSignpost_get_ExitDirections(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSignpost* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSignpost", L"ExitDirections"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSignpost_get_ExitNumber(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSignpost* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSignpost", L"ExitNumber"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoadSignpost_get_ForegroundColor(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSignpost* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoadSignpost", L"ForegroundColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_GuidanceRoadSignpost(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Services::Maps::Guidance::GuidanceRoadSignpost>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GuidanceRoadSignpost(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::Services::Maps::Guidance::GuidanceRoadSignpost>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GuidanceRoadSignpost[] = {
        { "_assign_array_", _assign_array_GuidanceRoadSignpost, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GuidanceRoadSignpost), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GuidanceRoadSignpost[] = {
        { "background_color", reinterpret_cast<getter>(GuidanceRoadSignpost_get_BackgroundColor), nullptr, nullptr, nullptr },
        { "exit", reinterpret_cast<getter>(GuidanceRoadSignpost_get_Exit), nullptr, nullptr, nullptr },
        { "exit_directions", reinterpret_cast<getter>(GuidanceRoadSignpost_get_ExitDirections), nullptr, nullptr, nullptr },
        { "exit_number", reinterpret_cast<getter>(GuidanceRoadSignpost_get_ExitNumber), nullptr, nullptr, nullptr },
        { "foreground_color", reinterpret_cast<getter>(GuidanceRoadSignpost_get_ForegroundColor), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GuidanceRoadSignpost[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GuidanceRoadSignpost) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GuidanceRoadSignpost) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GuidanceRoadSignpost) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GuidanceRoadSignpost) },
        { },
    };

    static PyType_Spec type_spec_GuidanceRoadSignpost =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceRoadSignpost",
        sizeof(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoadSignpost),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GuidanceRoadSignpost
    };

    // ----- GuidanceRoute class --------------------
    static constexpr const char* const type_name_GuidanceRoute = "GuidanceRoute";

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

    static void _dealloc_GuidanceRoute(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoute* 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* GuidanceRoute_CanCreateFromMapRoute(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceRoute", L"CanCreateFromMapRoute", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Services::Maps::MapRoute>(args, 0);

                return py::convert(winrt::Windows::Services::Maps::Guidance::GuidanceRoute::CanCreateFromMapRoute(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* GuidanceRoute_ConvertToMapRoute(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoute* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceRoute", L"ConvertToMapRoute", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceRoute", L"TryCreateFromMapRoute", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Services::Maps::MapRoute>(args, 0);

                return py::convert(winrt::Windows::Services::Maps::Guidance::GuidanceRoute::TryCreateFromMapRoute(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* GuidanceRoute_get_BoundingBox(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoute* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoute", L"BoundingBox"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoute_get_Distance(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoute* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoute", L"Distance"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoute_get_Duration(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoute* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoute", 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* GuidanceRoute_get_Maneuvers(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoute* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoute", L"Maneuvers"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoute_get_Path(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoute* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoute", L"Path"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceRoute_get_RoadSegments(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoute* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceRoute", L"RoadSegments"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_GuidanceRoute(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Services::Maps::Guidance::GuidanceRoute>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GuidanceRoute(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::Services::Maps::Guidance::GuidanceRoute>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GuidanceRoute[] = {
        { "can_create_from_map_route", reinterpret_cast<PyCFunction>(GuidanceRoute_CanCreateFromMapRoute), METH_VARARGS | METH_STATIC, nullptr },
        { "convert_to_map_route", reinterpret_cast<PyCFunction>(GuidanceRoute_ConvertToMapRoute), METH_VARARGS, nullptr },
        { "try_create_from_map_route", reinterpret_cast<PyCFunction>(GuidanceRoute_TryCreateFromMapRoute), METH_VARARGS | METH_STATIC, nullptr },
        { "_assign_array_", _assign_array_GuidanceRoute, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GuidanceRoute), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GuidanceRoute[] = {
        { "bounding_box", reinterpret_cast<getter>(GuidanceRoute_get_BoundingBox), nullptr, nullptr, nullptr },
        { "distance", reinterpret_cast<getter>(GuidanceRoute_get_Distance), nullptr, nullptr, nullptr },
        { "duration", reinterpret_cast<getter>(GuidanceRoute_get_Duration), nullptr, nullptr, nullptr },
        { "maneuvers", reinterpret_cast<getter>(GuidanceRoute_get_Maneuvers), nullptr, nullptr, nullptr },
        { "path", reinterpret_cast<getter>(GuidanceRoute_get_Path), nullptr, nullptr, nullptr },
        { "road_segments", reinterpret_cast<getter>(GuidanceRoute_get_RoadSegments), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GuidanceRoute[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GuidanceRoute) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GuidanceRoute) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GuidanceRoute) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GuidanceRoute) },
        { },
    };

    static PyType_Spec type_spec_GuidanceRoute =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceRoute",
        sizeof(py::wrapper::Windows::Services::Maps::Guidance::GuidanceRoute),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GuidanceRoute
    };

    // ----- GuidanceTelemetryCollector class --------------------
    static constexpr const char* const type_name_GuidanceTelemetryCollector = "GuidanceTelemetryCollector";

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

    static void _dealloc_GuidanceTelemetryCollector(py::wrapper::Windows::Services::Maps::Guidance::GuidanceTelemetryCollector* 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* GuidanceTelemetryCollector_ClearLocalData(py::wrapper::Windows::Services::Maps::Guidance::GuidanceTelemetryCollector* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceTelemetryCollector", L"ClearLocalData", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Services.Maps.Guidance.GuidanceTelemetryCollector", L"GetCurrent", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::Services::Maps::Guidance::GuidanceTelemetryCollector::GetCurrent());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* GuidanceTelemetryCollector_get_UploadFrequency(py::wrapper::Windows::Services::Maps::Guidance::GuidanceTelemetryCollector* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceTelemetryCollector", L"UploadFrequency"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int GuidanceTelemetryCollector_put_UploadFrequency(py::wrapper::Windows::Services::Maps::Guidance::GuidanceTelemetryCollector* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceTelemetryCollector", L"UploadFrequency"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

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

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

    static PyObject* GuidanceTelemetryCollector_get_SpeedTrigger(py::wrapper::Windows::Services::Maps::Guidance::GuidanceTelemetryCollector* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceTelemetryCollector", L"SpeedTrigger"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* GuidanceTelemetryCollector_get_Enabled(py::wrapper::Windows::Services::Maps::Guidance::GuidanceTelemetryCollector* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceTelemetryCollector", L"Enabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_GuidanceTelemetryCollector(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Services::Maps::Guidance::GuidanceTelemetryCollector>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GuidanceTelemetryCollector(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::Services::Maps::Guidance::GuidanceTelemetryCollector>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GuidanceTelemetryCollector[] = {
        { "clear_local_data", reinterpret_cast<PyCFunction>(GuidanceTelemetryCollector_ClearLocalData), METH_VARARGS, nullptr },
        { "get_current", reinterpret_cast<PyCFunction>(GuidanceTelemetryCollector_GetCurrent), METH_VARARGS | METH_STATIC, nullptr },
        { "_assign_array_", _assign_array_GuidanceTelemetryCollector, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GuidanceTelemetryCollector), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GuidanceTelemetryCollector[] = {
        { "upload_frequency", reinterpret_cast<getter>(GuidanceTelemetryCollector_get_UploadFrequency), reinterpret_cast<setter>(GuidanceTelemetryCollector_put_UploadFrequency), nullptr, nullptr },
        { "speed_trigger", reinterpret_cast<getter>(GuidanceTelemetryCollector_get_SpeedTrigger), reinterpret_cast<setter>(GuidanceTelemetryCollector_put_SpeedTrigger), nullptr, nullptr },
        { "enabled", reinterpret_cast<getter>(GuidanceTelemetryCollector_get_Enabled), reinterpret_cast<setter>(GuidanceTelemetryCollector_put_Enabled), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GuidanceTelemetryCollector[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GuidanceTelemetryCollector) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GuidanceTelemetryCollector) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GuidanceTelemetryCollector) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GuidanceTelemetryCollector) },
        { },
    };

    static PyType_Spec type_spec_GuidanceTelemetryCollector =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceTelemetryCollector",
        sizeof(py::wrapper::Windows::Services::Maps::Guidance::GuidanceTelemetryCollector),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GuidanceTelemetryCollector
    };

    // ----- GuidanceUpdatedEventArgs class --------------------
    static constexpr const char* const type_name_GuidanceUpdatedEventArgs = "GuidanceUpdatedEventArgs";

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

    static void _dealloc_GuidanceUpdatedEventArgs(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* 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* GuidanceUpdatedEventArgs_get_AfterNextManeuver(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"AfterNextManeuver"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_AfterNextManeuverDistance(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"AfterNextManeuverDistance"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_CurrentLocation(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"CurrentLocation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_DistanceToDestination(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"DistanceToDestination"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_ElapsedDistance(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"ElapsedDistance"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_ElapsedTime(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"ElapsedTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_IsNewManeuver(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"IsNewManeuver"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_LaneInfo(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"LaneInfo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_Mode(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"Mode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_NextManeuver(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"NextManeuver"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_NextManeuverDistance(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"NextManeuverDistance"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_RoadName(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"RoadName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_Route(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"Route"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* GuidanceUpdatedEventArgs_get_TimeToDestination(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs", L"TimeToDestination"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_GuidanceUpdatedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GuidanceUpdatedEventArgs(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::Services::Maps::Guidance::GuidanceUpdatedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GuidanceUpdatedEventArgs[] = {
        { "_assign_array_", _assign_array_GuidanceUpdatedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GuidanceUpdatedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GuidanceUpdatedEventArgs[] = {
        { "after_next_maneuver", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_AfterNextManeuver), nullptr, nullptr, nullptr },
        { "after_next_maneuver_distance", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_AfterNextManeuverDistance), nullptr, nullptr, nullptr },
        { "current_location", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_CurrentLocation), nullptr, nullptr, nullptr },
        { "distance_to_destination", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_DistanceToDestination), nullptr, nullptr, nullptr },
        { "elapsed_distance", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_ElapsedDistance), nullptr, nullptr, nullptr },
        { "elapsed_time", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_ElapsedTime), nullptr, nullptr, nullptr },
        { "is_new_maneuver", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_IsNewManeuver), nullptr, nullptr, nullptr },
        { "lane_info", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_LaneInfo), nullptr, nullptr, nullptr },
        { "mode", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_Mode), nullptr, nullptr, nullptr },
        { "next_maneuver", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_NextManeuver), nullptr, nullptr, nullptr },
        { "next_maneuver_distance", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_NextManeuverDistance), nullptr, nullptr, nullptr },
        { "road_name", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_RoadName), nullptr, nullptr, nullptr },
        { "route", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_Route), nullptr, nullptr, nullptr },
        { "time_to_destination", reinterpret_cast<getter>(GuidanceUpdatedEventArgs_get_TimeToDestination), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GuidanceUpdatedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GuidanceUpdatedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GuidanceUpdatedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GuidanceUpdatedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GuidanceUpdatedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_GuidanceUpdatedEventArgs =
    {
        "_winsdk_Windows_Services_Maps_Guidance.GuidanceUpdatedEventArgs",
        sizeof(py::wrapper::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GuidanceUpdatedEventArgs
    };

    // ----- Windows.Services.Maps.Guidance Initialization --------------------
    PyDoc_STRVAR(module_doc, "Windows::Services::Maps::Guidance");

    static PyMethodDef module_methods[] = {
        {"_register_GuidanceAudioMeasurementSystem", register_GuidanceAudioMeasurementSystem, METH_O, "registers type"},
        {"_register_GuidanceAudioNotificationKind", register_GuidanceAudioNotificationKind, METH_O, "registers type"},
        {"_register_GuidanceAudioNotifications", register_GuidanceAudioNotifications, METH_O, "registers type"},
        {"_register_GuidanceLaneMarkers", register_GuidanceLaneMarkers, METH_O, "registers type"},
        {"_register_GuidanceManeuverKind", register_GuidanceManeuverKind, METH_O, "registers type"},
        {"_register_GuidanceMode", register_GuidanceMode, 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_GuidanceAudioMeasurementSystem);
        Py_VISIT(state->type_GuidanceAudioNotificationKind);
        Py_VISIT(state->type_GuidanceAudioNotifications);
        Py_VISIT(state->type_GuidanceLaneMarkers);
        Py_VISIT(state->type_GuidanceManeuverKind);
        Py_VISIT(state->type_GuidanceMode);
        Py_VISIT(state->type_GuidanceAudioNotificationRequestedEventArgs);
        Py_VISIT(state->type_GuidanceLaneInfo);
        Py_VISIT(state->type_GuidanceManeuver);
        Py_VISIT(state->type_GuidanceMapMatchedCoordinate);
        Py_VISIT(state->type_GuidanceNavigator);
        Py_VISIT(state->type_GuidanceReroutedEventArgs);
        Py_VISIT(state->type_GuidanceRoadSegment);
        Py_VISIT(state->type_GuidanceRoadSignpost);
        Py_VISIT(state->type_GuidanceRoute);
        Py_VISIT(state->type_GuidanceTelemetryCollector);
        Py_VISIT(state->type_GuidanceUpdatedEventArgs);

        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_GuidanceAudioMeasurementSystem);
        Py_CLEAR(state->type_GuidanceAudioNotificationKind);
        Py_CLEAR(state->type_GuidanceAudioNotifications);
        Py_CLEAR(state->type_GuidanceLaneMarkers);
        Py_CLEAR(state->type_GuidanceManeuverKind);
        Py_CLEAR(state->type_GuidanceMode);
        Py_CLEAR(state->type_GuidanceAudioNotificationRequestedEventArgs);
        Py_CLEAR(state->type_GuidanceLaneInfo);
        Py_CLEAR(state->type_GuidanceManeuver);
        Py_CLEAR(state->type_GuidanceMapMatchedCoordinate);
        Py_CLEAR(state->type_GuidanceNavigator);
        Py_CLEAR(state->type_GuidanceReroutedEventArgs);
        Py_CLEAR(state->type_GuidanceRoadSegment);
        Py_CLEAR(state->type_GuidanceRoadSignpost);
        Py_CLEAR(state->type_GuidanceRoute);
        Py_CLEAR(state->type_GuidanceTelemetryCollector);
        Py_CLEAR(state->type_GuidanceUpdatedEventArgs);

        return 0;
    }


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

} // py::cpp::Windows::Services::Maps::Guidance

PyMODINIT_FUNC PyInit__winsdk_Windows_Services_Maps_Guidance(void) noexcept
{
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    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_GuidanceAudioNotificationRequestedEventArgs = py::register_python_type(module.get(), type_name_GuidanceAudioNotificationRequestedEventArgs, &type_spec_GuidanceAudioNotificationRequestedEventArgs, bases.get(), nullptr);
    if (!state->type_GuidanceAudioNotificationRequestedEventArgs)
    {
        return nullptr;
    }

    state->type_GuidanceLaneInfo = py::register_python_type(module.get(), type_name_GuidanceLaneInfo, &type_spec_GuidanceLaneInfo, bases.get(), nullptr);
    if (!state->type_GuidanceLaneInfo)
    {
        return nullptr;
    }

    state->type_GuidanceManeuver = py::register_python_type(module.get(), type_name_GuidanceManeuver, &type_spec_GuidanceManeuver, bases.get(), nullptr);
    if (!state->type_GuidanceManeuver)
    {
        return nullptr;
    }

    state->type_GuidanceMapMatchedCoordinate = py::register_python_type(module.get(), type_name_GuidanceMapMatchedCoordinate, &type_spec_GuidanceMapMatchedCoordinate, bases.get(), nullptr);
    if (!state->type_GuidanceMapMatchedCoordinate)
    {
        return nullptr;
    }

    py::pyobj_handle type_GuidanceNavigator_Meta{PyType_FromSpec(&type_spec_GuidanceNavigator_Meta)};
    if (!type_GuidanceNavigator_Meta)
    {
        return nullptr;
    }

    state->type_GuidanceNavigator = py::register_python_type(module.get(), type_name_GuidanceNavigator, &type_spec_GuidanceNavigator, bases.get(), reinterpret_cast<PyTypeObject*>(type_GuidanceNavigator_Meta.get()));
    if (!state->type_GuidanceNavigator)
    {
        return nullptr;
    }

    state->type_GuidanceReroutedEventArgs = py::register_python_type(module.get(), type_name_GuidanceReroutedEventArgs, &type_spec_GuidanceReroutedEventArgs, bases.get(), nullptr);
    if (!state->type_GuidanceReroutedEventArgs)
    {
        return nullptr;
    }

    state->type_GuidanceRoadSegment = py::register_python_type(module.get(), type_name_GuidanceRoadSegment, &type_spec_GuidanceRoadSegment, bases.get(), nullptr);
    if (!state->type_GuidanceRoadSegment)
    {
        return nullptr;
    }

    state->type_GuidanceRoadSignpost = py::register_python_type(module.get(), type_name_GuidanceRoadSignpost, &type_spec_GuidanceRoadSignpost, bases.get(), nullptr);
    if (!state->type_GuidanceRoadSignpost)
    {
        return nullptr;
    }

    state->type_GuidanceRoute = py::register_python_type(module.get(), type_name_GuidanceRoute, &type_spec_GuidanceRoute, bases.get(), nullptr);
    if (!state->type_GuidanceRoute)
    {
        return nullptr;
    }

    state->type_GuidanceTelemetryCollector = py::register_python_type(module.get(), type_name_GuidanceTelemetryCollector, &type_spec_GuidanceTelemetryCollector, bases.get(), nullptr);
    if (!state->type_GuidanceTelemetryCollector)
    {
        return nullptr;
    }

    state->type_GuidanceUpdatedEventArgs = py::register_python_type(module.get(), type_name_GuidanceUpdatedEventArgs, &type_spec_GuidanceUpdatedEventArgs, bases.get(), nullptr);
    if (!state->type_GuidanceUpdatedEventArgs)
    {
        return nullptr;
    }


    return module.detach();
}

PyObject* py::py_type<winrt::Windows::Services::Maps::Guidance::GuidanceAudioMeasurementSystem>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceAudioMeasurementSystem;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceAudioMeasurementSystem is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Services::Maps::Guidance::GuidanceAudioNotificationKind>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceAudioNotificationKind;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceAudioNotificationKind is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Services::Maps::Guidance::GuidanceAudioNotifications>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceAudioNotifications;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceAudioNotifications is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Services::Maps::Guidance::GuidanceLaneMarkers>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceLaneMarkers;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceLaneMarkers is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Services::Maps::Guidance::GuidanceManeuverKind>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceManeuverKind;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceManeuverKind is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Services::Maps::Guidance::GuidanceMode>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceMode;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceMode is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Services::Maps::Guidance::GuidanceAudioNotificationRequestedEventArgs>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceAudioNotificationRequestedEventArgs;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceAudioNotificationRequestedEventArgs is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Services::Maps::Guidance::GuidanceLaneInfo>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceLaneInfo;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceLaneInfo is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Services::Maps::Guidance::GuidanceManeuver>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceManeuver;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceManeuver is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Services::Maps::Guidance::GuidanceMapMatchedCoordinate>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceMapMatchedCoordinate;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceMapMatchedCoordinate is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Services::Maps::Guidance::GuidanceNavigator>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceNavigator;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceNavigator is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Services::Maps::Guidance::GuidanceReroutedEventArgs>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceReroutedEventArgs;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceReroutedEventArgs is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Services::Maps::Guidance::GuidanceRoadSegment>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceRoadSegment;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceRoadSegment is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Services::Maps::Guidance::GuidanceRoadSignpost>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceRoadSignpost;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceRoadSignpost is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Services::Maps::Guidance::GuidanceRoute>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceRoute;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceRoute is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Services::Maps::Guidance::GuidanceTelemetryCollector>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceTelemetryCollector;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceTelemetryCollector is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Services::Maps::Guidance;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_GuidanceUpdatedEventArgs;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Services::Maps::Guidance::GuidanceUpdatedEventArgs is not registered");
        return nullptr;
    }

    return python_type;
}
