/// @cond EO_CXX_EO_IMPL

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

inline void elm::entry::text_style_user_pop() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_text_style_user_pop());
}

inline void elm::entry::item_provider_prepend(Elm_Entry_Item_Provider_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_item_provider_prepend(func_, data_));
}

inline void elm::entry::input_panel_show() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_show());
}

inline void elm::entry::imf_context_reset() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_imf_context_reset());
}

inline void elm::entry::calc_force() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_calc_force());
}

inline void elm::entry::anchor_hover_end() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_anchor_hover_end());
}

inline void elm::entry::cursor_selection_begin() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_selection_begin());
}

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

inline void elm::entry::file_save() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_file_save());
}

inline void elm::entry::selection_copy() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_selection_copy());
}

inline void elm::entry::text_style_user_push(::efl::eina::string_view style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_text_style_user_push(::efl::eolian::to_c(style_)));
}

inline void elm::entry::item_provider_remove(Elm_Entry_Item_Provider_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_item_provider_remove(func_, data_));
}

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

inline void elm::entry::context_menu_clear() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_context_menu_clear());
}

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

inline void elm::entry::entry_insert(::efl::eina::string_view entry_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_insert(::efl::eolian::to_c(entry_)));
}

inline void elm::entry::input_panel_imdata_set(const void * data_, int len_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_imdata_set(data_, len_));
}

inline void elm::entry::input_panel_imdata_get(void* data_, int* len_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_imdata_get(data_, len_));
}

inline void elm::entry::selection_paste() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_selection_paste());
}

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

inline void elm::entry::select_none() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_select_none());
}

inline void elm::entry::input_panel_hide() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_hide());
}

inline void elm::entry::select_all() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_select_all());
}

inline void elm::entry::cursor_selection_end() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_selection_end());
}

inline void elm::entry::selection_cut() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_selection_cut());
}

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

inline void elm::entry::markup_filter_remove(Elm_Entry_Filter_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_markup_filter_remove(func_, data_));
}

inline void elm::entry::item_provider_append(Elm_Entry_Item_Provider_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_item_provider_append(func_, data_));
}

inline void elm::entry::markup_filter_append(Elm_Entry_Filter_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_markup_filter_append(func_, data_));
}

inline void elm::entry::entry_append(::efl::eina::string_view str_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_append(::efl::eolian::to_c(str_)));
}

inline void elm::entry::context_menu_item_add(::efl::eina::optional< ::efl::eina::string_view > label_, ::efl::eina::optional< ::efl::eina::string_view > icon_file_, Elm_Icon_Type icon_type_, Evas_Smart_Cb func_, const void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_context_menu_item_add(::efl::eolian::to_c(label_), ::efl::eolian::to_c(icon_file_), icon_type_, func_, data_));
}

inline void elm::entry::markup_filter_prepend(Elm_Entry_Filter_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_markup_filter_prepend(func_, data_));
}

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

inline void elm::entry::scrollable_set(bool scroll_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_scrollable_set(::efl::eolian::to_c(scroll_)));
}

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

inline void elm::entry::input_panel_show_on_demand_set(bool ondemand_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_show_on_demand_set(::efl::eolian::to_c(ondemand_)));
}

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

inline void elm::entry::context_menu_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_context_menu_disabled_set(::efl::eolian::to_c(disabled_)));
}

inline Elm_Cnp_Mode elm::entry::cnp_mode_get() const
{
   Elm_Cnp_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_cnp_mode_get());
   return _tmp_ret;
}

inline void elm::entry::cnp_mode_set(Elm_Cnp_Mode cnp_mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cnp_mode_set(cnp_mode_));
}

inline void elm::entry::file_text_format_set(Elm_Text_Format format_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_file_text_format_set(format_));
}

inline Elm_Input_Panel_Lang elm::entry::input_panel_language_get() const
{
   Elm_Input_Panel_Lang _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_input_panel_language_get());
   return _tmp_ret;
}

inline void elm::entry::input_panel_language_set(Elm_Input_Panel_Lang lang_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_language_set(lang_));
}

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

inline void elm::entry::selection_handler_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_selection_handler_disabled_set(::efl::eolian::to_c(disabled_)));
}

inline int elm::entry::input_panel_layout_variation_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_input_panel_layout_variation_get());
   return _tmp_ret;
}

inline void elm::entry::input_panel_layout_variation_set(int variation_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_layout_variation_set(variation_));
}

inline Elm_Autocapital_Type elm::entry::autocapital_type_get() const
{
   Elm_Autocapital_Type _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_autocapital_type_get());
   return _tmp_ret;
}

inline void elm::entry::autocapital_type_set(Elm_Autocapital_Type autocapital_type_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_autocapital_type_set(autocapital_type_));
}

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

inline void elm::entry::editable_set(bool editable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_editable_set(::efl::eolian::to_c(editable_)));
}

inline ::efl::eina::optional< ::efl::eina::string_view > elm::entry::anchor_hover_style_get() const
{
   const char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_anchor_hover_style_get());
   return ::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(_tmp_ret, std::tuple<std::false_type>());
}

inline void elm::entry::anchor_hover_style_set(::efl::eina::optional< ::efl::eina::string_view > style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_anchor_hover_style_set(::efl::eolian::to_c(style_)));
}

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

inline void elm::entry::single_line_set(bool single_line_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_single_line_set(::efl::eolian::to_c(single_line_)));
}

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

inline void elm::entry::password_set(bool password_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_password_set(::efl::eolian::to_c(password_)));
}

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

inline void elm::entry::input_panel_return_key_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_return_key_disabled_set(::efl::eolian::to_c(disabled_)));
}

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

inline void elm::entry::autosave_set(bool auto_save_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_autosave_set(::efl::eolian::to_c(auto_save_)));
}

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

inline void elm::entry::anchor_hover_parent_set(::evas::object parent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_anchor_hover_parent_set(::efl::eolian::to_c(parent_)));
}

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

inline void elm::entry::prediction_allow_set(bool prediction_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_prediction_allow_set(::efl::eolian::to_c(prediction_)));
}

inline Elm_Input_Hints elm::entry::input_hint_get() const
{
   Elm_Input_Hints _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_input_hint_get());
   return _tmp_ret;
}

inline void elm::entry::input_hint_set(Elm_Input_Hints hints_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_hint_set(hints_));
}

inline Elm_Input_Panel_Layout elm::entry::input_panel_layout_get() const
{
   Elm_Input_Panel_Layout _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_input_panel_layout_get());
   return _tmp_ret;
}

inline void elm::entry::input_panel_layout_set(Elm_Input_Panel_Layout layout_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_layout_set(layout_));
}

inline Elm_Input_Panel_Return_Key_Type elm::entry::input_panel_return_key_type_get() const
{
   Elm_Input_Panel_Return_Key_Type _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_input_panel_return_key_type_get());
   return _tmp_ret;
}

inline void elm::entry::input_panel_return_key_type_set(Elm_Input_Panel_Return_Key_Type return_key_type_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_return_key_type_set(return_key_type_));
}

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

inline void elm::entry::input_panel_enabled_set(bool enabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_enabled_set(::efl::eolian::to_c(enabled_)));
}

inline Elm_Wrap_Type elm::entry::line_wrap_get() const
{
   Elm_Wrap_Type _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_line_wrap_get());
   return _tmp_ret;
}

inline void elm::entry::line_wrap_set(Elm_Wrap_Type wrap_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_line_wrap_set(wrap_));
}

inline int elm::entry::cursor_pos_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_cursor_pos_get());
   return _tmp_ret;
}

inline void elm::entry::cursor_pos_set(int pos_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_pos_set(pos_));
}

inline void elm::entry::icon_visible_set(bool setting_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_icon_visible_set(::efl::eolian::to_c(setting_)));
}

inline void elm::entry::cursor_line_end_set() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_line_end_set());
}

inline void elm::entry::select_region_set(int start_, int end_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_select_region_set(start_, end_));
}

inline void elm::entry::input_panel_return_key_autoenabled_set(bool enabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_return_key_autoenabled_set(::efl::eolian::to_c(enabled_)));
}

inline void elm::entry::end_visible_set(bool setting_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_end_visible_set(::efl::eolian::to_c(setting_)));
}

inline void elm::entry::cursor_begin_set() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_begin_set());
}

inline void elm::entry::cursor_line_begin_set() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_line_begin_set());
}

inline void elm::entry::cursor_end_set() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_end_set());
}

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

inline bool elm::entry::cursor_geometry_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_cursor_geometry_get(x_, y_, w_, h_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void * elm::entry::imf_context_get() const
{
   void * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_imf_context_get());
   return _tmp_ret;
}

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

inline char * elm::entry::cursor_content_get() const
{
   char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_cursor_content_get());
   return _tmp_ret;
}

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

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

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

inline void eo_cxx::elm::entry::text_style_user_pop() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_text_style_user_pop());
}

inline void eo_cxx::elm::entry::item_provider_prepend(Elm_Entry_Item_Provider_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_item_provider_prepend(func_, data_));
}

inline void eo_cxx::elm::entry::input_panel_show() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_show());
}

inline void eo_cxx::elm::entry::imf_context_reset() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_imf_context_reset());
}

inline void eo_cxx::elm::entry::calc_force() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_calc_force());
}

inline void eo_cxx::elm::entry::anchor_hover_end() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_anchor_hover_end());
}

inline void eo_cxx::elm::entry::cursor_selection_begin() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_selection_begin());
}

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

inline void eo_cxx::elm::entry::file_save() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_file_save());
}

inline void eo_cxx::elm::entry::selection_copy() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_selection_copy());
}

inline void eo_cxx::elm::entry::text_style_user_push(::efl::eina::string_view style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_text_style_user_push(::efl::eolian::to_c(style_)));
}

inline void eo_cxx::elm::entry::item_provider_remove(Elm_Entry_Item_Provider_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_item_provider_remove(func_, data_));
}

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

inline void eo_cxx::elm::entry::context_menu_clear() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_context_menu_clear());
}

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

inline void eo_cxx::elm::entry::entry_insert(::efl::eina::string_view entry_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_insert(::efl::eolian::to_c(entry_)));
}

inline void eo_cxx::elm::entry::input_panel_imdata_set(const void * data_, int len_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_imdata_set(data_, len_));
}

inline void eo_cxx::elm::entry::input_panel_imdata_get(void* data_, int* len_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_imdata_get(data_, len_));
}

inline void eo_cxx::elm::entry::selection_paste() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_selection_paste());
}

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

inline void eo_cxx::elm::entry::select_none() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_select_none());
}

inline void eo_cxx::elm::entry::input_panel_hide() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_hide());
}

inline void eo_cxx::elm::entry::select_all() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_select_all());
}

inline void eo_cxx::elm::entry::cursor_selection_end() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_selection_end());
}

inline void eo_cxx::elm::entry::selection_cut() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_selection_cut());
}

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

inline void eo_cxx::elm::entry::markup_filter_remove(Elm_Entry_Filter_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_markup_filter_remove(func_, data_));
}

inline void eo_cxx::elm::entry::item_provider_append(Elm_Entry_Item_Provider_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_item_provider_append(func_, data_));
}

inline void eo_cxx::elm::entry::markup_filter_append(Elm_Entry_Filter_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_markup_filter_append(func_, data_));
}

inline void eo_cxx::elm::entry::entry_append(::efl::eina::string_view str_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_append(::efl::eolian::to_c(str_)));
}

inline void eo_cxx::elm::entry::context_menu_item_add(::efl::eina::optional< ::efl::eina::string_view > label_, ::efl::eina::optional< ::efl::eina::string_view > icon_file_, Elm_Icon_Type icon_type_, Evas_Smart_Cb func_, const void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_context_menu_item_add(::efl::eolian::to_c(label_), ::efl::eolian::to_c(icon_file_), icon_type_, func_, data_));
}

inline void eo_cxx::elm::entry::markup_filter_prepend(Elm_Entry_Filter_Cb func_, void * data_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_markup_filter_prepend(func_, data_));
}

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

inline void eo_cxx::elm::entry::scrollable_set(bool scroll_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_scrollable_set(::efl::eolian::to_c(scroll_)));
}

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

inline void eo_cxx::elm::entry::input_panel_show_on_demand_set(bool ondemand_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_show_on_demand_set(::efl::eolian::to_c(ondemand_)));
}

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

inline void eo_cxx::elm::entry::context_menu_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_context_menu_disabled_set(::efl::eolian::to_c(disabled_)));
}

inline Elm_Cnp_Mode eo_cxx::elm::entry::cnp_mode_get() const
{
   Elm_Cnp_Mode _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_cnp_mode_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::entry::cnp_mode_set(Elm_Cnp_Mode cnp_mode_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cnp_mode_set(cnp_mode_));
}

inline void eo_cxx::elm::entry::file_text_format_set(Elm_Text_Format format_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_file_text_format_set(format_));
}

inline Elm_Input_Panel_Lang eo_cxx::elm::entry::input_panel_language_get() const
{
   Elm_Input_Panel_Lang _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_input_panel_language_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::entry::input_panel_language_set(Elm_Input_Panel_Lang lang_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_language_set(lang_));
}

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

inline void eo_cxx::elm::entry::selection_handler_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_selection_handler_disabled_set(::efl::eolian::to_c(disabled_)));
}

inline int eo_cxx::elm::entry::input_panel_layout_variation_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_input_panel_layout_variation_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::entry::input_panel_layout_variation_set(int variation_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_layout_variation_set(variation_));
}

inline Elm_Autocapital_Type eo_cxx::elm::entry::autocapital_type_get() const
{
   Elm_Autocapital_Type _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_autocapital_type_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::entry::autocapital_type_set(Elm_Autocapital_Type autocapital_type_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_autocapital_type_set(autocapital_type_));
}

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

inline void eo_cxx::elm::entry::editable_set(bool editable_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_editable_set(::efl::eolian::to_c(editable_)));
}

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

inline void eo_cxx::elm::entry::anchor_hover_style_set(::efl::eina::optional< ::efl::eina::string_view > style_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_anchor_hover_style_set(::efl::eolian::to_c(style_)));
}

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

inline void eo_cxx::elm::entry::single_line_set(bool single_line_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_single_line_set(::efl::eolian::to_c(single_line_)));
}

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

inline void eo_cxx::elm::entry::password_set(bool password_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_password_set(::efl::eolian::to_c(password_)));
}

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

inline void eo_cxx::elm::entry::input_panel_return_key_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_return_key_disabled_set(::efl::eolian::to_c(disabled_)));
}

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

inline void eo_cxx::elm::entry::autosave_set(bool auto_save_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_autosave_set(::efl::eolian::to_c(auto_save_)));
}

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

inline void eo_cxx::elm::entry::anchor_hover_parent_set(::evas::object parent_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_anchor_hover_parent_set(::efl::eolian::to_c(parent_)));
}

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

inline void eo_cxx::elm::entry::prediction_allow_set(bool prediction_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_prediction_allow_set(::efl::eolian::to_c(prediction_)));
}

inline Elm_Input_Hints eo_cxx::elm::entry::input_hint_get() const
{
   Elm_Input_Hints _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_input_hint_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::entry::input_hint_set(Elm_Input_Hints hints_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_hint_set(hints_));
}

inline Elm_Input_Panel_Layout eo_cxx::elm::entry::input_panel_layout_get() const
{
   Elm_Input_Panel_Layout _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_input_panel_layout_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::entry::input_panel_layout_set(Elm_Input_Panel_Layout layout_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_layout_set(layout_));
}

inline Elm_Input_Panel_Return_Key_Type eo_cxx::elm::entry::input_panel_return_key_type_get() const
{
   Elm_Input_Panel_Return_Key_Type _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_input_panel_return_key_type_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::entry::input_panel_return_key_type_set(Elm_Input_Panel_Return_Key_Type return_key_type_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_return_key_type_set(return_key_type_));
}

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

inline void eo_cxx::elm::entry::input_panel_enabled_set(bool enabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_enabled_set(::efl::eolian::to_c(enabled_)));
}

inline Elm_Wrap_Type eo_cxx::elm::entry::line_wrap_get() const
{
   Elm_Wrap_Type _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_line_wrap_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::entry::line_wrap_set(Elm_Wrap_Type wrap_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_line_wrap_set(wrap_));
}

inline int eo_cxx::elm::entry::cursor_pos_get() const
{
   int _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_cursor_pos_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::entry::cursor_pos_set(int pos_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_pos_set(pos_));
}

inline void eo_cxx::elm::entry::icon_visible_set(bool setting_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_icon_visible_set(::efl::eolian::to_c(setting_)));
}

inline void eo_cxx::elm::entry::cursor_line_end_set() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_line_end_set());
}

inline void eo_cxx::elm::entry::select_region_set(int start_, int end_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_select_region_set(start_, end_));
}

inline void eo_cxx::elm::entry::input_panel_return_key_autoenabled_set(bool enabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_input_panel_return_key_autoenabled_set(::efl::eolian::to_c(enabled_)));
}

inline void eo_cxx::elm::entry::end_visible_set(bool setting_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_end_visible_set(::efl::eolian::to_c(setting_)));
}

inline void eo_cxx::elm::entry::cursor_begin_set() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_begin_set());
}

inline void eo_cxx::elm::entry::cursor_line_begin_set() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_line_begin_set());
}

inline void eo_cxx::elm::entry::cursor_end_set() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_entry_cursor_end_set());
}

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

inline bool eo_cxx::elm::entry::cursor_geometry_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_cursor_geometry_get(x_, y_, w_, h_));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline void * eo_cxx::elm::entry::imf_context_get() const
{
   void * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_imf_context_get());
   return _tmp_ret;
}

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

inline char * eo_cxx::elm::entry::cursor_content_get() const
{
   char * _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_entry_cursor_content_get());
   return _tmp_ret;
}

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

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

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

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

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

template <typename T>
bool elm_entry_cursor_prev_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->cursor_prev();
      }
   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_entry_text_style_user_pop_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->text_style_user_pop();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

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

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

template <typename T>
bool elm_entry_cursor_down_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->cursor_down();
      }
   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_entry_file_save_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->file_save();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

template <typename T>
void elm_entry_text_style_user_push_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * style_)
{
   try
      {
         static_cast<T*>(self->this_)->text_style_user_push(::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>
void elm_entry_item_provider_remove_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Entry_Item_Provider_Cb func_, void * data_)
{
   try
      {
         static_cast<T*>(self->this_)->item_provider_remove(func_, data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::efl::eina::string_view elm_entry_text_style_user_peek_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->text_style_user_peek();
      }
   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_entry_context_menu_clear_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->context_menu_clear();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_entry_cursor_up_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->cursor_up();
      }
   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_entry_entry_insert_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * entry_)
{
   try
      {
         static_cast<T*>(self->this_)->entry_insert(::efl::eolian::to_cxx<::efl::eina::string_view>(entry_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
void elm_entry_input_panel_imdata_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const void * data_, int len_)
{
   try
      {
         static_cast<T*>(self->this_)->input_panel_imdata_set(data_, len_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

template <typename T>
bool elm_entry_cursor_next_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->cursor_next();
      }
   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_entry_select_none_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         static_cast<T*>(self->this_)->select_none();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

template <typename T>
bool elm_entry_is_empty_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->is_empty();
      }
   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_entry_markup_filter_remove_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Elm_Entry_Filter_Cb func_, void * data_)
{
   try
      {
         static_cast<T*>(self->this_)->markup_filter_remove(func_, data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

template <typename T>
void elm_entry_context_menu_item_add_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const char * label_, const char * icon_file_, Elm_Icon_Type icon_type_, Evas_Smart_Cb func_, const void * data_)
{
   try
      {
         static_cast<T*>(self->this_)->context_menu_item_add(::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(label_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(icon_file_, std::tuple<std::false_type>()), icon_type_, func_, data_);
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

template <typename T>
bool elm_entry_scrollable_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->scrollable_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_entry_scrollable_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool scroll_)
{
   try
      {
         static_cast<T*>(self->this_)->scrollable_set(::efl::eolian::to_cxx<bool>(scroll_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_entry_input_panel_show_on_demand_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->input_panel_show_on_demand_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_entry_input_panel_show_on_demand_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool ondemand_)
{
   try
      {
         static_cast<T*>(self->this_)->input_panel_show_on_demand_set(::efl::eolian::to_cxx<bool>(ondemand_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_entry_context_menu_disabled_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->context_menu_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_entry_context_menu_disabled_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool disabled_)
{
   try
      {
         static_cast<T*>(self->this_)->context_menu_disabled_set(::efl::eolian::to_cxx<bool>(disabled_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

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

template <typename T>
bool elm_entry_selection_handler_disabled_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->selection_handler_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_entry_selection_handler_disabled_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool disabled_)
{
   try
      {
         static_cast<T*>(self->this_)->selection_handler_disabled_set(::efl::eolian::to_cxx<bool>(disabled_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

template <typename T>
bool elm_entry_editable_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->editable_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_entry_editable_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool editable_)
{
   try
      {
         static_cast<T*>(self->this_)->editable_set(::efl::eolian::to_cxx<bool>(editable_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

template <typename T>
bool elm_entry_single_line_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->single_line_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_entry_single_line_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool single_line_)
{
   try
      {
         static_cast<T*>(self->this_)->single_line_set(::efl::eolian::to_cxx<bool>(single_line_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_entry_password_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->password_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_entry_password_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool password_)
{
   try
      {
         static_cast<T*>(self->this_)->password_set(::efl::eolian::to_cxx<bool>(password_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_entry_input_panel_return_key_disabled_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->input_panel_return_key_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_entry_input_panel_return_key_disabled_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool disabled_)
{
   try
      {
         static_cast<T*>(self->this_)->input_panel_return_key_disabled_set(::efl::eolian::to_cxx<bool>(disabled_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_entry_autosave_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->autosave_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_entry_autosave_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool auto_save_)
{
   try
      {
         static_cast<T*>(self->this_)->autosave_set(::efl::eolian::to_cxx<bool>(auto_save_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
::evas::object elm_entry_anchor_hover_parent_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->anchor_hover_parent_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_entry_anchor_hover_parent_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Object * parent_)
{
   try
      {
         static_cast<T*>(self->this_)->anchor_hover_parent_set(::efl::eolian::to_cxx<::evas::object>(parent_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

template <typename T>
bool elm_entry_prediction_allow_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->prediction_allow_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_entry_prediction_allow_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool prediction_)
{
   try
      {
         static_cast<T*>(self->this_)->prediction_allow_set(::efl::eolian::to_cxx<bool>(prediction_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

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

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

template <typename T>
bool elm_entry_input_panel_enabled_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->input_panel_enabled_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_entry_input_panel_enabled_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool enabled_)
{
   try
      {
         static_cast<T*>(self->this_)->input_panel_enabled_set(::efl::eolian::to_cxx<bool>(enabled_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
      }
}

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
::evas::object elm_entry_textblock_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->textblock_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>
bool elm_entry_cursor_geometry_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
{
   try
      {
         return static_cast<T*>(self->this_)->cursor_geometry_get(x_, y_, w_, h_);
      }
   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_entry_imf_context_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->imf_context_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         void * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
bool elm_entry_cursor_is_format_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->cursor_is_format_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>
char * elm_entry_cursor_content_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->cursor_content_get();
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         char * _tmp_ret{};
         return _tmp_ret;
      }
}

template <typename T>
::efl::eina::string_view elm_entry_selection_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->selection_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>
bool elm_entry_cursor_is_visible_format_get_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self)
{
   try
      {
         return static_cast<T*>(self->this_)->cursor_is_visible_format_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>());
      }
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::elm::entry >
{
   template <typename T>
   struct type
         : virtual operations< ::elm::layout >::template type<T>
         , virtual operations< ::elm_interface_scrollable >::template type<T>
         , virtual operations< ::evas::clickable_interface >::template type<T>
         , virtual operations< ::elm_interface_atspi_text >::template type<T>
         , virtual operations< ::elm_interface_atspi_editable_text >::template type<T>
         , virtual operations< ::efl::file >::template type<T>
         , virtual operations< ::evas::selectable_interface >::template type<T>
         , virtual operations< ::evas::scrollable_interface >::template type<T>
   {
      virtual bool cursor_prev()
      {
         Eina_Bool _tmp_ret = {};

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

      virtual void text_style_user_pop()
      {

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

      virtual void item_provider_prepend(Elm_Entry_Item_Provider_Cb func_, void * data_)
      {

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

      virtual void input_panel_show()
      {

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

      virtual void imf_context_reset()
      {

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

      virtual void calc_force()
      {

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

      virtual void anchor_hover_end()
      {

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

      virtual void cursor_selection_begin()
      {

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

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

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

      virtual void file_save()
      {

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

      virtual void selection_copy()
      {

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

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

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

      virtual void item_provider_remove(Elm_Entry_Item_Provider_Cb func_, void * data_)
      {

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

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

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

      virtual void context_menu_clear()
      {

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

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

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

      virtual void entry_insert(::efl::eina::string_view entry_)
      {

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

      virtual void input_panel_imdata_set(const void * data_, int len_)
      {

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

      virtual void input_panel_imdata_get(void* data_, int* len_)
      {

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

      virtual void selection_paste()
      {

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

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

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

      virtual void select_none()
      {

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

      virtual void input_panel_hide()
      {

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

      virtual void select_all()
      {

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

      virtual void cursor_selection_end()
      {

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

      virtual void selection_cut()
      {

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

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

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

      virtual void markup_filter_remove(Elm_Entry_Filter_Cb func_, void * data_)
      {

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

      virtual void item_provider_append(Elm_Entry_Item_Provider_Cb func_, void * data_)
      {

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

      virtual void markup_filter_append(Elm_Entry_Filter_Cb func_, void * data_)
      {

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

      virtual void entry_append(::efl::eina::string_view str_)
      {

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

      virtual void context_menu_item_add(::efl::eina::optional< ::efl::eina::string_view > label_, ::efl::eina::optional< ::efl::eina::string_view > icon_file_, Elm_Icon_Type icon_type_, Evas_Smart_Cb func_, const void * data_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_entry_context_menu_item_add(::efl::eolian::to_c(label_), ::efl::eolian::to_c(icon_file_), icon_type_, func_, data_));
      }

      virtual void markup_filter_prepend(Elm_Entry_Filter_Cb func_, void * data_)
      {

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

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

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

      virtual void scrollable_set(bool scroll_)
      {

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

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

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

      virtual void input_panel_show_on_demand_set(bool ondemand_)
      {

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

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

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

      virtual void context_menu_disabled_set(bool disabled_)
      {

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

      virtual Elm_Cnp_Mode cnp_mode_get()
      {
         Elm_Cnp_Mode _tmp_ret = {};

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

      virtual void cnp_mode_set(Elm_Cnp_Mode cnp_mode_)
      {

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

      virtual void file_text_format_set(Elm_Text_Format format_)
      {

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

      virtual Elm_Input_Panel_Lang input_panel_language_get()
      {
         Elm_Input_Panel_Lang _tmp_ret = {};

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

      virtual void input_panel_language_set(Elm_Input_Panel_Lang lang_)
      {

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

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

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

      virtual void selection_handler_disabled_set(bool disabled_)
      {

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

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

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

      virtual void input_panel_layout_variation_set(int variation_)
      {

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

      virtual Elm_Autocapital_Type autocapital_type_get()
      {
         Elm_Autocapital_Type _tmp_ret = {};

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

      virtual void autocapital_type_set(Elm_Autocapital_Type autocapital_type_)
      {

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

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

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

      virtual void editable_set(bool editable_)
      {

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

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

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

      virtual void anchor_hover_style_set(::efl::eina::optional< ::efl::eina::string_view > style_)
      {

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

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

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

      virtual void single_line_set(bool single_line_)
      {

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

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

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

      virtual void password_set(bool password_)
      {

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

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

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

      virtual void input_panel_return_key_disabled_set(bool disabled_)
      {

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

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

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

      virtual void autosave_set(bool auto_save_)
      {

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

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

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

      virtual void anchor_hover_parent_set(::evas::object parent_)
      {

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

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

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

      virtual void prediction_allow_set(bool prediction_)
      {

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

      virtual Elm_Input_Hints input_hint_get()
      {
         Elm_Input_Hints _tmp_ret = {};

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

      virtual void input_hint_set(Elm_Input_Hints hints_)
      {

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

      virtual Elm_Input_Panel_Layout input_panel_layout_get()
      {
         Elm_Input_Panel_Layout _tmp_ret = {};

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

      virtual void input_panel_layout_set(Elm_Input_Panel_Layout layout_)
      {

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

      virtual Elm_Input_Panel_Return_Key_Type input_panel_return_key_type_get()
      {
         Elm_Input_Panel_Return_Key_Type _tmp_ret = {};

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

      virtual void input_panel_return_key_type_set(Elm_Input_Panel_Return_Key_Type return_key_type_)
      {

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

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

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

      virtual void input_panel_enabled_set(bool enabled_)
      {

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

      virtual Elm_Wrap_Type line_wrap_get()
      {
         Elm_Wrap_Type _tmp_ret = {};

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

      virtual void line_wrap_set(Elm_Wrap_Type wrap_)
      {

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

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

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

      virtual void cursor_pos_set(int pos_)
      {

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

      virtual void icon_visible_set(bool setting_)
      {

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

      virtual void cursor_line_end_set()
      {

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

      virtual void select_region_set(int start_, int end_)
      {

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

      virtual void input_panel_return_key_autoenabled_set(bool enabled_)
      {

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

      virtual void end_visible_set(bool setting_)
      {

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

      virtual void cursor_begin_set()
      {

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

      virtual void cursor_line_begin_set()
      {

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

      virtual void cursor_end_set()
      {

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

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

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

      virtual bool cursor_geometry_get(Evas_Coord* x_, Evas_Coord* y_, Evas_Coord* w_, Evas_Coord* h_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual void * imf_context_get()
      {
         void * _tmp_ret = {};

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

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

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

      virtual char * cursor_content_get()
      {
         char * _tmp_ret = {};

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

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

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

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

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

   };
};


template<>
struct operation_description_class_size< ::elm::entry >
{
   static constexpr int value = 
#if defined(ENTRY_PROTECTED) && defined(ENTRY_BETA)
      93
#elif defined(ENTRY_PROTECTED)
      93
#elif defined(ENTRY_BETA)
      93
#else
      93
#endif
      + operation_description_class_size<::elm::layout >::value      + operation_description_class_size<::elm_interface_scrollable >::value      + operation_description_class_size<::evas::clickable_interface >::value      + operation_description_class_size<::elm_interface_atspi_text >::value      + operation_description_class_size<::elm_interface_atspi_editable_text >::value      + operation_description_class_size<::efl::file >::value      + operation_description_class_size<::evas::selectable_interface >::value      + operation_description_class_size<::evas::scrollable_interface >::value;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   initialize_operation_description<T>(::efl::eo::detail::tag<::elm::layout>(), &ops[operation_description_class_size< ::elm::entry >::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_scrollable>(), &ops[operation_description_class_size< ::elm::entry >::value + operation_description_class_size<::elm::layout>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::evas::clickable_interface>(), &ops[operation_description_class_size< ::elm::entry >::value + operation_description_class_size<::elm::layout>::value + operation_description_class_size<::elm_interface_scrollable>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_atspi_text>(), &ops[operation_description_class_size< ::elm::entry >::value + operation_description_class_size<::elm::layout>::value + operation_description_class_size<::elm_interface_scrollable>::value + operation_description_class_size<::evas::clickable_interface>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_atspi_editable_text>(), &ops[operation_description_class_size< ::elm::entry >::value + operation_description_class_size<::elm::layout>::value + operation_description_class_size<::elm_interface_scrollable>::value + operation_description_class_size<::evas::clickable_interface>::value + operation_description_class_size<::elm_interface_atspi_text>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::efl::file>(), &ops[operation_description_class_size< ::elm::entry >::value + operation_description_class_size<::elm::layout>::value + operation_description_class_size<::elm_interface_scrollable>::value + operation_description_class_size<::evas::clickable_interface>::value + operation_description_class_size<::elm_interface_atspi_text>::value + operation_description_class_size<::elm_interface_atspi_editable_text>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::evas::selectable_interface>(), &ops[operation_description_class_size< ::elm::entry >::value + operation_description_class_size<::elm::layout>::value + operation_description_class_size<::elm_interface_scrollable>::value + operation_description_class_size<::evas::clickable_interface>::value + operation_description_class_size<::elm_interface_atspi_text>::value + operation_description_class_size<::elm_interface_atspi_editable_text>::value + operation_description_class_size<::efl::file>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::evas::scrollable_interface>(), &ops[operation_description_class_size< ::elm::entry >::value + operation_description_class_size<::elm::layout>::value + operation_description_class_size<::elm_interface_scrollable>::value + operation_description_class_size<::evas::clickable_interface>::value + operation_description_class_size<::elm_interface_atspi_text>::value + operation_description_class_size<::elm_interface_atspi_editable_text>::value + operation_description_class_size<::efl::file>::value + operation_description_class_size<::evas::selectable_interface>::value]);
   return 0;
}
inline Eo_Class const* get_eo_class(tag<::elm::entry>)
{
   return (ELM_ENTRY_CLASS);
}

} } }

/// @endcond

