/// @cond EO_CXX_EO_IMPL

inline ::efl::eina::crange_list< ::evas::object > elm::widget_item::access_order_get() const
{
   const Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_access_order_get());
   return ::efl::eolian::to_cxx<::efl::eina::crange_list< ::evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
}

inline void elm::widget_item::access_order_set(::efl::eina::list< ::evas::object > objs_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_access_order_set(::efl::eolian::to_native<Eina_List *>(objs_)));
}

inline ::evas::object elm::widget_item::widget_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_widget_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::del() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_del());
}

#ifdef WIDGET_ITEM_PROTECTED
inline void elm::widget_item::pre_notify_del() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_pre_notify_del());
}
#endif

inline void elm::widget_item::tooltip_text_set(::efl::eina::string_view text_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_tooltip_text_set(::efl::eolian::to_c(text_)));
}

#ifdef WIDGET_ITEM_PROTECTED
inline void elm::widget_item::tooltip_translatable_text_set(::efl::eina::string_view text_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_tooltip_translatable_text_set(::efl::eolian::to_c(text_)));
}
#endif

inline void elm::widget_item::tooltip_unset() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_tooltip_unset());
}

inline void elm::widget_item::cursor_unset() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_cursor_unset());
}

inline ::evas::object elm::widget_item::part_content_unset(::efl::eina::string_view part_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_part_content_unset(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

#ifdef WIDGET_ITEM_PROTECTED
inline void elm::widget_item::part_text_custom_update() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_part_text_custom_update());
}
#endif

inline void elm::widget_item::signal_callback_add(::efl::eina::string_view emission_, ::efl::eina::string_view source_, Elm_Object_Item_Signal_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_signal_callback_add(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), func_, data_));
}

inline void * elm::widget_item::signal_callback_del(::efl::eina::string_view emission_, ::efl::eina::string_view source_, Elm_Object_Item_Signal_Cb func_) const
{
   void * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_signal_callback_del(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), func_));
   return _tmp_ret;
}

inline void elm::widget_item::signal_emit(::efl::eina::string_view emission_, ::efl::eina::string_view source_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_signal_emit(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_)));
}

inline void elm::widget_item::access_info_set(::efl::eina::string_view txt_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_access_info_set(::efl::eolian::to_c(txt_)));
}

inline ::evas::object elm::widget_item::access_object_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_access_object_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::domain_translatable_part_text_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, ::efl::eina::string_view label_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_domain_translatable_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(label_)));
}

inline ::efl::eina::string_view elm::widget_item::translatable_part_text_get(::efl::eina::string_view part_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_translatable_part_text_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

#ifdef WIDGET_ITEM_PROTECTED
inline void elm::widget_item::translate() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_translate());
}
#endif

inline void elm::widget_item::domain_part_text_translatable_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, bool translatable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_domain_part_text_translatable_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(translatable_)));
}

inline ::evas::object elm::widget_item::track() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_track());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::untrack() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_untrack());
}

inline int elm::widget_item::track_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_track_get());
   return _tmp_ret;
}

#ifdef WIDGET_ITEM_PROTECTED
inline void elm::widget_item::track_cancel() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_track_cancel());
}
#endif

inline void elm::widget_item::del_cb_set(Evas_Smart_Cb del_cb_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_del_cb_set(del_cb_));
}

inline void elm::widget_item::tooltip_content_cb_set(Elm_Tooltip_Item_Content_Cb func_, const void * data_, Evas_Smart_Cb del_cb_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_tooltip_content_cb_set(func_, data_, del_cb_));
}

inline ::evas::object elm::widget_item::access_register() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_access_register());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::access_unregister() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_access_unregister());
}

inline void elm::widget_item::access_order_unset() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_access_order_unset());
}

#ifdef WIDGET_ITEM_PROTECTED
inline void elm::widget_item::disable() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_disable());
}
#endif

#ifdef WIDGET_ITEM_PROTECTED
inline bool elm::widget_item::del_pre() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_del_pre());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

inline ::evas::object elm::widget_item::focus_next_object_get(Elm_Focus_Direction dir_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_focus_next_object_get(dir_));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::focus_next_object_set(::evas::object next_, Elm_Focus_Direction dir_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_focus_next_object_set(::efl::eolian::to_c(next_), dir_));
}

inline Elm_Object_Item * elm::widget_item::focus_next_item_get(Elm_Focus_Direction dir_) const
{
   Elm_Object_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_focus_next_item_get(dir_));
   return _tmp_ret;
}

inline void elm::widget_item::focus_next_item_set(Elm_Object_Item * next_item_, Elm_Focus_Direction dir_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_focus_next_item_set(next_item_, dir_));
}

inline bool elm::widget_item::tooltip_window_mode_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_tooltip_window_mode_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::widget_item::tooltip_window_mode_set(bool disable_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_tooltip_window_mode_set(::efl::eolian::to_c(disable_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::efl::eina::string_view elm::widget_item::tooltip_style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_tooltip_style_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::tooltip_style_set(::efl::eina::string_view style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_tooltip_style_set(::efl::eolian::to_c(style_)));
}

inline ::efl::eina::string_view elm::widget_item::cursor_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_cursor_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::cursor_set(::efl::eina::string_view cursor_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_cursor_set(::efl::eolian::to_c(cursor_)));
}

inline ::efl::eina::string_view elm::widget_item::cursor_style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_cursor_style_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::cursor_style_set(::efl::eina::string_view style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_cursor_style_set(::efl::eolian::to_c(style_)));
}

inline bool elm::widget_item::cursor_engine_only_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_cursor_engine_only_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::cursor_engine_only_set(bool engine_only_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_cursor_engine_only_set(::efl::eolian::to_c(engine_only_)));
}

inline ::evas::object elm::widget_item::part_content_get(::efl::eina::optional< ::efl::eina::string_view > part_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_part_content_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::part_content_set(::efl::eina::optional< ::efl::eina::string_view > part_, ::evas::object content_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_part_content_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(content_)));
}

inline ::efl::eina::string_view elm::widget_item::part_text_get(::efl::eina::optional< ::efl::eina::string_view > part_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_part_text_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::part_text_set(::efl::eina::optional< ::efl::eina::string_view > part_, ::efl::eina::string_view label_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(label_)));
}

#ifdef WIDGET_ITEM_PROTECTED
inline ::efl::eina::string_view elm::widget_item::part_text_custom_get(::efl::eina::string_view part_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_part_text_custom_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef WIDGET_ITEM_PROTECTED
inline void elm::widget_item::part_text_custom_set(::efl::eina::string_view part_, ::efl::eina::string_view label_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_part_text_custom_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(label_)));
}
#endif

inline bool elm::widget_item::focus_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_focus_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::focus_set(bool focused_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_focus_set(::efl::eolian::to_c(focused_)));
}

inline ::efl::eina::string_view elm::widget_item::style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_style_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::style_set(::efl::eina::string_view style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_style_set(::efl::eolian::to_c(style_)));
}

inline bool elm::widget_item::disabled_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_disabled_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::widget_item::disabled_set(bool disable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_disabled_set(::efl::eolian::to_c(disable_)));
}

inline ::efl::eina::crange_list< ::evas::object > eo_cxx::elm::widget_item::access_order_get() const
{
   const Eina_List * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_access_order_get());
   return ::efl::eolian::to_cxx<::efl::eina::crange_list< ::evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
}

inline void eo_cxx::elm::widget_item::access_order_set(::efl::eina::list< ::evas::object > objs_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_access_order_set(::efl::eolian::to_native<Eina_List *>(objs_)));
}

inline ::evas::object eo_cxx::elm::widget_item::widget_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_widget_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::del() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_del());
}

#ifdef WIDGET_ITEM_PROTECTED
inline void eo_cxx::elm::widget_item::pre_notify_del() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_pre_notify_del());
}
#endif

inline void eo_cxx::elm::widget_item::tooltip_text_set(::efl::eina::string_view text_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_tooltip_text_set(::efl::eolian::to_c(text_)));
}

#ifdef WIDGET_ITEM_PROTECTED
inline void eo_cxx::elm::widget_item::tooltip_translatable_text_set(::efl::eina::string_view text_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_tooltip_translatable_text_set(::efl::eolian::to_c(text_)));
}
#endif

inline void eo_cxx::elm::widget_item::tooltip_unset() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_tooltip_unset());
}

inline void eo_cxx::elm::widget_item::cursor_unset() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_cursor_unset());
}

inline ::evas::object eo_cxx::elm::widget_item::part_content_unset(::efl::eina::string_view part_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_part_content_unset(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

#ifdef WIDGET_ITEM_PROTECTED
inline void eo_cxx::elm::widget_item::part_text_custom_update() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_part_text_custom_update());
}
#endif

inline void eo_cxx::elm::widget_item::signal_callback_add(::efl::eina::string_view emission_, ::efl::eina::string_view source_, Elm_Object_Item_Signal_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_signal_callback_add(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), func_, data_));
}

inline void * eo_cxx::elm::widget_item::signal_callback_del(::efl::eina::string_view emission_, ::efl::eina::string_view source_, Elm_Object_Item_Signal_Cb func_) const
{
   void * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_signal_callback_del(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), func_));
   return _tmp_ret;
}

inline void eo_cxx::elm::widget_item::signal_emit(::efl::eina::string_view emission_, ::efl::eina::string_view source_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_signal_emit(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_)));
}

inline void eo_cxx::elm::widget_item::access_info_set(::efl::eina::string_view txt_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_access_info_set(::efl::eolian::to_c(txt_)));
}

inline ::evas::object eo_cxx::elm::widget_item::access_object_get() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_access_object_get());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::domain_translatable_part_text_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, ::efl::eina::string_view label_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_domain_translatable_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(label_)));
}

inline ::efl::eina::string_view eo_cxx::elm::widget_item::translatable_part_text_get(::efl::eina::string_view part_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_translatable_part_text_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

#ifdef WIDGET_ITEM_PROTECTED
inline void eo_cxx::elm::widget_item::translate() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_translate());
}
#endif

inline void eo_cxx::elm::widget_item::domain_part_text_translatable_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, bool translatable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_domain_part_text_translatable_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(translatable_)));
}

inline ::evas::object eo_cxx::elm::widget_item::track() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_track());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::untrack() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_untrack());
}

inline int eo_cxx::elm::widget_item::track_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_track_get());
   return _tmp_ret;
}

#ifdef WIDGET_ITEM_PROTECTED
inline void eo_cxx::elm::widget_item::track_cancel() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_track_cancel());
}
#endif

inline void eo_cxx::elm::widget_item::del_cb_set(Evas_Smart_Cb del_cb_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_del_cb_set(del_cb_));
}

inline void eo_cxx::elm::widget_item::tooltip_content_cb_set(Elm_Tooltip_Item_Content_Cb func_, const void * data_, Evas_Smart_Cb del_cb_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_tooltip_content_cb_set(func_, data_, del_cb_));
}

inline ::evas::object eo_cxx::elm::widget_item::access_register() const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_access_register());
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::access_unregister() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_access_unregister());
}

inline void eo_cxx::elm::widget_item::access_order_unset() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_access_order_unset());
}

#ifdef WIDGET_ITEM_PROTECTED
inline void eo_cxx::elm::widget_item::disable() const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_disable());
}
#endif

#ifdef WIDGET_ITEM_PROTECTED
inline bool eo_cxx::elm::widget_item::del_pre() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_del_pre());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

inline ::evas::object eo_cxx::elm::widget_item::focus_next_object_get(Elm_Focus_Direction dir_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_focus_next_object_get(dir_));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::focus_next_object_set(::evas::object next_, Elm_Focus_Direction dir_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_focus_next_object_set(::efl::eolian::to_c(next_), dir_));
}

inline Elm_Object_Item * eo_cxx::elm::widget_item::focus_next_item_get(Elm_Focus_Direction dir_) const
{
   Elm_Object_Item * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_focus_next_item_get(dir_));
   return _tmp_ret;
}

inline void eo_cxx::elm::widget_item::focus_next_item_set(Elm_Object_Item * next_item_, Elm_Focus_Direction dir_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_focus_next_item_set(next_item_, dir_));
}

inline bool eo_cxx::elm::widget_item::tooltip_window_mode_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_tooltip_window_mode_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::widget_item::tooltip_window_mode_set(bool disable_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_tooltip_window_mode_set(::efl::eolian::to_c(disable_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline ::efl::eina::string_view eo_cxx::elm::widget_item::tooltip_style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_tooltip_style_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::tooltip_style_set(::efl::eina::string_view style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_tooltip_style_set(::efl::eolian::to_c(style_)));
}

inline ::efl::eina::string_view eo_cxx::elm::widget_item::cursor_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_cursor_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::cursor_set(::efl::eina::string_view cursor_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_cursor_set(::efl::eolian::to_c(cursor_)));
}

inline ::efl::eina::string_view eo_cxx::elm::widget_item::cursor_style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_cursor_style_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::cursor_style_set(::efl::eina::string_view style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_cursor_style_set(::efl::eolian::to_c(style_)));
}

inline bool eo_cxx::elm::widget_item::cursor_engine_only_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_cursor_engine_only_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::cursor_engine_only_set(bool engine_only_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_cursor_engine_only_set(::efl::eolian::to_c(engine_only_)));
}

inline ::evas::object eo_cxx::elm::widget_item::part_content_get(::efl::eina::optional< ::efl::eina::string_view > part_) const
{
   Evas_Object * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_part_content_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::part_content_set(::efl::eina::optional< ::efl::eina::string_view > part_, ::evas::object content_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_part_content_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(content_)));
}

inline ::efl::eina::string_view eo_cxx::elm::widget_item::part_text_get(::efl::eina::optional< ::efl::eina::string_view > part_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_part_text_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::part_text_set(::efl::eina::optional< ::efl::eina::string_view > part_, ::efl::eina::string_view label_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(label_)));
}

#ifdef WIDGET_ITEM_PROTECTED
inline ::efl::eina::string_view eo_cxx::elm::widget_item::part_text_custom_get(::efl::eina::string_view part_) const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_part_text_custom_get(::efl::eolian::to_c(part_)));
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}
#endif

#ifdef WIDGET_ITEM_PROTECTED
inline void eo_cxx::elm::widget_item::part_text_custom_set(::efl::eina::string_view part_, ::efl::eina::string_view label_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_part_text_custom_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(label_)));
}
#endif

inline bool eo_cxx::elm::widget_item::focus_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_focus_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::focus_set(bool focused_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_focus_set(::efl::eolian::to_c(focused_)));
}

inline ::efl::eina::string_view eo_cxx::elm::widget_item::style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_style_get());
   return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::style_set(::efl::eina::string_view style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_style_set(::efl::eolian::to_c(style_)));
}

inline bool eo_cxx::elm::widget_item::disabled_get() const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_wdg_item_disabled_get());
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void eo_cxx::elm::widget_item::disabled_set(bool disable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_wdg_item_disabled_set(::efl::eolian::to_c(disable_)));
}

inline ::eo_cxx::elm::widget_item::operator ::elm::widget_item() const
{
   return *static_cast<::elm::widget_item const*>(static_cast<void const*>(this));
}

inline ::eo_cxx::elm::widget_item::operator ::elm::widget_item&()
{
   return *static_cast<::elm::widget_item*>(static_cast<void*>(this));
}

inline ::eo_cxx::elm::widget_item::operator ::elm::widget_item const&() const
{
   return *static_cast<::elm::widget_item const*>(static_cast<void const*>(this));
}

template <typename T>
::efl::eina::crange_list< ::evas::object > elm_widget_item_access_order_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->access_order_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const Eina_List * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::crange_list< ::evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }
}

template <typename T>
void elm_widget_item_access_order_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_List * objs_)
{
   try
      {
         static_cast<T*>(self->this_)->access_order_set(::efl::eolian::to_cxx<::efl::eina::list< ::evas::object >>(objs_, std::tuple<std::true_type, std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::evas::object elm_widget_item_widget_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->widget_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_del_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->del();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

#ifdef WIDGET_ITEM_PROTECTED
template <typename T>
void elm_widget_item_pre_notify_del_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->pre_notify_del();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}
#endif

template <typename T>
void elm_widget_item_tooltip_text_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * text_)
{
   try
      {
         static_cast<T*>(self->this_)->tooltip_text_set(::efl::eolian::to_cxx<::efl::eina::string_view>(text_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

#ifdef WIDGET_ITEM_PROTECTED
template <typename T>
void elm_widget_item_tooltip_translatable_text_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * text_)
{
   try
      {
         static_cast<T*>(self->this_)->tooltip_translatable_text_set(::efl::eolian::to_cxx<::efl::eina::string_view>(text_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}
#endif

template <typename T>
void elm_widget_item_tooltip_unset_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->tooltip_unset();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_widget_item_cursor_unset_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->cursor_unset();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::evas::object elm_widget_item_part_content_unset_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_)
{
   try
      {
         return static_cast<T*>(self->this_)->part_content_unset(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

#ifdef WIDGET_ITEM_PROTECTED
template <typename T>
void elm_widget_item_part_text_custom_update_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->part_text_custom_update();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}
#endif

template <typename T>
void elm_widget_item_signal_callback_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * emission_, const char * source_, Elm_Object_Item_Signal_Cb func_, void * data_)
{
   try
      {
         static_cast<T*>(self->this_)->signal_callback_add(::efl::eolian::to_cxx<::efl::eina::string_view>(emission_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(source_, std::tuple<std::false_type>()), func_, data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void * elm_widget_item_signal_callback_del_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * emission_, const char * source_, Elm_Object_Item_Signal_Cb func_)
{
   try
      {
         return static_cast<T*>(self->this_)->signal_callback_del(::efl::eolian::to_cxx<::efl::eina::string_view>(emission_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(source_, std::tuple<std::false_type>()), func_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         void * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_widget_item_signal_emit_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * emission_, const char * source_)
{
   try
      {
         static_cast<T*>(self->this_)->signal_emit(::efl::eolian::to_cxx<::efl::eina::string_view>(emission_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(source_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_widget_item_access_info_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * txt_)
{
   try
      {
         static_cast<T*>(self->this_)->access_info_set(::efl::eolian::to_cxx<::efl::eina::string_view>(txt_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::evas::object elm_widget_item_access_object_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->access_object_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_domain_translatable_part_text_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char * domain_, const char * label_)
{
   try
      {
         static_cast<T*>(self->this_)->domain_translatable_part_text_set(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(domain_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(label_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::string_view elm_widget_item_translatable_part_text_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_)
{
   try
      {
         return static_cast<T*>(self->this_)->translatable_part_text_get(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

#ifdef WIDGET_ITEM_PROTECTED
template <typename T>
void elm_widget_item_translate_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->translate();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}
#endif

template <typename T>
void elm_widget_item_domain_part_text_translatable_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char * domain_, Eina_Bool translatable_)
{
   try
      {
         static_cast<T*>(self->this_)->domain_part_text_translatable_set(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(domain_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<bool>(translatable_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::evas::object elm_widget_item_track_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->track();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_untrack_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->untrack();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
int elm_widget_item_track_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->track_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         int _tmp_ret{};
         return _tmp_ret;
      }
}

#ifdef WIDGET_ITEM_PROTECTED
template <typename T>
void elm_widget_item_track_cancel_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->track_cancel();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}
#endif

template <typename T>
void elm_widget_item_del_cb_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Smart_Cb del_cb_)
{
   try
      {
         static_cast<T*>(self->this_)->del_cb_set(del_cb_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_widget_item_tooltip_content_cb_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Tooltip_Item_Content_Cb func_, const void * data_, Evas_Smart_Cb del_cb_)
{
   try
      {
         static_cast<T*>(self->this_)->tooltip_content_cb_set(func_, data_, del_cb_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::evas::object elm_widget_item_access_register_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->access_register();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_access_unregister_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->access_unregister();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_widget_item_access_order_unset_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->access_order_unset();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

#ifdef WIDGET_ITEM_PROTECTED
template <typename T>
void elm_widget_item_disable_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->disable();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}
#endif

#ifdef WIDGET_ITEM_PROTECTED
template <typename T>
bool elm_widget_item_del_pre_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->del_pre();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}
#endif

template <typename T>
::evas::object elm_widget_item_focus_next_object_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Focus_Direction dir_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_next_object_get(dir_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_focus_next_object_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * next_, Elm_Focus_Direction dir_)
{
   try
      {
         static_cast<T*>(self->this_)->focus_next_object_set(::efl::eolian::to_cxx<::evas::object>(next_, std::tuple<std::false_type>()), dir_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
Elm_Object_Item * elm_widget_item_focus_next_item_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Focus_Direction dir_)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_next_item_get(dir_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Elm_Object_Item * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
void elm_widget_item_focus_next_item_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Object_Item * next_item_, Elm_Focus_Direction dir_)
{
   try
      {
         static_cast<T*>(self->this_)->focus_next_item_set(next_item_, dir_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_item_tooltip_window_mode_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->tooltip_window_mode_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
bool elm_widget_item_tooltip_window_mode_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool disable_)
{
   try
      {
         return static_cast<T*>(self->this_)->tooltip_window_mode_set(::efl::eolian::to_cxx<bool>(disable_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
::efl::eina::string_view elm_widget_item_tooltip_style_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->tooltip_style_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_tooltip_style_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * style_)
{
   try
      {
         static_cast<T*>(self->this_)->tooltip_style_set(::efl::eolian::to_cxx<::efl::eina::string_view>(style_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::string_view elm_widget_item_cursor_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->cursor_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_cursor_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * cursor_)
{
   try
      {
         static_cast<T*>(self->this_)->cursor_set(::efl::eolian::to_cxx<::efl::eina::string_view>(cursor_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::string_view elm_widget_item_cursor_style_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->cursor_style_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_cursor_style_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * style_)
{
   try
      {
         static_cast<T*>(self->this_)->cursor_style_set(::efl::eolian::to_cxx<::efl::eina::string_view>(style_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_item_cursor_engine_only_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->cursor_engine_only_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_cursor_engine_only_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool engine_only_)
{
   try
      {
         static_cast<T*>(self->this_)->cursor_engine_only_set(::efl::eolian::to_cxx<bool>(engine_only_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::evas::object elm_widget_item_part_content_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_)
{
   try
      {
         return static_cast<T*>(self->this_)->part_content_get(::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(part_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Evas_Object * _tmp_ret{};
         return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_part_content_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_, Evas_Object * content_)
{
   try
      {
         static_cast<T*>(self->this_)->part_content_set(::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(part_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::evas::object>(content_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::string_view elm_widget_item_part_text_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_)
{
   try
      {
         return static_cast<T*>(self->this_)->part_text_get(::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(part_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_part_text_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char * label_)
{
   try
      {
         static_cast<T*>(self->this_)->part_text_set(::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(part_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(label_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

#ifdef WIDGET_ITEM_PROTECTED
template <typename T>
::efl::eina::string_view elm_widget_item_part_text_custom_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_)
{
   try
      {
         return static_cast<T*>(self->this_)->part_text_custom_get(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}
#endif

#ifdef WIDGET_ITEM_PROTECTED
template <typename T>
void elm_widget_item_part_text_custom_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * part_, const char * label_)
{
   try
      {
         static_cast<T*>(self->this_)->part_text_custom_set(::efl::eolian::to_cxx<::efl::eina::string_view>(part_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::string_view>(label_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}
#endif

template <typename T>
bool elm_widget_item_focus_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->focus_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_focus_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool focused_)
{
   try
      {
         static_cast<T*>(self->this_)->focus_set(::efl::eolian::to_cxx<bool>(focused_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::string_view elm_widget_item_style_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->style_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         const char * _tmp_ret{};
         return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_style_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * style_)
{
   try
      {
         static_cast<T*>(self->this_)->style_set(::efl::eolian::to_cxx<::efl::eina::string_view>(style_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_widget_item_disabled_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->disabled_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
void elm_widget_item_disabled_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool disable_)
{
   try
      {
         static_cast<T*>(self->this_)->disabled_set(::efl::eolian::to_cxx<bool>(disable_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::elm::widget_item >
{
   template <typename T>
   struct type
         : virtual operations< ::eo::base >::template type<T>
         , virtual operations< ::elm_interface_atspi_accessible >::template type<T>
         , virtual operations< ::elm_interface_atspi_component >::template type<T>
   {
      virtual ::efl::eina::crange_list< ::evas::object > access_order_get()
      {
         const Eina_List * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_access_order_get());
            return ::efl::eolian::to_cxx<::efl::eina::crange_list< ::evas::object >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual void access_order_set(::efl::eina::list< ::evas::object > objs_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_access_order_set(::efl::eolian::to_native<Eina_List *>(objs_)));
      }

      virtual ::evas::object widget_get()
      {
         Evas_Object * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_widget_get());
            return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void del()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_del());
      }

#ifdef WIDGET_ITEM_PROTECTED
      virtual void pre_notify_del()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_pre_notify_del());
      }
#endif

      virtual void tooltip_text_set(::efl::eina::string_view text_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_tooltip_text_set(::efl::eolian::to_c(text_)));
      }

#ifdef WIDGET_ITEM_PROTECTED
      virtual void tooltip_translatable_text_set(::efl::eina::string_view text_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_tooltip_translatable_text_set(::efl::eolian::to_c(text_)));
      }
#endif

      virtual void tooltip_unset()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_tooltip_unset());
      }

      virtual void cursor_unset()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_cursor_unset());
      }

      virtual ::evas::object part_content_unset(::efl::eina::string_view part_)
      {
         Evas_Object * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_part_content_unset(::efl::eolian::to_c(part_)));
            return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

#ifdef WIDGET_ITEM_PROTECTED
      virtual void part_text_custom_update()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_part_text_custom_update());
      }
#endif

      virtual void signal_callback_add(::efl::eina::string_view emission_, ::efl::eina::string_view source_, Elm_Object_Item_Signal_Cb func_, void * data_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_signal_callback_add(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), func_, data_));
      }

      virtual void * signal_callback_del(::efl::eina::string_view emission_, ::efl::eina::string_view source_, Elm_Object_Item_Signal_Cb func_)
      {
         void * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_signal_callback_del(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_), func_));
            return _tmp_ret;
      }

      virtual void signal_emit(::efl::eina::string_view emission_, ::efl::eina::string_view source_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_signal_emit(::efl::eolian::to_c(emission_), ::efl::eolian::to_c(source_)));
      }

      virtual void access_info_set(::efl::eina::string_view txt_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_access_info_set(::efl::eolian::to_c(txt_)));
      }

      virtual ::evas::object access_object_get()
      {
         Evas_Object * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_access_object_get());
            return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void domain_translatable_part_text_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, ::efl::eina::string_view label_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_domain_translatable_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(label_)));
      }

      virtual ::efl::eina::string_view translatable_part_text_get(::efl::eina::string_view part_)
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_translatable_part_text_get(::efl::eolian::to_c(part_)));
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }

#ifdef WIDGET_ITEM_PROTECTED
      virtual void translate()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_translate());
      }
#endif

      virtual void domain_part_text_translatable_set(::efl::eina::string_view part_, ::efl::eina::string_view domain_, bool translatable_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_domain_part_text_translatable_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(domain_), ::efl::eolian::to_c(translatable_)));
      }

      virtual ::evas::object track()
      {
         Evas_Object * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_track());
            return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void untrack()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_untrack());
      }

      virtual int track_get()
      {
         int _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_track_get());
            return _tmp_ret;
      }

#ifdef WIDGET_ITEM_PROTECTED
      virtual void track_cancel()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_track_cancel());
      }
#endif

      virtual void del_cb_set(Evas_Smart_Cb del_cb_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_del_cb_set(del_cb_));
      }

      virtual void tooltip_content_cb_set(Elm_Tooltip_Item_Content_Cb func_, const void * data_, Evas_Smart_Cb del_cb_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_tooltip_content_cb_set(func_, data_, del_cb_));
      }

      virtual ::evas::object access_register()
      {
         Evas_Object * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_access_register());
            return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void access_unregister()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_access_unregister());
      }

      virtual void access_order_unset()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_access_order_unset());
      }

#ifdef WIDGET_ITEM_PROTECTED
      virtual void disable()
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_disable());
      }
#endif

#ifdef WIDGET_ITEM_PROTECTED
      virtual bool del_pre()
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_del_pre());
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
#endif

      virtual ::evas::object focus_next_object_get(Elm_Focus_Direction dir_)
      {
         Evas_Object * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_focus_next_object_get(dir_));
            return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void focus_next_object_set(::evas::object next_, Elm_Focus_Direction dir_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_focus_next_object_set(::efl::eolian::to_c(next_), dir_));
      }

      virtual Elm_Object_Item * focus_next_item_get(Elm_Focus_Direction dir_)
      {
         Elm_Object_Item * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_focus_next_item_get(dir_));
            return _tmp_ret;
      }

      virtual void focus_next_item_set(Elm_Object_Item * next_item_, Elm_Focus_Direction dir_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_focus_next_item_set(next_item_, dir_));
      }

      virtual bool tooltip_window_mode_get()
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_tooltip_window_mode_get());
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual bool tooltip_window_mode_set(bool disable_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_tooltip_window_mode_set(::efl::eolian::to_c(disable_)));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual ::efl::eina::string_view tooltip_style_get()
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_tooltip_style_get());
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void tooltip_style_set(::efl::eina::string_view style_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_tooltip_style_set(::efl::eolian::to_c(style_)));
      }

      virtual ::efl::eina::string_view cursor_get()
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_cursor_get());
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void cursor_set(::efl::eina::string_view cursor_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_cursor_set(::efl::eolian::to_c(cursor_)));
      }

      virtual ::efl::eina::string_view cursor_style_get()
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_cursor_style_get());
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void cursor_style_set(::efl::eina::string_view style_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_cursor_style_set(::efl::eolian::to_c(style_)));
      }

      virtual bool cursor_engine_only_get()
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_cursor_engine_only_get());
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void cursor_engine_only_set(bool engine_only_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_cursor_engine_only_set(::efl::eolian::to_c(engine_only_)));
      }

      virtual ::evas::object part_content_get(::efl::eina::optional< ::efl::eina::string_view > part_)
      {
         Evas_Object * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_part_content_get(::efl::eolian::to_c(part_)));
            return ::efl::eolian::to_cxx<::evas::object>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void part_content_set(::efl::eina::optional< ::efl::eina::string_view > part_, ::evas::object content_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_part_content_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(content_)));
      }

      virtual ::efl::eina::string_view part_text_get(::efl::eina::optional< ::efl::eina::string_view > part_)
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_part_text_get(::efl::eolian::to_c(part_)));
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void part_text_set(::efl::eina::optional< ::efl::eina::string_view > part_, ::efl::eina::string_view label_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_part_text_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(label_)));
      }

#ifdef WIDGET_ITEM_PROTECTED
      virtual ::efl::eina::string_view part_text_custom_get(::efl::eina::string_view part_)
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_part_text_custom_get(::efl::eolian::to_c(part_)));
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }
#endif

#ifdef WIDGET_ITEM_PROTECTED
      virtual void part_text_custom_set(::efl::eina::string_view part_, ::efl::eina::string_view label_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_part_text_custom_set(::efl::eolian::to_c(part_), ::efl::eolian::to_c(label_)));
      }
#endif

      virtual bool focus_get()
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_focus_get());
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void focus_set(bool focused_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_focus_set(::efl::eolian::to_c(focused_)));
      }

      virtual ::efl::eina::string_view style_get()
      {
         const char * _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_style_get());
            return ::efl::eolian::to_cxx<::efl::eina::string_view>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void style_set(::efl::eina::string_view style_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_style_set(::efl::eolian::to_c(style_)));
      }

      virtual bool disabled_get()
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_wdg_item_disabled_get());
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void disabled_set(bool disable_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_wdg_item_disabled_set(::efl::eolian::to_c(disable_)));
      }

   };
};


template<>
struct operation_description_class_size< ::elm::widget_item >
{
   static constexpr int value = 
#if defined(WIDGET_ITEM_PROTECTED) && defined(WIDGET_ITEM_BETA)
      57
#elif defined(WIDGET_ITEM_PROTECTED)
      57
#elif defined(WIDGET_ITEM_BETA)
      48
#else
      48
#endif
      + operation_description_class_size<::eo::base >::value      + operation_description_class_size<::elm_interface_atspi_accessible >::value      + operation_description_class_size<::elm_interface_atspi_component >::value;
};

template <typename T>
int initialize_operation_description(::efl::eo::detail::tag<::elm::widget_item>
                                 , Eo_Op_Description* ops)
{
   int i = 0;
   (void)i;
   (void)ops;
   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_access_order_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_access_order_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_access_order_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_access_order_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_widget_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_widget_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_del_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_del);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

#ifdef WIDGET_ITEM_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_pre_notify_del_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_pre_notify_del);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_tooltip_text_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_tooltip_text_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

#ifdef WIDGET_ITEM_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_tooltip_translatable_text_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_tooltip_translatable_text_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_tooltip_unset_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_tooltip_unset);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_cursor_unset_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_cursor_unset);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_part_content_unset_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_part_content_unset);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

#ifdef WIDGET_ITEM_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_part_text_custom_update_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_part_text_custom_update);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_signal_callback_add_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_signal_callback_add);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_signal_callback_del_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_signal_callback_del);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_signal_emit_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_signal_emit);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_access_info_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_access_info_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_access_object_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_access_object_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_domain_translatable_part_text_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_domain_translatable_part_text_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_translatable_part_text_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_translatable_part_text_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

#ifdef WIDGET_ITEM_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_translate_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_translate);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_domain_part_text_translatable_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_domain_part_text_translatable_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_track_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_track);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_untrack_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_untrack);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_track_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_track_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

#ifdef WIDGET_ITEM_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_track_cancel_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_track_cancel);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_del_cb_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_del_cb_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_tooltip_content_cb_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_tooltip_content_cb_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_access_register_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_access_register);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_access_unregister_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_access_unregister);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_access_order_unset_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_access_order_unset);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

#ifdef WIDGET_ITEM_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_disable_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_disable);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef WIDGET_ITEM_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_del_pre_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_del_pre);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_focus_next_object_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_focus_next_object_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_focus_next_object_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_focus_next_object_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_focus_next_item_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_focus_next_item_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_focus_next_item_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_focus_next_item_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_tooltip_window_mode_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_tooltip_window_mode_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_tooltip_window_mode_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_tooltip_window_mode_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_tooltip_style_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_tooltip_style_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_tooltip_style_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_tooltip_style_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_cursor_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_cursor_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_cursor_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_cursor_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_cursor_style_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_cursor_style_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_cursor_style_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_cursor_style_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_cursor_engine_only_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_cursor_engine_only_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_cursor_engine_only_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_cursor_engine_only_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_part_content_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_part_content_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_part_content_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_part_content_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_part_text_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_part_text_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_part_text_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_part_text_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

#ifdef WIDGET_ITEM_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_part_text_custom_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_part_text_custom_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

#ifdef WIDGET_ITEM_PROTECTED
   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_part_text_custom_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_part_text_custom_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;
#endif

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_focus_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_focus_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_focus_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_focus_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_style_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_style_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_style_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_style_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_disabled_get_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_disabled_get);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   ops[i].func = reinterpret_cast<void*>(& ::elm_widget_item_disabled_set_wrapper<T>);
   ops[i].api_func = reinterpret_cast<void*>(& ::elm_wdg_item_disabled_set);
   ops[i].op_type = EO_OP_TYPE_REGULAR;
   ++i;

   initialize_operation_description<T>(::efl::eo::detail::tag<::eo::base>(), &ops[operation_description_class_size< ::elm::widget_item >::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_atspi_accessible>(), &ops[operation_description_class_size< ::elm::widget_item >::value + operation_description_class_size<::eo::base>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_atspi_component>(), &ops[operation_description_class_size< ::elm::widget_item >::value + operation_description_class_size<::eo::base>::value + operation_description_class_size<::elm_interface_atspi_accessible>::value]);
   return 0;
}
inline Eo_Class const* get_eo_class(tag<::elm::widget_item>)
{
   return (ELM_WIDGET_ITEM_CLASS);
}

} } }

/// @endcond

