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

#include "py.Windows.ApplicationModel.Appointments.DataProvider.h"

namespace py::cpp::Windows::ApplicationModel::Appointments::DataProvider
{
    // ----- AppointmentCalendarCancelMeetingRequest class --------------------

    static PyObject* _new_AppointmentCalendarCancelMeetingRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarCancelMeetingRequest(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarCancelMeetingRequest_ReportCompletedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequest", L"ReportCompletedAsync", 0);
                }

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

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

    static PyObject* AppointmentCalendarCancelMeetingRequest_ReportFailedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequest", L"ReportFailedAsync", 0);
                }

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

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

    static PyObject* AppointmentCalendarCancelMeetingRequest_get_AppointmentCalendarLocalId(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequest", L"AppointmentCalendarLocalId");
            }

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

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

    static PyObject* AppointmentCalendarCancelMeetingRequest_get_AppointmentLocalId(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequest", L"AppointmentLocalId");
            }

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

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

    static PyObject* AppointmentCalendarCancelMeetingRequest_get_AppointmentOriginalStartTime(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequest", L"AppointmentOriginalStartTime");
            }

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

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

    static PyObject* AppointmentCalendarCancelMeetingRequest_get_Comment(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequest", L"Comment");
            }

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

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

    static PyObject* AppointmentCalendarCancelMeetingRequest_get_NotifyInvitees(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequest", L"NotifyInvitees");
            }

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

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

    static PyObject* AppointmentCalendarCancelMeetingRequest_get_Subject(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequest", L"Subject");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarCancelMeetingRequest(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarCancelMeetingRequest(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarCancelMeetingRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarCancelMeetingRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarCancelMeetingRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarCancelMeetingRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarCancelMeetingRequest), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarCancelMeetingRequest[] = {
        { "appointment_calendar_local_id", reinterpret_cast<getter>(AppointmentCalendarCancelMeetingRequest_get_AppointmentCalendarLocalId), nullptr, nullptr, nullptr },
        { "appointment_local_id", reinterpret_cast<getter>(AppointmentCalendarCancelMeetingRequest_get_AppointmentLocalId), nullptr, nullptr, nullptr },
        { "appointment_original_start_time", reinterpret_cast<getter>(AppointmentCalendarCancelMeetingRequest_get_AppointmentOriginalStartTime), nullptr, nullptr, nullptr },
        { "comment", reinterpret_cast<getter>(AppointmentCalendarCancelMeetingRequest_get_Comment), nullptr, nullptr, nullptr },
        { "notify_invitees", reinterpret_cast<getter>(AppointmentCalendarCancelMeetingRequest_get_NotifyInvitees), nullptr, nullptr, nullptr },
        { "subject", reinterpret_cast<getter>(AppointmentCalendarCancelMeetingRequest_get_Subject), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarCancelMeetingRequest[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarCancelMeetingRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarCancelMeetingRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarCancelMeetingRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarCancelMeetingRequest) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarCancelMeetingRequest = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarCancelMeetingRequest",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarCancelMeetingRequest};

    // ----- AppointmentCalendarCancelMeetingRequestEventArgs class --------------------

    static PyObject* _new_AppointmentCalendarCancelMeetingRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarCancelMeetingRequestEventArgs(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarCancelMeetingRequestEventArgs_GetDeferral(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs", L"GetDeferral", 0);
                }

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

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

    static PyObject* AppointmentCalendarCancelMeetingRequestEventArgs_get_Request(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequestEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs", L"Request");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarCancelMeetingRequestEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequestEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarCancelMeetingRequestEventArgs(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarCancelMeetingRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(AppointmentCalendarCancelMeetingRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarCancelMeetingRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarCancelMeetingRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarCancelMeetingRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(AppointmentCalendarCancelMeetingRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarCancelMeetingRequestEventArgs[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarCancelMeetingRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarCancelMeetingRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarCancelMeetingRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarCancelMeetingRequestEventArgs) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarCancelMeetingRequestEventArgs = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarCancelMeetingRequestEventArgs",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarCancelMeetingRequestEventArgs};

    // ----- AppointmentCalendarCreateOrUpdateAppointmentRequest class --------------------

    static PyObject* _new_AppointmentCalendarCreateOrUpdateAppointmentRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarCreateOrUpdateAppointmentRequest(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarCreateOrUpdateAppointmentRequest_ReportCompletedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequest", L"ReportCompletedAsync", 1);
                }

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

                auto param0 = py::convert_to<winrt::Windows::ApplicationModel::Appointments::Appointment>(args, 0);

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

    static PyObject* AppointmentCalendarCreateOrUpdateAppointmentRequest_ReportFailedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequest", L"ReportFailedAsync", 0);
                }

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

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

    static PyObject* AppointmentCalendarCreateOrUpdateAppointmentRequest_get_Appointment(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequest", L"Appointment");
            }

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

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

    static PyObject* AppointmentCalendarCreateOrUpdateAppointmentRequest_get_AppointmentCalendarLocalId(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequest", L"AppointmentCalendarLocalId");
            }

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

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

    static PyObject* AppointmentCalendarCreateOrUpdateAppointmentRequest_get_ChangedProperties(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequest", L"ChangedProperties");
            }

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

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

    static PyObject* AppointmentCalendarCreateOrUpdateAppointmentRequest_get_NotifyInvitees(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequest", L"NotifyInvitees");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarCreateOrUpdateAppointmentRequest(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarCreateOrUpdateAppointmentRequest(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarCreateOrUpdateAppointmentRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarCreateOrUpdateAppointmentRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarCreateOrUpdateAppointmentRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarCreateOrUpdateAppointmentRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarCreateOrUpdateAppointmentRequest), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarCreateOrUpdateAppointmentRequest[] = {
        { "appointment", reinterpret_cast<getter>(AppointmentCalendarCreateOrUpdateAppointmentRequest_get_Appointment), nullptr, nullptr, nullptr },
        { "appointment_calendar_local_id", reinterpret_cast<getter>(AppointmentCalendarCreateOrUpdateAppointmentRequest_get_AppointmentCalendarLocalId), nullptr, nullptr, nullptr },
        { "changed_properties", reinterpret_cast<getter>(AppointmentCalendarCreateOrUpdateAppointmentRequest_get_ChangedProperties), nullptr, nullptr, nullptr },
        { "notify_invitees", reinterpret_cast<getter>(AppointmentCalendarCreateOrUpdateAppointmentRequest_get_NotifyInvitees), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarCreateOrUpdateAppointmentRequest[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarCreateOrUpdateAppointmentRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarCreateOrUpdateAppointmentRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarCreateOrUpdateAppointmentRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarCreateOrUpdateAppointmentRequest) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarCreateOrUpdateAppointmentRequest = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarCreateOrUpdateAppointmentRequest",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarCreateOrUpdateAppointmentRequest};

    // ----- AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs class --------------------

    static PyObject* _new_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs_GetDeferral(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs", L"GetDeferral", 0);
                }

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

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

    static PyObject* AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs_get_Request(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs", L"Request");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs};

    // ----- AppointmentCalendarForwardMeetingRequest class --------------------

    static PyObject* _new_AppointmentCalendarForwardMeetingRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarForwardMeetingRequest(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarForwardMeetingRequest_ReportCompletedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest", L"ReportCompletedAsync", 0);
                }

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

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

    static PyObject* AppointmentCalendarForwardMeetingRequest_ReportFailedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest", L"ReportFailedAsync", 0);
                }

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

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

    static PyObject* AppointmentCalendarForwardMeetingRequest_get_AppointmentCalendarLocalId(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest", L"AppointmentCalendarLocalId");
            }

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

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

    static PyObject* AppointmentCalendarForwardMeetingRequest_get_AppointmentLocalId(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest", L"AppointmentLocalId");
            }

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

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

    static PyObject* AppointmentCalendarForwardMeetingRequest_get_AppointmentOriginalStartTime(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest", L"AppointmentOriginalStartTime");
            }

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

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

    static PyObject* AppointmentCalendarForwardMeetingRequest_get_Comment(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest", L"Comment");
            }

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

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

    static PyObject* AppointmentCalendarForwardMeetingRequest_get_ForwardHeader(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest", L"ForwardHeader");
            }

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

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

    static PyObject* AppointmentCalendarForwardMeetingRequest_get_Invitees(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest", L"Invitees");
            }

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

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

    static PyObject* AppointmentCalendarForwardMeetingRequest_get_Subject(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest", L"Subject");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarForwardMeetingRequest(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarForwardMeetingRequest(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarForwardMeetingRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarForwardMeetingRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarForwardMeetingRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarForwardMeetingRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarForwardMeetingRequest), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarForwardMeetingRequest[] = {
        { "appointment_calendar_local_id", reinterpret_cast<getter>(AppointmentCalendarForwardMeetingRequest_get_AppointmentCalendarLocalId), nullptr, nullptr, nullptr },
        { "appointment_local_id", reinterpret_cast<getter>(AppointmentCalendarForwardMeetingRequest_get_AppointmentLocalId), nullptr, nullptr, nullptr },
        { "appointment_original_start_time", reinterpret_cast<getter>(AppointmentCalendarForwardMeetingRequest_get_AppointmentOriginalStartTime), nullptr, nullptr, nullptr },
        { "comment", reinterpret_cast<getter>(AppointmentCalendarForwardMeetingRequest_get_Comment), nullptr, nullptr, nullptr },
        { "forward_header", reinterpret_cast<getter>(AppointmentCalendarForwardMeetingRequest_get_ForwardHeader), nullptr, nullptr, nullptr },
        { "invitees", reinterpret_cast<getter>(AppointmentCalendarForwardMeetingRequest_get_Invitees), nullptr, nullptr, nullptr },
        { "subject", reinterpret_cast<getter>(AppointmentCalendarForwardMeetingRequest_get_Subject), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarForwardMeetingRequest[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarForwardMeetingRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarForwardMeetingRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarForwardMeetingRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarForwardMeetingRequest) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarForwardMeetingRequest = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarForwardMeetingRequest",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarForwardMeetingRequest};

    // ----- AppointmentCalendarForwardMeetingRequestEventArgs class --------------------

    static PyObject* _new_AppointmentCalendarForwardMeetingRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarForwardMeetingRequestEventArgs(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarForwardMeetingRequestEventArgs_GetDeferral(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs", L"GetDeferral", 0);
                }

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

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

    static PyObject* AppointmentCalendarForwardMeetingRequestEventArgs_get_Request(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequestEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs", L"Request");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarForwardMeetingRequestEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequestEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarForwardMeetingRequestEventArgs(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarForwardMeetingRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(AppointmentCalendarForwardMeetingRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarForwardMeetingRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarForwardMeetingRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarForwardMeetingRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(AppointmentCalendarForwardMeetingRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarForwardMeetingRequestEventArgs[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarForwardMeetingRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarForwardMeetingRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarForwardMeetingRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarForwardMeetingRequestEventArgs) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarForwardMeetingRequestEventArgs = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarForwardMeetingRequestEventArgs",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarForwardMeetingRequestEventArgs};

    // ----- AppointmentCalendarProposeNewTimeForMeetingRequest class --------------------

    static PyObject* _new_AppointmentCalendarProposeNewTimeForMeetingRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarProposeNewTimeForMeetingRequest(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarProposeNewTimeForMeetingRequest_ReportCompletedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest", L"ReportCompletedAsync", 0);
                }

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

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

    static PyObject* AppointmentCalendarProposeNewTimeForMeetingRequest_ReportFailedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest", L"ReportFailedAsync", 0);
                }

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

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

    static PyObject* AppointmentCalendarProposeNewTimeForMeetingRequest_get_AppointmentCalendarLocalId(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest", L"AppointmentCalendarLocalId");
            }

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

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

    static PyObject* AppointmentCalendarProposeNewTimeForMeetingRequest_get_AppointmentLocalId(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest", L"AppointmentLocalId");
            }

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

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

    static PyObject* AppointmentCalendarProposeNewTimeForMeetingRequest_get_AppointmentOriginalStartTime(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest", L"AppointmentOriginalStartTime");
            }

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

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

    static PyObject* AppointmentCalendarProposeNewTimeForMeetingRequest_get_Comment(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest", L"Comment");
            }

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

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

    static PyObject* AppointmentCalendarProposeNewTimeForMeetingRequest_get_NewDuration(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest", L"NewDuration");
            }

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

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

    static PyObject* AppointmentCalendarProposeNewTimeForMeetingRequest_get_NewStartTime(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest", L"NewStartTime");
            }

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

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

    static PyObject* AppointmentCalendarProposeNewTimeForMeetingRequest_get_Subject(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest", L"Subject");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarProposeNewTimeForMeetingRequest(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarProposeNewTimeForMeetingRequest(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarProposeNewTimeForMeetingRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarProposeNewTimeForMeetingRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarProposeNewTimeForMeetingRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarProposeNewTimeForMeetingRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarProposeNewTimeForMeetingRequest), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarProposeNewTimeForMeetingRequest[] = {
        { "appointment_calendar_local_id", reinterpret_cast<getter>(AppointmentCalendarProposeNewTimeForMeetingRequest_get_AppointmentCalendarLocalId), nullptr, nullptr, nullptr },
        { "appointment_local_id", reinterpret_cast<getter>(AppointmentCalendarProposeNewTimeForMeetingRequest_get_AppointmentLocalId), nullptr, nullptr, nullptr },
        { "appointment_original_start_time", reinterpret_cast<getter>(AppointmentCalendarProposeNewTimeForMeetingRequest_get_AppointmentOriginalStartTime), nullptr, nullptr, nullptr },
        { "comment", reinterpret_cast<getter>(AppointmentCalendarProposeNewTimeForMeetingRequest_get_Comment), nullptr, nullptr, nullptr },
        { "new_duration", reinterpret_cast<getter>(AppointmentCalendarProposeNewTimeForMeetingRequest_get_NewDuration), nullptr, nullptr, nullptr },
        { "new_start_time", reinterpret_cast<getter>(AppointmentCalendarProposeNewTimeForMeetingRequest_get_NewStartTime), nullptr, nullptr, nullptr },
        { "subject", reinterpret_cast<getter>(AppointmentCalendarProposeNewTimeForMeetingRequest_get_Subject), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarProposeNewTimeForMeetingRequest[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarProposeNewTimeForMeetingRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarProposeNewTimeForMeetingRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarProposeNewTimeForMeetingRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarProposeNewTimeForMeetingRequest) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarProposeNewTimeForMeetingRequest = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarProposeNewTimeForMeetingRequest",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarProposeNewTimeForMeetingRequest};

    // ----- AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs class --------------------

    static PyObject* _new_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs_GetDeferral(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs", L"GetDeferral", 0);
                }

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

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

    static PyObject* AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs_get_Request(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs", L"Request");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs};

    // ----- AppointmentCalendarSyncManagerSyncRequest class --------------------

    static PyObject* _new_AppointmentCalendarSyncManagerSyncRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarSyncManagerSyncRequest(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarSyncManagerSyncRequest_ReportCompletedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequest", L"ReportCompletedAsync", 0);
                }

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

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

    static PyObject* AppointmentCalendarSyncManagerSyncRequest_ReportFailedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequest", L"ReportFailedAsync", 0);
                }

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

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

    static PyObject* AppointmentCalendarSyncManagerSyncRequest_get_AppointmentCalendarLocalId(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequest", L"AppointmentCalendarLocalId");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarSyncManagerSyncRequest(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequest>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarSyncManagerSyncRequest(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarSyncManagerSyncRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarSyncManagerSyncRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarSyncManagerSyncRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarSyncManagerSyncRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarSyncManagerSyncRequest), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarSyncManagerSyncRequest[] = {
        { "appointment_calendar_local_id", reinterpret_cast<getter>(AppointmentCalendarSyncManagerSyncRequest_get_AppointmentCalendarLocalId), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarSyncManagerSyncRequest[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarSyncManagerSyncRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarSyncManagerSyncRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarSyncManagerSyncRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarSyncManagerSyncRequest) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarSyncManagerSyncRequest = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarSyncManagerSyncRequest",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarSyncManagerSyncRequest};

    // ----- AppointmentCalendarSyncManagerSyncRequestEventArgs class --------------------

    static PyObject* _new_AppointmentCalendarSyncManagerSyncRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarSyncManagerSyncRequestEventArgs(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarSyncManagerSyncRequestEventArgs_GetDeferral(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs", L"GetDeferral", 0);
                }

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

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

    static PyObject* AppointmentCalendarSyncManagerSyncRequestEventArgs_get_Request(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequestEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs", L"Request");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarSyncManagerSyncRequestEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequestEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarSyncManagerSyncRequestEventArgs(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarSyncManagerSyncRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(AppointmentCalendarSyncManagerSyncRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarSyncManagerSyncRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarSyncManagerSyncRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarSyncManagerSyncRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(AppointmentCalendarSyncManagerSyncRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarSyncManagerSyncRequestEventArgs[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarSyncManagerSyncRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarSyncManagerSyncRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarSyncManagerSyncRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarSyncManagerSyncRequestEventArgs) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarSyncManagerSyncRequestEventArgs = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarSyncManagerSyncRequestEventArgs",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarSyncManagerSyncRequestEventArgs};

    // ----- AppointmentCalendarUpdateMeetingResponseRequest class --------------------

    static PyObject* _new_AppointmentCalendarUpdateMeetingResponseRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarUpdateMeetingResponseRequest(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarUpdateMeetingResponseRequest_ReportCompletedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest", L"ReportCompletedAsync", 0);
                }

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

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

    static PyObject* AppointmentCalendarUpdateMeetingResponseRequest_ReportFailedAsync(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest", L"ReportFailedAsync", 0);
                }

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

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

    static PyObject* AppointmentCalendarUpdateMeetingResponseRequest_get_AppointmentCalendarLocalId(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest", L"AppointmentCalendarLocalId");
            }

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

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

    static PyObject* AppointmentCalendarUpdateMeetingResponseRequest_get_AppointmentLocalId(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest", L"AppointmentLocalId");
            }

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

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

    static PyObject* AppointmentCalendarUpdateMeetingResponseRequest_get_AppointmentOriginalStartTime(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest", L"AppointmentOriginalStartTime");
            }

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

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

    static PyObject* AppointmentCalendarUpdateMeetingResponseRequest_get_Comment(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest", L"Comment");
            }

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

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

    static PyObject* AppointmentCalendarUpdateMeetingResponseRequest_get_Response(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest", L"Response");
            }

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

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

    static PyObject* AppointmentCalendarUpdateMeetingResponseRequest_get_SendUpdate(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest", L"SendUpdate");
            }

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

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

    static PyObject* AppointmentCalendarUpdateMeetingResponseRequest_get_Subject(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest", L"Subject");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarUpdateMeetingResponseRequest(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarUpdateMeetingResponseRequest(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarUpdateMeetingResponseRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarUpdateMeetingResponseRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(AppointmentCalendarUpdateMeetingResponseRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarUpdateMeetingResponseRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarUpdateMeetingResponseRequest), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarUpdateMeetingResponseRequest[] = {
        { "appointment_calendar_local_id", reinterpret_cast<getter>(AppointmentCalendarUpdateMeetingResponseRequest_get_AppointmentCalendarLocalId), nullptr, nullptr, nullptr },
        { "appointment_local_id", reinterpret_cast<getter>(AppointmentCalendarUpdateMeetingResponseRequest_get_AppointmentLocalId), nullptr, nullptr, nullptr },
        { "appointment_original_start_time", reinterpret_cast<getter>(AppointmentCalendarUpdateMeetingResponseRequest_get_AppointmentOriginalStartTime), nullptr, nullptr, nullptr },
        { "comment", reinterpret_cast<getter>(AppointmentCalendarUpdateMeetingResponseRequest_get_Comment), nullptr, nullptr, nullptr },
        { "response", reinterpret_cast<getter>(AppointmentCalendarUpdateMeetingResponseRequest_get_Response), nullptr, nullptr, nullptr },
        { "send_update", reinterpret_cast<getter>(AppointmentCalendarUpdateMeetingResponseRequest_get_SendUpdate), nullptr, nullptr, nullptr },
        { "subject", reinterpret_cast<getter>(AppointmentCalendarUpdateMeetingResponseRequest_get_Subject), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarUpdateMeetingResponseRequest[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarUpdateMeetingResponseRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarUpdateMeetingResponseRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarUpdateMeetingResponseRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarUpdateMeetingResponseRequest) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarUpdateMeetingResponseRequest = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarUpdateMeetingResponseRequest",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarUpdateMeetingResponseRequest};

    // ----- AppointmentCalendarUpdateMeetingResponseRequestEventArgs class --------------------

    static PyObject* _new_AppointmentCalendarUpdateMeetingResponseRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentCalendarUpdateMeetingResponseRequestEventArgs(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentCalendarUpdateMeetingResponseRequestEventArgs_GetDeferral(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs", L"GetDeferral", 0);
                }

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

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

    static PyObject* AppointmentCalendarUpdateMeetingResponseRequestEventArgs_get_Request(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequestEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs", L"Request");
            }

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

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

    static PyObject* _assign_array_AppointmentCalendarUpdateMeetingResponseRequestEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequestEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentCalendarUpdateMeetingResponseRequestEventArgs(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::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentCalendarUpdateMeetingResponseRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(AppointmentCalendarUpdateMeetingResponseRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AppointmentCalendarUpdateMeetingResponseRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentCalendarUpdateMeetingResponseRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentCalendarUpdateMeetingResponseRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(AppointmentCalendarUpdateMeetingResponseRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentCalendarUpdateMeetingResponseRequestEventArgs[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentCalendarUpdateMeetingResponseRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentCalendarUpdateMeetingResponseRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentCalendarUpdateMeetingResponseRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentCalendarUpdateMeetingResponseRequestEventArgs) },
        { }};

    static PyType_Spec type_spec_AppointmentCalendarUpdateMeetingResponseRequestEventArgs = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentCalendarUpdateMeetingResponseRequestEventArgs};

    // ----- AppointmentDataProviderConnection class --------------------

    static PyObject* _new_AppointmentDataProviderConnection(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentDataProviderConnection(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentDataProviderConnection_Start(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_GET_SIZE(args);

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

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"Start", 0);
                }

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

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

                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* AppointmentDataProviderConnection_add_CancelMeetingRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"CancelMeetingRequested");
            }

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

            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection, winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCancelMeetingRequestEventArgs>>(arg);

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

    static PyObject* AppointmentDataProviderConnection_remove_CancelMeetingRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"CancelMeetingRequested");
            }

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

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

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

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

    static PyObject* AppointmentDataProviderConnection_add_CreateOrUpdateAppointmentRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"CreateOrUpdateAppointmentRequested");
            }

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

            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection, winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs>>(arg);

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

    static PyObject* AppointmentDataProviderConnection_remove_CreateOrUpdateAppointmentRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"CreateOrUpdateAppointmentRequested");
            }

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

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

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

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

    static PyObject* AppointmentDataProviderConnection_add_ForwardMeetingRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"ForwardMeetingRequested");
            }

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

            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection, winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarForwardMeetingRequestEventArgs>>(arg);

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

    static PyObject* AppointmentDataProviderConnection_remove_ForwardMeetingRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"ForwardMeetingRequested");
            }

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

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

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

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

    static PyObject* AppointmentDataProviderConnection_add_ProposeNewTimeForMeetingRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"ProposeNewTimeForMeetingRequested");
            }

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

            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection, winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs>>(arg);

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

    static PyObject* AppointmentDataProviderConnection_remove_ProposeNewTimeForMeetingRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"ProposeNewTimeForMeetingRequested");
            }

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

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

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

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

    static PyObject* AppointmentDataProviderConnection_add_SyncRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"SyncRequested");
            }

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

            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection, winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarSyncManagerSyncRequestEventArgs>>(arg);

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

    static PyObject* AppointmentDataProviderConnection_remove_SyncRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"SyncRequested");
            }

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

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

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

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

    static PyObject* AppointmentDataProviderConnection_add_UpdateMeetingResponseRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"UpdateMeetingResponseRequested");
            }

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

            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection, winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentCalendarUpdateMeetingResponseRequestEventArgs>>(arg);

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

    static PyObject* AppointmentDataProviderConnection_remove_UpdateMeetingResponseRequested(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection* self, PyObject* arg) noexcept
    {
        try
        {
            static std::optional<bool> is_event_present{};

            if (!is_event_present.has_value())
            {
                is_event_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection", L"UpdateMeetingResponseRequested");
            }

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

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

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

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

    static PyObject* _assign_array_AppointmentDataProviderConnection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentDataProviderConnection(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::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentDataProviderConnection[] = {
        { "start", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_Start), METH_VARARGS, nullptr },
        { "add_cancel_meeting_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_add_CancelMeetingRequested), METH_O, nullptr },
        { "remove_cancel_meeting_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_remove_CancelMeetingRequested), METH_O, nullptr },
        { "add_create_or_update_appointment_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_add_CreateOrUpdateAppointmentRequested), METH_O, nullptr },
        { "remove_create_or_update_appointment_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_remove_CreateOrUpdateAppointmentRequested), METH_O, nullptr },
        { "add_forward_meeting_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_add_ForwardMeetingRequested), METH_O, nullptr },
        { "remove_forward_meeting_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_remove_ForwardMeetingRequested), METH_O, nullptr },
        { "add_propose_new_time_for_meeting_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_add_ProposeNewTimeForMeetingRequested), METH_O, nullptr },
        { "remove_propose_new_time_for_meeting_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_remove_ProposeNewTimeForMeetingRequested), METH_O, nullptr },
        { "add_sync_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_add_SyncRequested), METH_O, nullptr },
        { "remove_sync_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_remove_SyncRequested), METH_O, nullptr },
        { "add_update_meeting_response_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_add_UpdateMeetingResponseRequested), METH_O, nullptr },
        { "remove_update_meeting_response_requested", reinterpret_cast<PyCFunction>(AppointmentDataProviderConnection_remove_UpdateMeetingResponseRequested), METH_O, nullptr },
        { "_assign_array_", _assign_array_AppointmentDataProviderConnection, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentDataProviderConnection), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentDataProviderConnection[] = {
        { }};

    static PyType_Slot _type_slots_AppointmentDataProviderConnection[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentDataProviderConnection) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentDataProviderConnection) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentDataProviderConnection) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentDataProviderConnection) },
        { }};

    static PyType_Spec type_spec_AppointmentDataProviderConnection = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentDataProviderConnection",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderConnection),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentDataProviderConnection};

    // ----- AppointmentDataProviderTriggerDetails class --------------------

    static PyObject* _new_AppointmentDataProviderTriggerDetails(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderTriggerDetails>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderTriggerDetails>::type_name);
        return nullptr;
    }

    static void _dealloc_AppointmentDataProviderTriggerDetails(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderTriggerDetails* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppointmentDataProviderTriggerDetails_get_Connection(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderTriggerDetails* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderTriggerDetails", L"Connection");
            }

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

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

    static PyObject* _assign_array_AppointmentDataProviderTriggerDetails(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderTriggerDetails>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppointmentDataProviderTriggerDetails(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::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderTriggerDetails>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppointmentDataProviderTriggerDetails[] = {
        { "_assign_array_", _assign_array_AppointmentDataProviderTriggerDetails, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppointmentDataProviderTriggerDetails), METH_O | METH_STATIC, nullptr },
        { }};

    static PyGetSetDef _getset_AppointmentDataProviderTriggerDetails[] = {
        { "connection", reinterpret_cast<getter>(AppointmentDataProviderTriggerDetails_get_Connection), nullptr, nullptr, nullptr },
        { }};

    static PyType_Slot _type_slots_AppointmentDataProviderTriggerDetails[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppointmentDataProviderTriggerDetails) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppointmentDataProviderTriggerDetails) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppointmentDataProviderTriggerDetails) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppointmentDataProviderTriggerDetails) },
        { }};

    static PyType_Spec type_spec_AppointmentDataProviderTriggerDetails = {
        "winrt._winrt_windows_applicationmodel_appointments_dataprovider.AppointmentDataProviderTriggerDetails",
        sizeof(py::wrapper::Windows::ApplicationModel::Appointments::DataProvider::AppointmentDataProviderTriggerDetails),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppointmentDataProviderTriggerDetails};

    // ----- Windows.ApplicationModel.Appointments.DataProvider Initialization --------------------

    PyDoc_STRVAR(module_doc, "Windows.ApplicationModel.Appointments.DataProvider");

    static PyModuleDef module_def = {
        PyModuleDef_HEAD_INIT,
        "_winrt_windows_applicationmodel_appointments_dataprovider",
        module_doc,
        0,
        nullptr,
        nullptr,
        nullptr,
        nullptr,
        nullptr};
} // py::cpp::Windows::ApplicationModel::Appointments::DataProvider

PyMODINIT_FUNC PyInit__winrt_windows_applicationmodel_appointments_dataprovider(void) noexcept
{
    using namespace py::cpp::Windows::ApplicationModel::Appointments::DataProvider;

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

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

    if (!module)
    {
        return nullptr;
    }

    auto inspectable_meta_type = py::get_inspectable_meta_type();
    if (!inspectable_meta_type)
    {
        return nullptr;
    }

    auto object_type = py::get_object_type();
    if (!object_type)
    {
        return nullptr;
    }

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

    if (!object_bases)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarCancelMeetingRequest_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarCancelMeetingRequest, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarCancelMeetingRequest_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarCancelMeetingRequestEventArgs_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarCancelMeetingRequestEventArgs, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarCancelMeetingRequestEventArgs_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarCreateOrUpdateAppointmentRequest_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarCreateOrUpdateAppointmentRequest, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarCreateOrUpdateAppointmentRequest_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarForwardMeetingRequest_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarForwardMeetingRequest, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarForwardMeetingRequest_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarForwardMeetingRequestEventArgs_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarForwardMeetingRequestEventArgs, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarForwardMeetingRequestEventArgs_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarProposeNewTimeForMeetingRequest_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarProposeNewTimeForMeetingRequest, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarProposeNewTimeForMeetingRequest_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarSyncManagerSyncRequest_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarSyncManagerSyncRequest, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarSyncManagerSyncRequest_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarSyncManagerSyncRequestEventArgs_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarSyncManagerSyncRequestEventArgs, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarSyncManagerSyncRequestEventArgs_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarUpdateMeetingResponseRequest_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarUpdateMeetingResponseRequest, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarUpdateMeetingResponseRequest_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentCalendarUpdateMeetingResponseRequestEventArgs_type{py::register_python_type(module.get(), &type_spec_AppointmentCalendarUpdateMeetingResponseRequestEventArgs, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentCalendarUpdateMeetingResponseRequestEventArgs_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentDataProviderConnection_type{py::register_python_type(module.get(), &type_spec_AppointmentDataProviderConnection, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentDataProviderConnection_type)
    {
        return nullptr;
    }

    py::pytype_handle AppointmentDataProviderTriggerDetails_type{py::register_python_type(module.get(), &type_spec_AppointmentDataProviderTriggerDetails, object_bases.get(), inspectable_meta_type)};
    if (!AppointmentDataProviderTriggerDetails_type)
    {
        return nullptr;
    }


    return module.detach();
}
