/// @cond EO_CXX_EO_IMPL

inline void elm::image::sizing_eval() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_sizing_eval());
}

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

inline void elm::image::editable_set(bool set_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_editable_set(::efl::eolian::to_c(set_)));
}

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

inline void elm::image::resize_down_set(bool resize_down_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_resize_down_set(::efl::eolian::to_c(resize_down_)));
}

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

inline void elm::image::resize_up_set(bool resize_up_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_resize_up_set(::efl::eolian::to_c(resize_up_)));
}

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

inline void elm::image::smooth_set(bool smooth_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_smooth_set(::efl::eolian::to_c(smooth_)));
}

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

inline void elm::image::no_scale_set(bool no_scale_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_no_scale_set(::efl::eolian::to_c(no_scale_)));
}

inline double elm::image::scale_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_image_scale_get());
   return _tmp_ret;
}

inline void elm::image::scale_set(double scale_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_scale_set(scale_));
}

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

inline void elm::image::fill_inside_set(bool fill_inside_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_fill_inside_set(::efl::eolian::to_c(fill_inside_)));
}

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

inline void elm::image::aspect_fixed_set(bool fixed_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_aspect_fixed_set(::efl::eolian::to_c(fixed_)));
}

inline Elm_Image_Orient elm::image::orient_get() const
{
   Elm_Image_Orient _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_image_orient_get());
   return _tmp_ret;
}

inline void elm::image::orient_set(Elm_Image_Orient orient_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_orient_set(orient_));
}

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

inline void elm::image::fill_outside_set(bool fill_outside_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_fill_outside_set(::efl::eolian::to_c(fill_outside_)));
}

inline void elm::image::resizable_get(Eina_Bool* up_, Eina_Bool* down_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_resizable_get(up_, down_));
}

inline void elm::image::resizable_set(bool up_, bool down_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_resizable_set(::efl::eolian::to_c(up_), ::efl::eolian::to_c(down_)));
}

inline void elm::image::preload_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_preload_disabled_set(::efl::eolian::to_c(disabled_)));
}

inline bool elm::image::mmap_set(const Eina_File * file_, ::efl::eina::optional< ::efl::eina::string_view > group_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_image_mmap_set(file_, ::efl::eolian::to_c(group_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool elm::image::memfile_set(const void * img_, size_t size_, ::efl::eina::optional< ::efl::eina::string_view > format_, ::efl::eina::optional< ::efl::eina::string_view > key_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_image_memfile_set(img_, size_, ::efl::eolian::to_c(format_), ::efl::eolian::to_c(key_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void elm::image::object_size_get(int* w_, int* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_object_size_get(w_, h_));
}

inline void eo_cxx::elm::image::sizing_eval() const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_sizing_eval());
}

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

inline void eo_cxx::elm::image::editable_set(bool set_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_editable_set(::efl::eolian::to_c(set_)));
}

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

inline void eo_cxx::elm::image::resize_down_set(bool resize_down_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_resize_down_set(::efl::eolian::to_c(resize_down_)));
}

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

inline void eo_cxx::elm::image::resize_up_set(bool resize_up_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_resize_up_set(::efl::eolian::to_c(resize_up_)));
}

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

inline void eo_cxx::elm::image::smooth_set(bool smooth_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_smooth_set(::efl::eolian::to_c(smooth_)));
}

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

inline void eo_cxx::elm::image::no_scale_set(bool no_scale_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_no_scale_set(::efl::eolian::to_c(no_scale_)));
}

inline double eo_cxx::elm::image::scale_get() const
{
   double _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_image_scale_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::image::scale_set(double scale_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_scale_set(scale_));
}

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

inline void eo_cxx::elm::image::fill_inside_set(bool fill_inside_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_fill_inside_set(::efl::eolian::to_c(fill_inside_)));
}

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

inline void eo_cxx::elm::image::aspect_fixed_set(bool fixed_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_aspect_fixed_set(::efl::eolian::to_c(fixed_)));
}

inline Elm_Image_Orient eo_cxx::elm::image::orient_get() const
{
   Elm_Image_Orient _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_image_orient_get());
   return _tmp_ret;
}

inline void eo_cxx::elm::image::orient_set(Elm_Image_Orient orient_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_orient_set(orient_));
}

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

inline void eo_cxx::elm::image::fill_outside_set(bool fill_outside_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_fill_outside_set(::efl::eolian::to_c(fill_outside_)));
}

inline void eo_cxx::elm::image::resizable_get(Eina_Bool* up_, Eina_Bool* down_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_resizable_get(up_, down_));
}

inline void eo_cxx::elm::image::resizable_set(bool up_, bool down_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_resizable_set(::efl::eolian::to_c(up_), ::efl::eolian::to_c(down_)));
}

inline void eo_cxx::elm::image::preload_disabled_set(bool disabled_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_preload_disabled_set(::efl::eolian::to_c(disabled_)));
}

inline bool eo_cxx::elm::image::mmap_set(const Eina_File * file_, ::efl::eina::optional< ::efl::eina::string_view > group_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_image_mmap_set(file_, ::efl::eolian::to_c(group_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

inline bool eo_cxx::elm::image::memfile_set(const void * img_, size_t size_, ::efl::eina::optional< ::efl::eina::string_view > format_, ::efl::eina::optional< ::efl::eina::string_view > key_) const
{
   Eina_Bool _tmp_ret;
   eo_do(_concrete_eo_ptr(), _tmp_ret = ::elm_obj_image_memfile_set(img_, size_, ::efl::eolian::to_c(format_), ::efl::eolian::to_c(key_)));
   return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
}

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

inline void eo_cxx::elm::image::object_size_get(int* w_, int* h_) const
{
   eo_do(_concrete_eo_ptr(), ::elm_obj_image_object_size_get(w_, h_));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
void elm_image_preload_disabled_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, Eina_Bool disabled_)
{
   try
      {
         static_cast<T*>(self->this_)->preload_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_image_mmap_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const Eina_File * file_, const char * group_)
{
   try
      {
         return static_cast<T*>(self->this_)->mmap_set(file_, ::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(group_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}

template <typename T>
bool elm_image_memfile_set_wrapper(Eo* objid EINA_UNUSED, ::efl::eo::detail::Inherit_Private_Data* self, const void * img_, size_t size_, const char * format_, const char * key_)
{
   try
      {
         return static_cast<T*>(self->this_)->memfile_set(img_, size_, ::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(format_, std::tuple<std::false_type>()), ::efl::eolian::to_cxx<::efl::eina::optional< ::efl::eina::string_view >>(key_, std::tuple<std::false_type>()));
      }
   catch (...)
      {
         eina_error_set( ::efl::eina::unknown_error() );
         Eina_Bool _tmp_ret{};
         return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }
}

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

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

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::elm::image >
{
   template <typename T>
   struct type
         : virtual operations< ::elm::widget >::template type<T>
         , virtual operations< ::efl::file >::template type<T>
         , virtual operations< ::efl::image >::template type<T>
         , virtual operations< ::evas::clickable_interface >::template type<T>
         , virtual operations< ::edje::object >::template type<T>
         , virtual operations< ::elm_interface_atspi_image >::template type<T>
         , virtual operations< ::elm_interface_atspi_widget_action >::template type<T>
         , virtual operations< ::efl::player >::template type<T>
   {
      virtual void sizing_eval()
      {

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

      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_image_editable_get());
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void editable_set(bool set_)
      {

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

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

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

      virtual void resize_down_set(bool resize_down_)
      {

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

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

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

      virtual void resize_up_set(bool resize_up_)
      {

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

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

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

      virtual void smooth_set(bool smooth_)
      {

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

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

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

      virtual void no_scale_set(bool no_scale_)
      {

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

      virtual double scale_get()
      {
         double _tmp_ret = {};

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

      virtual void scale_set(double scale_)
      {

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

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

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

      virtual void fill_inside_set(bool fill_inside_)
      {

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

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

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

      virtual void aspect_fixed_set(bool fixed_)
      {

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

      virtual Elm_Image_Orient orient_get()
      {
         Elm_Image_Orient _tmp_ret = {};

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

      virtual void orient_set(Elm_Image_Orient orient_)
      {

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

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

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

      virtual void fill_outside_set(bool fill_outside_)
      {

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

      virtual void resizable_get(Eina_Bool* up_, Eina_Bool* down_)
      {

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

      virtual void resizable_set(bool up_, bool down_)
      {

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               ::elm_obj_image_resizable_set(::efl::eolian::to_c(up_), ::efl::eolian::to_c(down_)));
      }

      virtual void preload_disabled_set(bool disabled_)
      {

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

      virtual bool mmap_set(const Eina_File * file_, ::efl::eina::optional< ::efl::eina::string_view > group_)
      {
         Eina_Bool _tmp_ret = {};

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

      virtual bool memfile_set(const void * img_, size_t size_, ::efl::eina::optional< ::efl::eina::string_view > format_, ::efl::eina::optional< ::efl::eina::string_view > key_)
      {
         Eina_Bool _tmp_ret = {};

         eo_do_super(dynamic_cast<T*>(this)->_eo_ptr(),
               dynamic_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::elm_obj_image_memfile_set(img_, size_, ::efl::eolian::to_c(format_), ::efl::eolian::to_c(key_)));
            return ::efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

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

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

      virtual void object_size_get(int* w_, int* h_)
      {

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

   };
};


template<>
struct operation_description_class_size< ::elm::image >
{
   static constexpr int value = 
#if defined(IMAGE_PROTECTED) && defined(IMAGE_BETA)
      28
#elif defined(IMAGE_PROTECTED)
      28
#elif defined(IMAGE_BETA)
      28
#else
      28
#endif
      + operation_description_class_size<::elm::widget >::value      + operation_description_class_size<::efl::file >::value      + operation_description_class_size<::efl::image >::value      + operation_description_class_size<::evas::clickable_interface >::value      + operation_description_class_size<::edje::object >::value      + operation_description_class_size<::elm_interface_atspi_image >::value      + operation_description_class_size<::elm_interface_atspi_widget_action >::value      + operation_description_class_size<::efl::player >::value;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   initialize_operation_description<T>(::efl::eo::detail::tag<::elm::widget>(), &ops[operation_description_class_size< ::elm::image >::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::efl::file>(), &ops[operation_description_class_size< ::elm::image >::value + operation_description_class_size<::elm::widget>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::efl::image>(), &ops[operation_description_class_size< ::elm::image >::value + operation_description_class_size<::elm::widget>::value + operation_description_class_size<::efl::file>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::evas::clickable_interface>(), &ops[operation_description_class_size< ::elm::image >::value + operation_description_class_size<::elm::widget>::value + operation_description_class_size<::efl::file>::value + operation_description_class_size<::efl::image>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::edje::object>(), &ops[operation_description_class_size< ::elm::image >::value + operation_description_class_size<::elm::widget>::value + operation_description_class_size<::efl::file>::value + operation_description_class_size<::efl::image>::value + operation_description_class_size<::evas::clickable_interface>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_atspi_image>(), &ops[operation_description_class_size< ::elm::image >::value + operation_description_class_size<::elm::widget>::value + operation_description_class_size<::efl::file>::value + operation_description_class_size<::efl::image>::value + operation_description_class_size<::evas::clickable_interface>::value + operation_description_class_size<::edje::object>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::elm_interface_atspi_widget_action>(), &ops[operation_description_class_size< ::elm::image >::value + operation_description_class_size<::elm::widget>::value + operation_description_class_size<::efl::file>::value + operation_description_class_size<::efl::image>::value + operation_description_class_size<::evas::clickable_interface>::value + operation_description_class_size<::edje::object>::value + operation_description_class_size<::elm_interface_atspi_image>::value]);
   initialize_operation_description<T>(::efl::eo::detail::tag<::efl::player>(), &ops[operation_description_class_size< ::elm::image >::value + operation_description_class_size<::elm::widget>::value + operation_description_class_size<::efl::file>::value + operation_description_class_size<::efl::image>::value + operation_description_class_size<::evas::clickable_interface>::value + operation_description_class_size<::edje::object>::value + operation_description_class_size<::elm_interface_atspi_image>::value + operation_description_class_size<::elm_interface_atspi_widget_action>::value]);
   return 0;
}
inline Eo_Class const* get_eo_class(tag<::elm::image>)
{
   return (ELM_IMAGE_CLASS);
}

} } }

/// @endcond

