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

#include "py.Windows.ApplicationModel.SocialInfo.Provider.h"


namespace py::cpp::Windows::ApplicationModel::SocialInfo::Provider
{
    // ----- SocialDashboardItemUpdater class --------------------

    static PyObject* _new_SocialDashboardItemUpdater(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater>::type_name);
        return nullptr;
    }

    static void _dealloc_SocialDashboardItemUpdater(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SocialDashboardItemUpdater_CommitAsync(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialDashboardItemUpdater", L"CommitAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

    static int SocialDashboardItemUpdater_put_Timestamp(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialDashboardItemUpdater", L"Timestamp"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

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

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

    static PyObject* SocialDashboardItemUpdater_get_Thumbnail(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialDashboardItemUpdater", L"Thumbnail"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int SocialDashboardItemUpdater_put_Thumbnail(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialDashboardItemUpdater", L"Thumbnail"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

        try
        {
            auto param0 = py::convert_to<winrt::Windows::ApplicationModel::SocialInfo::SocialItemThumbnail>(arg);

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

    static PyObject* SocialDashboardItemUpdater_get_TargetUri(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialDashboardItemUpdater", L"TargetUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int SocialDashboardItemUpdater_put_TargetUri(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialDashboardItemUpdater", L"TargetUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

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

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

    static PyObject* SocialDashboardItemUpdater_get_Content(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialDashboardItemUpdater", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SocialDashboardItemUpdater_get_OwnerRemoteId(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialDashboardItemUpdater", L"OwnerRemoteId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _from_SocialDashboardItemUpdater(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::SocialInfo::Provider::SocialDashboardItemUpdater>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SocialDashboardItemUpdater[] = {
        { "commit_async", reinterpret_cast<PyCFunction>(SocialDashboardItemUpdater_CommitAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_SocialDashboardItemUpdater, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SocialDashboardItemUpdater), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SocialDashboardItemUpdater[] = {
        { "timestamp", reinterpret_cast<getter>(SocialDashboardItemUpdater_get_Timestamp), reinterpret_cast<setter>(SocialDashboardItemUpdater_put_Timestamp), nullptr, nullptr },
        { "thumbnail", reinterpret_cast<getter>(SocialDashboardItemUpdater_get_Thumbnail), reinterpret_cast<setter>(SocialDashboardItemUpdater_put_Thumbnail), nullptr, nullptr },
        { "target_uri", reinterpret_cast<getter>(SocialDashboardItemUpdater_get_TargetUri), reinterpret_cast<setter>(SocialDashboardItemUpdater_put_TargetUri), nullptr, nullptr },
        { "content", reinterpret_cast<getter>(SocialDashboardItemUpdater_get_Content), nullptr, nullptr, nullptr },
        { "owner_remote_id", reinterpret_cast<getter>(SocialDashboardItemUpdater_get_OwnerRemoteId), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SocialDashboardItemUpdater[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SocialDashboardItemUpdater) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SocialDashboardItemUpdater) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SocialDashboardItemUpdater) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SocialDashboardItemUpdater) },
        { },
    };

    static PyType_Spec type_spec_SocialDashboardItemUpdater =
    {
        "winrt._winrt_windows_applicationmodel_socialinfo_provider.SocialDashboardItemUpdater",
        sizeof(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialDashboardItemUpdater),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SocialDashboardItemUpdater
    };

    // ----- SocialFeedUpdater class --------------------

    static PyObject* _new_SocialFeedUpdater(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialFeedUpdater>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialFeedUpdater>::type_name);
        return nullptr;
    }

    static void _dealloc_SocialFeedUpdater(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialFeedUpdater* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SocialFeedUpdater_CommitAsync(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialFeedUpdater* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialFeedUpdater", L"CommitAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* SocialFeedUpdater_get_Items(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialFeedUpdater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialFeedUpdater", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

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

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

    static PyObject* SocialFeedUpdater_get_OwnerRemoteId(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialFeedUpdater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialFeedUpdater", L"OwnerRemoteId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _from_SocialFeedUpdater(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::SocialInfo::Provider::SocialFeedUpdater>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SocialFeedUpdater[] = {
        { "commit_async", reinterpret_cast<PyCFunction>(SocialFeedUpdater_CommitAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_SocialFeedUpdater, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SocialFeedUpdater), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SocialFeedUpdater[] = {
        { "items", reinterpret_cast<getter>(SocialFeedUpdater_get_Items), nullptr, nullptr, nullptr },
        { "kind", reinterpret_cast<getter>(SocialFeedUpdater_get_Kind), nullptr, nullptr, nullptr },
        { "owner_remote_id", reinterpret_cast<getter>(SocialFeedUpdater_get_OwnerRemoteId), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SocialFeedUpdater[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SocialFeedUpdater) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SocialFeedUpdater) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SocialFeedUpdater) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SocialFeedUpdater) },
        { },
    };

    static PyType_Spec type_spec_SocialFeedUpdater =
    {
        "winrt._winrt_windows_applicationmodel_socialinfo_provider.SocialFeedUpdater",
        sizeof(py::wrapper::Windows::ApplicationModel::SocialInfo::Provider::SocialFeedUpdater),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SocialFeedUpdater
    };

    // ----- SocialInfoProviderManager class --------------------

    static PyObject* _new_SocialInfoProviderManager(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialInfoProviderManager>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialInfoProviderManager>::type_name);
        return nullptr;
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialInfoProviderManager", L"CreateDashboardItemUpdaterAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialInfoProviderManager::CreateDashboardItemUpdaterAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialInfoProviderManager", L"CreateSocialFeedUpdaterAsync", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::ApplicationModel::SocialInfo::SocialFeedKind>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::ApplicationModel::SocialInfo::SocialFeedUpdateMode>(args, 1);
                auto param2 = py::convert_to<winrt::hstring>(args, 2);

                return py::convert(winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialInfoProviderManager::CreateSocialFeedUpdaterAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialInfoProviderManager", L"DeprovisionAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialInfoProviderManager::DeprovisionAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialInfoProviderManager", L"ProvisionAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialInfoProviderManager::ProvisionAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialInfoProviderManager", L"ReportNewContentAvailable", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

                winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialInfoProviderManager::ReportNewContentAvailable(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.SocialInfo.Provider.SocialInfoProviderManager", L"UpdateBadgeCountValue", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

                winrt::Windows::ApplicationModel::SocialInfo::Provider::SocialInfoProviderManager::UpdateBadgeCountValue(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyMethodDef _methods_SocialInfoProviderManager[] = {
        { }
    };

    static PyGetSetDef _getset_SocialInfoProviderManager[] = {
        { }
    };

    static PyType_Slot _type_slots_SocialInfoProviderManager[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SocialInfoProviderManager) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SocialInfoProviderManager) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SocialInfoProviderManager) },
        { },
    };

    static PyType_Spec type_spec_SocialInfoProviderManager =
    {
        "winrt._winrt_windows_applicationmodel_socialinfo_provider.SocialInfoProviderManager",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SocialInfoProviderManager
    };

    static PyGetSetDef getset_SocialInfoProviderManager_Static[] = {
        { }
    };

    static PyMethodDef methods_SocialInfoProviderManager_Static[] = {
        { "create_dashboard_item_updater_async", reinterpret_cast<PyCFunction>(SocialInfoProviderManager_CreateDashboardItemUpdaterAsync), METH_VARARGS, nullptr },
        { "create_social_feed_updater_async", reinterpret_cast<PyCFunction>(SocialInfoProviderManager_CreateSocialFeedUpdaterAsync), METH_VARARGS, nullptr },
        { "deprovision_async", reinterpret_cast<PyCFunction>(SocialInfoProviderManager_DeprovisionAsync), METH_VARARGS, nullptr },
        { "provision_async", reinterpret_cast<PyCFunction>(SocialInfoProviderManager_ProvisionAsync), METH_VARARGS, nullptr },
        { "report_new_content_available", reinterpret_cast<PyCFunction>(SocialInfoProviderManager_ReportNewContentAvailable), METH_VARARGS, nullptr },
        { "update_badge_count_value", reinterpret_cast<PyCFunction>(SocialInfoProviderManager_UpdateBadgeCountValue), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_SocialInfoProviderManager_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SocialInfoProviderManager_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SocialInfoProviderManager_Static) },
        { }
    };

    static PyType_Spec type_spec_SocialInfoProviderManager_Static =
    {
        "winrt._winrt_windows_applicationmodel_socialinfo_provider.SocialInfoProviderManager_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SocialInfoProviderManager_Static
    };

    // ----- Windows.ApplicationModel.SocialInfo.Provider Initialization --------------------
    PyDoc_STRVAR(module_doc, "Windows::ApplicationModel::SocialInfo::Provider");


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

} // py::cpp::Windows::ApplicationModel::SocialInfo::Provider

PyMODINIT_FUNC PyInit__winrt_windows_applicationmodel_socialinfo_provider(void) noexcept
{
    using namespace py::cpp::Windows::ApplicationModel::SocialInfo::Provider;

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

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

    if (!module)
    {
        return nullptr;
    }

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

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

    if (!object_bases)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SocialDashboardItemUpdater, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SocialFeedUpdater, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SocialInfoProviderManager_Static{PyType_FromSpec(&type_spec_SocialInfoProviderManager_Static)};
    if (!type_SocialInfoProviderManager_Static)
    {
        return nullptr;
    }

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


    return module.detach();
}
