
/*

  KLayout Layout Viewer
  Copyright (C) 2006-2016 Matthias Koefferlein

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

/**
*  @file gsiDeclQSqlResult.cc 
*
*  DO NOT EDIT THIS FILE. 
*  This file has been created automatically
*/

#include "gsiQtSql.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiDeclQSqlResult_Enums.h"
#include <memory>

// -----------------------------------------------------------------------
// class QSqlResult

// QVariant QSqlResult::handle()


static void _init_f_handle_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QVariant > ();
}

static void _call_f_handle_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<QVariant > ((QVariant)((QSqlResult *)cls)->handle ());
}

static qt_gsi::GenericMethod *_create_f_handle_c0 ()
{
  return new qt_gsi::GenericMethod ("handle", "@brief Method QVariant QSqlResult::handle()\n", true, &_init_f_handle_c0, &_call_f_handle_c0);
}

namespace gsi
{
gsi::Class<QSqlResult> decl_QSqlResult ("QSqlResult_Native",
  gsi::Methods(_create_f_handle_c0 ()),
  "@hide\n@alias QSqlResult");
}


class QSqlResult_Adaptor : public QSqlResult, public qt_gsi::QtObjectBase
{
public:

  virtual ~QSqlResult_Adaptor();

  //  void QSqlResult::addBindValue(const QVariant &val, QFlags<QSql::ParamTypeFlag> type)
  void fp_QSqlResult_addBindValue_4937 (const QVariant &val, const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & type) {
    QSqlResult::addBindValue(val, qt_gsi::QtToCppAdaptor<QFlags<QSql::ParamTypeFlag> >(type).cref());
  }

  //  int QSqlResult::at()
  int fp_QSqlResult_at_c0 () const {
    return QSqlResult::at();
  }

  //  QFlags<QSql::ParamTypeFlag> QSqlResult::bindValueType(const QString &placeholder)
  qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type fp_QSqlResult_bindValueType_c2025 (const QString &placeholder) const {
    return qt_gsi::CppToQtAdaptor<QFlags<QSql::ParamTypeFlag> >(QSqlResult::bindValueType(placeholder));
  }

  //  QFlags<QSql::ParamTypeFlag> QSqlResult::bindValueType(int pos)
  qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type fp_QSqlResult_bindValueType_c767 (int pos) const {
    return qt_gsi::CppToQtAdaptor<QFlags<QSql::ParamTypeFlag> >(QSqlResult::bindValueType(pos));
  }

  //  QSqlResult::BindingSyntax QSqlResult::bindingSyntax()
  unsigned int fp_QSqlResult_bindingSyntax_c0 () const {
    return (unsigned int)(QSqlResult::bindingSyntax());
  }

  //  QVariant QSqlResult::boundValue(const QString &placeholder)
  QVariant fp_QSqlResult_boundValue_c2025 (const QString &placeholder) const {
    return QSqlResult::boundValue(placeholder);
  }

  //  QVariant QSqlResult::boundValue(int pos)
  QVariant fp_QSqlResult_boundValue_c767 (int pos) const {
    return QSqlResult::boundValue(pos);
  }

  //  int QSqlResult::boundValueCount()
  int fp_QSqlResult_boundValueCount_c0 () const {
    return QSqlResult::boundValueCount();
  }

  //  QString QSqlResult::boundValueName(int pos)
  QString fp_QSqlResult_boundValueName_c767 (int pos) const {
    return QSqlResult::boundValueName(pos);
  }

  //  QVector<QVariant> &QSqlResult::boundValues()
  qt_gsi::Converter<QVector<QVariant> >::target_type fp_QSqlResult_boundValues_c0 () const {
    return qt_gsi::CppToQtAdaptor<QVector<QVariant> >(QSqlResult::boundValues());
  }

  //  void QSqlResult::clear()
  void fp_QSqlResult_clear_0 () {
    QSqlResult::clear();
  }

  //  void QSqlResult::detachFromResultSet()
  void fp_QSqlResult_detachFromResultSet_0 () {
    QSqlResult::detachFromResultSet();
  }

  //  const QSqlDriver *QSqlResult::driver()
  const QSqlDriver * fp_QSqlResult_driver_c0 () const {
    return QSqlResult::driver();
  }

  //  bool QSqlResult::execBatch(bool arrayBind)
  bool fp_QSqlResult_execBatch_864 (bool arrayBind) {
    return QSqlResult::execBatch(arrayBind);
  }

  //  QString QSqlResult::executedQuery()
  QString fp_QSqlResult_executedQuery_c0 () const {
    return QSqlResult::executedQuery();
  }

  //  bool QSqlResult::hasOutValues()
  bool fp_QSqlResult_hasOutValues_c0 () const {
    return QSqlResult::hasOutValues();
  }

  //  bool QSqlResult::isActive()
  bool fp_QSqlResult_isActive_c0 () const {
    return QSqlResult::isActive();
  }

  //  bool QSqlResult::isForwardOnly()
  bool fp_QSqlResult_isForwardOnly_c0 () const {
    return QSqlResult::isForwardOnly();
  }

  //  bool QSqlResult::isSelect()
  bool fp_QSqlResult_isSelect_c0 () const {
    return QSqlResult::isSelect();
  }

  //  bool QSqlResult::isValid()
  bool fp_QSqlResult_isValid_c0 () const {
    return QSqlResult::isValid();
  }

  //  QSqlError QSqlResult::lastError()
  QSqlError fp_QSqlResult_lastError_c0 () const {
    return QSqlResult::lastError();
  }

  //  QString QSqlResult::lastQuery()
  QString fp_QSqlResult_lastQuery_c0 () const {
    return QSqlResult::lastQuery();
  }

  //  bool QSqlResult::nextResult()
  bool fp_QSqlResult_nextResult_0 () {
    return QSqlResult::nextResult();
  }

  //  QSql::NumericalPrecisionPolicy QSqlResult::numericalPrecisionPolicy()
  qt_gsi::Converter<QSql::NumericalPrecisionPolicy>::target_type fp_QSqlResult_numericalPrecisionPolicy_c0 () const {
    return qt_gsi::CppToQtAdaptor<QSql::NumericalPrecisionPolicy>(QSqlResult::numericalPrecisionPolicy());
  }

  //  void QSqlResult::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy policy)
  void fp_QSqlResult_setNumericalPrecisionPolicy_3429 (const qt_gsi::Converter<QSql::NumericalPrecisionPolicy>::target_type & policy) {
    QSqlResult::setNumericalPrecisionPolicy(qt_gsi::QtToCppAdaptor<QSql::NumericalPrecisionPolicy>(policy).cref());
  }

  //  [adaptor impl] QVariant QSqlResult::handle()
  QVariant cbs_handle_c0_0() const
  {
    return QSqlResult::handle();
  }

  virtual QVariant handle() const
  {
    if (cb_handle_c0_0.can_issue()) {
      return cb_handle_c0_0.issue<QSqlResult_Adaptor, QVariant>(&QSqlResult_Adaptor::cbs_handle_c0_0);
    } else {
      return QSqlResult::handle();
    }
  }

  //  [adaptor impl] void QSqlResult::bindValue(int pos, const QVariant &val, QFlags<QSql::ParamTypeFlag> type)
  void cbs_bindValue_5596_0(int pos, const QVariant &val, const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & type)
  {
    QSqlResult::bindValue(pos, val, qt_gsi::QtToCppAdaptor<QFlags<QSql::ParamTypeFlag> >(type).cref());
  }

  virtual void bindValue(int pos, const QVariant &val, QFlags<QSql::ParamTypeFlag> type)
  {
    if (cb_bindValue_5596_0.can_issue()) {
      cb_bindValue_5596_0.issue<QSqlResult_Adaptor, int, const QVariant &, const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type &>(&QSqlResult_Adaptor::cbs_bindValue_5596_0, pos, val, qt_gsi::CppToQtAdaptor<QFlags<QSql::ParamTypeFlag> >(type));
    } else {
      QSqlResult::bindValue(pos, val, type);
    }
  }

  //  [adaptor impl] void QSqlResult::bindValue(const QString &placeholder, const QVariant &val, QFlags<QSql::ParamTypeFlag> type)
  void cbs_bindValue_6854_0(const QString &placeholder, const QVariant &val, const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & type)
  {
    QSqlResult::bindValue(placeholder, val, qt_gsi::QtToCppAdaptor<QFlags<QSql::ParamTypeFlag> >(type).cref());
  }

  virtual void bindValue(const QString &placeholder, const QVariant &val, QFlags<QSql::ParamTypeFlag> type)
  {
    if (cb_bindValue_6854_0.can_issue()) {
      cb_bindValue_6854_0.issue<QSqlResult_Adaptor, const QString &, const QVariant &, const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type &>(&QSqlResult_Adaptor::cbs_bindValue_6854_0, placeholder, val, qt_gsi::CppToQtAdaptor<QFlags<QSql::ParamTypeFlag> >(type));
    } else {
      QSqlResult::bindValue(placeholder, val, type);
    }
  }

  //  [adaptor impl] QVariant QSqlResult::data(int i)
  QVariant cbs_data_767_0(int i)
  {
    throw qt_gsi::AbstractMethodCalledException("data");
  }

  virtual QVariant data(int i)
  {
    if (cb_data_767_0.can_issue()) {
      return cb_data_767_0.issue<QSqlResult_Adaptor, QVariant, int>(&QSqlResult_Adaptor::cbs_data_767_0, i);
    } else {
      throw qt_gsi::AbstractMethodCalledException("data");
    }
  }

  //  [adaptor impl] bool QSqlResult::exec()
  bool cbs_exec_0_0()
  {
    return QSqlResult::exec();
  }

  virtual bool exec()
  {
    if (cb_exec_0_0.can_issue()) {
      return cb_exec_0_0.issue<QSqlResult_Adaptor, bool>(&QSqlResult_Adaptor::cbs_exec_0_0);
    } else {
      return QSqlResult::exec();
    }
  }

  //  [adaptor impl] bool QSqlResult::fetch(int i)
  bool cbs_fetch_767_0(int i)
  {
    throw qt_gsi::AbstractMethodCalledException("fetch");
  }

  virtual bool fetch(int i)
  {
    if (cb_fetch_767_0.can_issue()) {
      return cb_fetch_767_0.issue<QSqlResult_Adaptor, bool, int>(&QSqlResult_Adaptor::cbs_fetch_767_0, i);
    } else {
      throw qt_gsi::AbstractMethodCalledException("fetch");
    }
  }

  //  [adaptor impl] bool QSqlResult::fetchFirst()
  bool cbs_fetchFirst_0_0()
  {
    throw qt_gsi::AbstractMethodCalledException("fetchFirst");
  }

  virtual bool fetchFirst()
  {
    if (cb_fetchFirst_0_0.can_issue()) {
      return cb_fetchFirst_0_0.issue<QSqlResult_Adaptor, bool>(&QSqlResult_Adaptor::cbs_fetchFirst_0_0);
    } else {
      throw qt_gsi::AbstractMethodCalledException("fetchFirst");
    }
  }

  //  [adaptor impl] bool QSqlResult::fetchLast()
  bool cbs_fetchLast_0_0()
  {
    throw qt_gsi::AbstractMethodCalledException("fetchLast");
  }

  virtual bool fetchLast()
  {
    if (cb_fetchLast_0_0.can_issue()) {
      return cb_fetchLast_0_0.issue<QSqlResult_Adaptor, bool>(&QSqlResult_Adaptor::cbs_fetchLast_0_0);
    } else {
      throw qt_gsi::AbstractMethodCalledException("fetchLast");
    }
  }

  //  [adaptor impl] bool QSqlResult::fetchNext()
  bool cbs_fetchNext_0_0()
  {
    return QSqlResult::fetchNext();
  }

  virtual bool fetchNext()
  {
    if (cb_fetchNext_0_0.can_issue()) {
      return cb_fetchNext_0_0.issue<QSqlResult_Adaptor, bool>(&QSqlResult_Adaptor::cbs_fetchNext_0_0);
    } else {
      return QSqlResult::fetchNext();
    }
  }

  //  [adaptor impl] bool QSqlResult::fetchPrevious()
  bool cbs_fetchPrevious_0_0()
  {
    return QSqlResult::fetchPrevious();
  }

  virtual bool fetchPrevious()
  {
    if (cb_fetchPrevious_0_0.can_issue()) {
      return cb_fetchPrevious_0_0.issue<QSqlResult_Adaptor, bool>(&QSqlResult_Adaptor::cbs_fetchPrevious_0_0);
    } else {
      return QSqlResult::fetchPrevious();
    }
  }

  //  [adaptor impl] bool QSqlResult::isNull(int i)
  bool cbs_isNull_767_0(int i)
  {
    throw qt_gsi::AbstractMethodCalledException("isNull");
  }

  virtual bool isNull(int i)
  {
    if (cb_isNull_767_0.can_issue()) {
      return cb_isNull_767_0.issue<QSqlResult_Adaptor, bool, int>(&QSqlResult_Adaptor::cbs_isNull_767_0, i);
    } else {
      throw qt_gsi::AbstractMethodCalledException("isNull");
    }
  }

  //  [adaptor impl] QVariant QSqlResult::lastInsertId()
  QVariant cbs_lastInsertId_c0_0() const
  {
    return QSqlResult::lastInsertId();
  }

  virtual QVariant lastInsertId() const
  {
    if (cb_lastInsertId_c0_0.can_issue()) {
      return cb_lastInsertId_c0_0.issue<QSqlResult_Adaptor, QVariant>(&QSqlResult_Adaptor::cbs_lastInsertId_c0_0);
    } else {
      return QSqlResult::lastInsertId();
    }
  }

  //  [adaptor impl] int QSqlResult::numRowsAffected()
  int cbs_numRowsAffected_0_0()
  {
    throw qt_gsi::AbstractMethodCalledException("numRowsAffected");
  }

  virtual int numRowsAffected()
  {
    if (cb_numRowsAffected_0_0.can_issue()) {
      return cb_numRowsAffected_0_0.issue<QSqlResult_Adaptor, int>(&QSqlResult_Adaptor::cbs_numRowsAffected_0_0);
    } else {
      throw qt_gsi::AbstractMethodCalledException("numRowsAffected");
    }
  }

  //  [adaptor impl] bool QSqlResult::prepare(const QString &query)
  bool cbs_prepare_2025_0(const QString &query)
  {
    return QSqlResult::prepare(query);
  }

  virtual bool prepare(const QString &query)
  {
    if (cb_prepare_2025_0.can_issue()) {
      return cb_prepare_2025_0.issue<QSqlResult_Adaptor, bool, const QString &>(&QSqlResult_Adaptor::cbs_prepare_2025_0, query);
    } else {
      return QSqlResult::prepare(query);
    }
  }

  //  [adaptor impl] QSqlRecord QSqlResult::record()
  QSqlRecord cbs_record_c0_0() const
  {
    return QSqlResult::record();
  }

  virtual QSqlRecord record() const
  {
    if (cb_record_c0_0.can_issue()) {
      return cb_record_c0_0.issue<QSqlResult_Adaptor, QSqlRecord>(&QSqlResult_Adaptor::cbs_record_c0_0);
    } else {
      return QSqlResult::record();
    }
  }

  //  [adaptor impl] bool QSqlResult::reset(const QString &sqlquery)
  bool cbs_reset_2025_0(const QString &sqlquery)
  {
    throw qt_gsi::AbstractMethodCalledException("reset");
  }

  virtual bool reset(const QString &sqlquery)
  {
    if (cb_reset_2025_0.can_issue()) {
      return cb_reset_2025_0.issue<QSqlResult_Adaptor, bool, const QString &>(&QSqlResult_Adaptor::cbs_reset_2025_0, sqlquery);
    } else {
      throw qt_gsi::AbstractMethodCalledException("reset");
    }
  }

  //  [adaptor impl] bool QSqlResult::savePrepare(const QString &sqlquery)
  bool cbs_savePrepare_2025_0(const QString &sqlquery)
  {
    return QSqlResult::savePrepare(sqlquery);
  }

  virtual bool savePrepare(const QString &sqlquery)
  {
    if (cb_savePrepare_2025_0.can_issue()) {
      return cb_savePrepare_2025_0.issue<QSqlResult_Adaptor, bool, const QString &>(&QSqlResult_Adaptor::cbs_savePrepare_2025_0, sqlquery);
    } else {
      return QSqlResult::savePrepare(sqlquery);
    }
  }

  //  [adaptor impl] void QSqlResult::setActive(bool a)
  void cbs_setActive_864_0(bool a)
  {
    QSqlResult::setActive(a);
  }

  virtual void setActive(bool a)
  {
    if (cb_setActive_864_0.can_issue()) {
      cb_setActive_864_0.issue<QSqlResult_Adaptor, bool>(&QSqlResult_Adaptor::cbs_setActive_864_0, a);
    } else {
      QSqlResult::setActive(a);
    }
  }

  //  [adaptor impl] void QSqlResult::setAt(int at)
  void cbs_setAt_767_0(int at)
  {
    QSqlResult::setAt(at);
  }

  virtual void setAt(int at)
  {
    if (cb_setAt_767_0.can_issue()) {
      cb_setAt_767_0.issue<QSqlResult_Adaptor, int>(&QSqlResult_Adaptor::cbs_setAt_767_0, at);
    } else {
      QSqlResult::setAt(at);
    }
  }

  //  [adaptor impl] void QSqlResult::setForwardOnly(bool forward)
  void cbs_setForwardOnly_864_0(bool forward)
  {
    QSqlResult::setForwardOnly(forward);
  }

  virtual void setForwardOnly(bool forward)
  {
    if (cb_setForwardOnly_864_0.can_issue()) {
      cb_setForwardOnly_864_0.issue<QSqlResult_Adaptor, bool>(&QSqlResult_Adaptor::cbs_setForwardOnly_864_0, forward);
    } else {
      QSqlResult::setForwardOnly(forward);
    }
  }

  //  [adaptor impl] void QSqlResult::setLastError(const QSqlError &e)
  void cbs_setLastError_2220_0(const QSqlError &e)
  {
    QSqlResult::setLastError(e);
  }

  virtual void setLastError(const QSqlError &e)
  {
    if (cb_setLastError_2220_0.can_issue()) {
      cb_setLastError_2220_0.issue<QSqlResult_Adaptor, const QSqlError &>(&QSqlResult_Adaptor::cbs_setLastError_2220_0, e);
    } else {
      QSqlResult::setLastError(e);
    }
  }

  //  [adaptor impl] void QSqlResult::setQuery(const QString &query)
  void cbs_setQuery_2025_0(const QString &query)
  {
    QSqlResult::setQuery(query);
  }

  virtual void setQuery(const QString &query)
  {
    if (cb_setQuery_2025_0.can_issue()) {
      cb_setQuery_2025_0.issue<QSqlResult_Adaptor, const QString &>(&QSqlResult_Adaptor::cbs_setQuery_2025_0, query);
    } else {
      QSqlResult::setQuery(query);
    }
  }

  //  [adaptor impl] void QSqlResult::setSelect(bool s)
  void cbs_setSelect_864_0(bool s)
  {
    QSqlResult::setSelect(s);
  }

  virtual void setSelect(bool s)
  {
    if (cb_setSelect_864_0.can_issue()) {
      cb_setSelect_864_0.issue<QSqlResult_Adaptor, bool>(&QSqlResult_Adaptor::cbs_setSelect_864_0, s);
    } else {
      QSqlResult::setSelect(s);
    }
  }

  //  [adaptor impl] int QSqlResult::size()
  int cbs_size_0_0()
  {
    throw qt_gsi::AbstractMethodCalledException("size");
  }

  virtual int size()
  {
    if (cb_size_0_0.can_issue()) {
      return cb_size_0_0.issue<QSqlResult_Adaptor, int>(&QSqlResult_Adaptor::cbs_size_0_0);
    } else {
      throw qt_gsi::AbstractMethodCalledException("size");
    }
  }

  //  [adaptor impl] void QSqlResult::virtual_hook(int id, void *data)
  void cbs_virtual_hook_1715_0(int id, void *data)
  {
    QSqlResult::virtual_hook(id, data);
  }

  virtual void virtual_hook(int id, void *data)
  {
    if (cb_virtual_hook_1715_0.can_issue()) {
      cb_virtual_hook_1715_0.issue<QSqlResult_Adaptor, int, void *>(&QSqlResult_Adaptor::cbs_virtual_hook_1715_0, id, data);
    } else {
      QSqlResult::virtual_hook(id, data);
    }
  }

  gsi::Callback cb_handle_c0_0;
  gsi::Callback cb_bindValue_5596_0;
  gsi::Callback cb_bindValue_6854_0;
  gsi::Callback cb_data_767_0;
  gsi::Callback cb_exec_0_0;
  gsi::Callback cb_fetch_767_0;
  gsi::Callback cb_fetchFirst_0_0;
  gsi::Callback cb_fetchLast_0_0;
  gsi::Callback cb_fetchNext_0_0;
  gsi::Callback cb_fetchPrevious_0_0;
  gsi::Callback cb_isNull_767_0;
  gsi::Callback cb_lastInsertId_c0_0;
  gsi::Callback cb_numRowsAffected_0_0;
  gsi::Callback cb_prepare_2025_0;
  gsi::Callback cb_record_c0_0;
  gsi::Callback cb_reset_2025_0;
  gsi::Callback cb_savePrepare_2025_0;
  gsi::Callback cb_setActive_864_0;
  gsi::Callback cb_setAt_767_0;
  gsi::Callback cb_setForwardOnly_864_0;
  gsi::Callback cb_setLastError_2220_0;
  gsi::Callback cb_setQuery_2025_0;
  gsi::Callback cb_setSelect_864_0;
  gsi::Callback cb_size_0_0;
  gsi::Callback cb_virtual_hook_1715_0;
};

QSqlResult_Adaptor::~QSqlResult_Adaptor() { }

// void QSqlResult::addBindValue(const QVariant &val, QFlags<QSql::ParamTypeFlag> type)

static void _init_fp_addBindValue_4937 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("val");
  decl->add_arg<const QVariant & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("type");
  decl->add_arg<const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & > (argspec_1);
  decl->set_return<void > ();
}

static void _call_fp_addBindValue_4937 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  const QVariant &arg1 = args.read<const QVariant & > ();
  const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & arg2 = args.read<const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & > ();
  ((QSqlResult_Adaptor *)cls)->fp_QSqlResult_addBindValue_4937 (arg1, arg2);
}

static qt_gsi::GenericMethod*_create_fp_addBindValue_4937 ()
{
  return new qt_gsi::GenericMethod("*addBindValue", "@brief Method void QSqlResult::addBindValue(const QVariant &val, QFlags<QSql::ParamTypeFlag> type)\nThis method is protected and can only be called from inside a derived class.", false, &_init_fp_addBindValue_4937, &_call_fp_addBindValue_4937);
}


// int QSqlResult::at()

static void _init_fp_at_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<int > ();
}

static void _call_fp_at_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<int > ((int)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_at_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_at_c0 ()
{
  return new qt_gsi::GenericMethod("*at", "@brief Method int QSqlResult::at()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_at_c0, &_call_fp_at_c0);
}


// QFlags<QSql::ParamTypeFlag> QSqlResult::bindValueType(const QString &placeholder)

static void _init_fp_bindValueType_c2025 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("placeholder");
  decl->add_arg<const QString & > (argspec_0);
  decl->set_return<qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type > ();
}

static void _call_fp_bindValueType_c2025 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  const QString &arg1 = args.read<const QString & > ();
  ret.write<qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type > ((qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_bindValueType_c2025 (arg1));
}

static qt_gsi::GenericMethod*_create_fp_bindValueType_c2025 ()
{
  return new qt_gsi::GenericMethod("*bindValueType", "@brief Method QFlags<QSql::ParamTypeFlag> QSqlResult::bindValueType(const QString &placeholder)\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_bindValueType_c2025, &_call_fp_bindValueType_c2025);
}


// QFlags<QSql::ParamTypeFlag> QSqlResult::bindValueType(int pos)

static void _init_fp_bindValueType_c767 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("pos");
  decl->add_arg<int > (argspec_0);
  decl->set_return<qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type > ();
}

static void _call_fp_bindValueType_c767 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  int arg1 = args.read<int > ();
  ret.write<qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type > ((qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_bindValueType_c767 (arg1));
}

static qt_gsi::GenericMethod*_create_fp_bindValueType_c767 ()
{
  return new qt_gsi::GenericMethod("*bindValueType", "@brief Method QFlags<QSql::ParamTypeFlag> QSqlResult::bindValueType(int pos)\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_bindValueType_c767, &_call_fp_bindValueType_c767);
}


// QSqlResult::BindingSyntax QSqlResult::bindingSyntax()

static void _init_fp_bindingSyntax_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<unsigned int > ();
}

static void _call_fp_bindingSyntax_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<unsigned int > ((unsigned int)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_bindingSyntax_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_bindingSyntax_c0 ()
{
  return new qt_gsi::GenericMethod("*bindingSyntax", "@brief Method QSqlResult::BindingSyntax QSqlResult::bindingSyntax()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_bindingSyntax_c0, &_call_fp_bindingSyntax_c0);
}


// QVariant QSqlResult::boundValue(const QString &placeholder)

static void _init_fp_boundValue_c2025 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("placeholder");
  decl->add_arg<const QString & > (argspec_0);
  decl->set_return<QVariant > ();
}

static void _call_fp_boundValue_c2025 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  const QString &arg1 = args.read<const QString & > ();
  ret.write<QVariant > ((QVariant)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_boundValue_c2025 (arg1));
}

static qt_gsi::GenericMethod*_create_fp_boundValue_c2025 ()
{
  return new qt_gsi::GenericMethod("*boundValue", "@brief Method QVariant QSqlResult::boundValue(const QString &placeholder)\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_boundValue_c2025, &_call_fp_boundValue_c2025);
}


// QVariant QSqlResult::boundValue(int pos)

static void _init_fp_boundValue_c767 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("pos");
  decl->add_arg<int > (argspec_0);
  decl->set_return<QVariant > ();
}

static void _call_fp_boundValue_c767 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  int arg1 = args.read<int > ();
  ret.write<QVariant > ((QVariant)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_boundValue_c767 (arg1));
}

static qt_gsi::GenericMethod*_create_fp_boundValue_c767 ()
{
  return new qt_gsi::GenericMethod("*boundValue", "@brief Method QVariant QSqlResult::boundValue(int pos)\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_boundValue_c767, &_call_fp_boundValue_c767);
}


// int QSqlResult::boundValueCount()

static void _init_fp_boundValueCount_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<int > ();
}

static void _call_fp_boundValueCount_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<int > ((int)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_boundValueCount_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_boundValueCount_c0 ()
{
  return new qt_gsi::GenericMethod("*boundValueCount", "@brief Method int QSqlResult::boundValueCount()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_boundValueCount_c0, &_call_fp_boundValueCount_c0);
}


// QString QSqlResult::boundValueName(int pos)

static void _init_fp_boundValueName_c767 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("pos");
  decl->add_arg<int > (argspec_0);
  decl->set_return<QString > ();
}

static void _call_fp_boundValueName_c767 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  int arg1 = args.read<int > ();
  ret.write<QString > ((QString)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_boundValueName_c767 (arg1));
}

static qt_gsi::GenericMethod*_create_fp_boundValueName_c767 ()
{
  return new qt_gsi::GenericMethod("*boundValueName", "@brief Method QString QSqlResult::boundValueName(int pos)\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_boundValueName_c767, &_call_fp_boundValueName_c767);
}


// QVector<QVariant> &QSqlResult::boundValues()

static void _init_fp_boundValues_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<qt_gsi::Converter<QVector<QVariant> >::target_type > ();
}

static void _call_fp_boundValues_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<qt_gsi::Converter<QVector<QVariant> >::target_type > ((qt_gsi::Converter<QVector<QVariant> >::target_type)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_boundValues_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_boundValues_c0 ()
{
  return new qt_gsi::GenericMethod("*boundValues", "@brief Method QVector<QVariant> &QSqlResult::boundValues()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_boundValues_c0, &_call_fp_boundValues_c0);
}


// void QSqlResult::clear()

static void _init_fp_clear_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<void > ();
}

static void _call_fp_clear_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ((QSqlResult_Adaptor *)cls)->fp_QSqlResult_clear_0 ();
}

static qt_gsi::GenericMethod*_create_fp_clear_0 ()
{
  return new qt_gsi::GenericMethod("*clear", "@brief Method void QSqlResult::clear()\nThis method is protected and can only be called from inside a derived class.", false, &_init_fp_clear_0, &_call_fp_clear_0);
}


// void QSqlResult::detachFromResultSet()

static void _init_fp_detachFromResultSet_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<void > ();
}

static void _call_fp_detachFromResultSet_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ((QSqlResult_Adaptor *)cls)->fp_QSqlResult_detachFromResultSet_0 ();
}

static qt_gsi::GenericMethod*_create_fp_detachFromResultSet_0 ()
{
  return new qt_gsi::GenericMethod("*detachFromResultSet", "@brief Method void QSqlResult::detachFromResultSet()\nThis method is protected and can only be called from inside a derived class.", false, &_init_fp_detachFromResultSet_0, &_call_fp_detachFromResultSet_0);
}


// const QSqlDriver *QSqlResult::driver()

static void _init_fp_driver_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<const QSqlDriver * > ();
}

static void _call_fp_driver_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<const QSqlDriver * > ((const QSqlDriver *)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_driver_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_driver_c0 ()
{
  return new qt_gsi::GenericMethod("*driver", "@brief Method const QSqlDriver *QSqlResult::driver()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_driver_c0, &_call_fp_driver_c0);
}


// bool QSqlResult::execBatch(bool arrayBind)

static void _init_fp_execBatch_864 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("arrayBind", true, "false");
  decl->add_arg<bool > (argspec_0);
  decl->set_return<bool > ();
}

static void _call_fp_execBatch_864 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  bool arg1 = args ? args.read<bool > () : (bool)(false);
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_execBatch_864 (arg1));
}

static qt_gsi::GenericMethod*_create_fp_execBatch_864 ()
{
  return new qt_gsi::GenericMethod("*execBatch", "@brief Method bool QSqlResult::execBatch(bool arrayBind)\nThis method is protected and can only be called from inside a derived class.", false, &_init_fp_execBatch_864, &_call_fp_execBatch_864);
}


// QString QSqlResult::executedQuery()

static void _init_fp_executedQuery_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QString > ();
}

static void _call_fp_executedQuery_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<QString > ((QString)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_executedQuery_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_executedQuery_c0 ()
{
  return new qt_gsi::GenericMethod("*executedQuery", "@brief Method QString QSqlResult::executedQuery()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_executedQuery_c0, &_call_fp_executedQuery_c0);
}


// bool QSqlResult::hasOutValues()

static void _init_fp_hasOutValues_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_fp_hasOutValues_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_hasOutValues_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_hasOutValues_c0 ()
{
  return new qt_gsi::GenericMethod("*hasOutValues", "@brief Method bool QSqlResult::hasOutValues()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_hasOutValues_c0, &_call_fp_hasOutValues_c0);
}


// bool QSqlResult::isActive()

static void _init_fp_isActive_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_fp_isActive_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_isActive_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_isActive_c0 ()
{
  return new qt_gsi::GenericMethod("*isActive", "@brief Method bool QSqlResult::isActive()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_isActive_c0, &_call_fp_isActive_c0);
}


// bool QSqlResult::isForwardOnly()

static void _init_fp_isForwardOnly_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_fp_isForwardOnly_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_isForwardOnly_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_isForwardOnly_c0 ()
{
  return new qt_gsi::GenericMethod("*isForwardOnly", "@brief Method bool QSqlResult::isForwardOnly()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_isForwardOnly_c0, &_call_fp_isForwardOnly_c0);
}


// bool QSqlResult::isSelect()

static void _init_fp_isSelect_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_fp_isSelect_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_isSelect_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_isSelect_c0 ()
{
  return new qt_gsi::GenericMethod("*isSelect", "@brief Method bool QSqlResult::isSelect()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_isSelect_c0, &_call_fp_isSelect_c0);
}


// bool QSqlResult::isValid()

static void _init_fp_isValid_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_fp_isValid_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_isValid_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_isValid_c0 ()
{
  return new qt_gsi::GenericMethod("*isValid", "@brief Method bool QSqlResult::isValid()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_isValid_c0, &_call_fp_isValid_c0);
}


// QSqlError QSqlResult::lastError()

static void _init_fp_lastError_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QSqlError > ();
}

static void _call_fp_lastError_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<QSqlError > ((QSqlError)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_lastError_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_lastError_c0 ()
{
  return new qt_gsi::GenericMethod("*lastError", "@brief Method QSqlError QSqlResult::lastError()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_lastError_c0, &_call_fp_lastError_c0);
}


// QString QSqlResult::lastQuery()

static void _init_fp_lastQuery_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QString > ();
}

static void _call_fp_lastQuery_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<QString > ((QString)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_lastQuery_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_lastQuery_c0 ()
{
  return new qt_gsi::GenericMethod("*lastQuery", "@brief Method QString QSqlResult::lastQuery()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_lastQuery_c0, &_call_fp_lastQuery_c0);
}


// bool QSqlResult::nextResult()

static void _init_fp_nextResult_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_fp_nextResult_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_nextResult_0 ());
}

static qt_gsi::GenericMethod*_create_fp_nextResult_0 ()
{
  return new qt_gsi::GenericMethod("*nextResult", "@brief Method bool QSqlResult::nextResult()\nThis method is protected and can only be called from inside a derived class.", false, &_init_fp_nextResult_0, &_call_fp_nextResult_0);
}


// QSql::NumericalPrecisionPolicy QSqlResult::numericalPrecisionPolicy()

static void _init_fp_numericalPrecisionPolicy_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<qt_gsi::Converter<QSql::NumericalPrecisionPolicy>::target_type > ();
}

static void _call_fp_numericalPrecisionPolicy_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<qt_gsi::Converter<QSql::NumericalPrecisionPolicy>::target_type > ((qt_gsi::Converter<QSql::NumericalPrecisionPolicy>::target_type)((QSqlResult_Adaptor *)cls)->fp_QSqlResult_numericalPrecisionPolicy_c0 ());
}

static qt_gsi::GenericMethod*_create_fp_numericalPrecisionPolicy_c0 ()
{
  return new qt_gsi::GenericMethod("*numericalPrecisionPolicy", "@brief Method QSql::NumericalPrecisionPolicy QSqlResult::numericalPrecisionPolicy()\nThis method is protected and can only be called from inside a derived class.", true, &_init_fp_numericalPrecisionPolicy_c0, &_call_fp_numericalPrecisionPolicy_c0);
}


// void QSqlResult::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy policy)

static void _init_fp_setNumericalPrecisionPolicy_3429 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("policy");
  decl->add_arg<const qt_gsi::Converter<QSql::NumericalPrecisionPolicy>::target_type & > (argspec_0);
  decl->set_return<void > ();
}

static void _call_fp_setNumericalPrecisionPolicy_3429 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  const qt_gsi::Converter<QSql::NumericalPrecisionPolicy>::target_type & arg1 = args.read<const qt_gsi::Converter<QSql::NumericalPrecisionPolicy>::target_type & > ();
  ((QSqlResult_Adaptor *)cls)->fp_QSqlResult_setNumericalPrecisionPolicy_3429 (arg1);
}

static qt_gsi::GenericMethod*_create_fp_setNumericalPrecisionPolicy_3429 ()
{
  return new qt_gsi::GenericMethod("*setNumericalPrecisionPolicy", "@brief Method void QSqlResult::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy policy)\nThis method is protected and can only be called from inside a derived class.", false, &_init_fp_setNumericalPrecisionPolicy_3429, &_call_fp_setNumericalPrecisionPolicy_3429);
}


// QVariant QSqlResult::handle()

static void _init_cbs_handle_c0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QVariant > ();
}

static void _call_cbs_handle_c0_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<QVariant > ((QVariant)((QSqlResult_Adaptor *)cls)->cbs_handle_c0_0 ());
}

static void _set_callback_cbs_handle_c0_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_handle_c0_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_handle_c0_0 ()
{
  return new qt_gsi::GenericMethod ("handle", "@hide", true, &_init_cbs_handle_c0_0, &_call_cbs_handle_c0_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_handle_c0_0 ()
{
  return new qt_gsi::GenericMethod ("handle", "@brief Virtual method QVariant QSqlResult::handle()\nThis method can be reimplemented in a derived class.", true, &_init_cbs_handle_c0_0, &_call_cbs_handle_c0_0, &_set_callback_cbs_handle_c0_0);
}


// void QSqlResult::bindValue(int pos, const QVariant &val, QFlags<QSql::ParamTypeFlag> type)

static void _init_cbs_bindValue_5596_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("pos");
  decl->add_arg<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("val");
  decl->add_arg<const QVariant & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("type");
  decl->add_arg<const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & > (argspec_2);
  decl->set_return<void > ();
}

static void _call_cbs_bindValue_5596_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  int arg1 = args.read<int > ();
  const QVariant &arg2 = args.read<const QVariant & > ();
  const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & arg3 = args.read<const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & > ();
  ((QSqlResult_Adaptor *)cls)->cbs_bindValue_5596_0 (arg1, arg2, arg3);
}

static void _set_callback_cbs_bindValue_5596_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_bindValue_5596_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_bindValue_5596_0 ()
{
  return new qt_gsi::GenericMethod ("*bindValue", "@hide", false, &_init_cbs_bindValue_5596_0, &_call_cbs_bindValue_5596_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_bindValue_5596_0 ()
{
  return new qt_gsi::GenericMethod ("*bindValue", "@brief Virtual method void QSqlResult::bindValue(int pos, const QVariant &val, QFlags<QSql::ParamTypeFlag> type)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_bindValue_5596_0, &_call_cbs_bindValue_5596_0, &_set_callback_cbs_bindValue_5596_0);
}


// void QSqlResult::bindValue(const QString &placeholder, const QVariant &val, QFlags<QSql::ParamTypeFlag> type)

static void _init_cbs_bindValue_6854_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("placeholder");
  decl->add_arg<const QString & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("val");
  decl->add_arg<const QVariant & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("type");
  decl->add_arg<const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & > (argspec_2);
  decl->set_return<void > ();
}

static void _call_cbs_bindValue_6854_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  const QString &arg1 = args.read<const QString & > ();
  const QVariant &arg2 = args.read<const QVariant & > ();
  const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & arg3 = args.read<const qt_gsi::Converter<QFlags<QSql::ParamTypeFlag> >::target_type & > ();
  ((QSqlResult_Adaptor *)cls)->cbs_bindValue_6854_0 (arg1, arg2, arg3);
}

static void _set_callback_cbs_bindValue_6854_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_bindValue_6854_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_bindValue_6854_0 ()
{
  return new qt_gsi::GenericMethod ("*bindValue", "@hide", false, &_init_cbs_bindValue_6854_0, &_call_cbs_bindValue_6854_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_bindValue_6854_0 ()
{
  return new qt_gsi::GenericMethod ("*bindValue", "@brief Virtual method void QSqlResult::bindValue(const QString &placeholder, const QVariant &val, QFlags<QSql::ParamTypeFlag> type)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_bindValue_6854_0, &_call_cbs_bindValue_6854_0, &_set_callback_cbs_bindValue_6854_0);
}


// QVariant QSqlResult::data(int i)

static void _init_cbs_data_767_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("i");
  decl->add_arg<int > (argspec_0);
  decl->set_return<QVariant > ();
}

static void _call_cbs_data_767_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  int arg1 = args.read<int > ();
  ret.write<QVariant > ((QVariant)((QSqlResult_Adaptor *)cls)->cbs_data_767_0 (arg1));
}

static void _set_callback_cbs_data_767_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_data_767_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_data_767_0 ()
{
  return new qt_gsi::GenericMethod ("*data", "@hide", false, &_init_cbs_data_767_0, &_call_cbs_data_767_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_data_767_0 ()
{
  return new qt_gsi::GenericMethod ("*data", "@brief Virtual method QVariant QSqlResult::data(int i)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_data_767_0, &_call_cbs_data_767_0, &_set_callback_cbs_data_767_0);
}


// bool QSqlResult::exec()

static void _init_cbs_exec_0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_cbs_exec_0_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->cbs_exec_0_0 ());
}

static void _set_callback_cbs_exec_0_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_exec_0_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_exec_0_0 ()
{
  return new qt_gsi::GenericMethod ("*exec", "@hide", false, &_init_cbs_exec_0_0, &_call_cbs_exec_0_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_exec_0_0 ()
{
  return new qt_gsi::GenericMethod ("*exec", "@brief Virtual method bool QSqlResult::exec()\nThis method can be reimplemented in a derived class.", false, &_init_cbs_exec_0_0, &_call_cbs_exec_0_0, &_set_callback_cbs_exec_0_0);
}


// bool QSqlResult::fetch(int i)

static void _init_cbs_fetch_767_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("i");
  decl->add_arg<int > (argspec_0);
  decl->set_return<bool > ();
}

static void _call_cbs_fetch_767_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  int arg1 = args.read<int > ();
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->cbs_fetch_767_0 (arg1));
}

static void _set_callback_cbs_fetch_767_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_fetch_767_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_fetch_767_0 ()
{
  return new qt_gsi::GenericMethod ("*fetch", "@hide", false, &_init_cbs_fetch_767_0, &_call_cbs_fetch_767_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_fetch_767_0 ()
{
  return new qt_gsi::GenericMethod ("*fetch", "@brief Virtual method bool QSqlResult::fetch(int i)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_fetch_767_0, &_call_cbs_fetch_767_0, &_set_callback_cbs_fetch_767_0);
}


// bool QSqlResult::fetchFirst()

static void _init_cbs_fetchFirst_0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_cbs_fetchFirst_0_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->cbs_fetchFirst_0_0 ());
}

static void _set_callback_cbs_fetchFirst_0_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_fetchFirst_0_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_fetchFirst_0_0 ()
{
  return new qt_gsi::GenericMethod ("*fetchFirst", "@hide", false, &_init_cbs_fetchFirst_0_0, &_call_cbs_fetchFirst_0_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_fetchFirst_0_0 ()
{
  return new qt_gsi::GenericMethod ("*fetchFirst", "@brief Virtual method bool QSqlResult::fetchFirst()\nThis method can be reimplemented in a derived class.", false, &_init_cbs_fetchFirst_0_0, &_call_cbs_fetchFirst_0_0, &_set_callback_cbs_fetchFirst_0_0);
}


// bool QSqlResult::fetchLast()

static void _init_cbs_fetchLast_0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_cbs_fetchLast_0_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->cbs_fetchLast_0_0 ());
}

static void _set_callback_cbs_fetchLast_0_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_fetchLast_0_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_fetchLast_0_0 ()
{
  return new qt_gsi::GenericMethod ("*fetchLast", "@hide", false, &_init_cbs_fetchLast_0_0, &_call_cbs_fetchLast_0_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_fetchLast_0_0 ()
{
  return new qt_gsi::GenericMethod ("*fetchLast", "@brief Virtual method bool QSqlResult::fetchLast()\nThis method can be reimplemented in a derived class.", false, &_init_cbs_fetchLast_0_0, &_call_cbs_fetchLast_0_0, &_set_callback_cbs_fetchLast_0_0);
}


// bool QSqlResult::fetchNext()

static void _init_cbs_fetchNext_0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_cbs_fetchNext_0_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->cbs_fetchNext_0_0 ());
}

static void _set_callback_cbs_fetchNext_0_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_fetchNext_0_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_fetchNext_0_0 ()
{
  return new qt_gsi::GenericMethod ("*fetchNext", "@hide", false, &_init_cbs_fetchNext_0_0, &_call_cbs_fetchNext_0_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_fetchNext_0_0 ()
{
  return new qt_gsi::GenericMethod ("*fetchNext", "@brief Virtual method bool QSqlResult::fetchNext()\nThis method can be reimplemented in a derived class.", false, &_init_cbs_fetchNext_0_0, &_call_cbs_fetchNext_0_0, &_set_callback_cbs_fetchNext_0_0);
}


// bool QSqlResult::fetchPrevious()

static void _init_cbs_fetchPrevious_0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_cbs_fetchPrevious_0_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->cbs_fetchPrevious_0_0 ());
}

static void _set_callback_cbs_fetchPrevious_0_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_fetchPrevious_0_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_fetchPrevious_0_0 ()
{
  return new qt_gsi::GenericMethod ("*fetchPrevious", "@hide", false, &_init_cbs_fetchPrevious_0_0, &_call_cbs_fetchPrevious_0_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_fetchPrevious_0_0 ()
{
  return new qt_gsi::GenericMethod ("*fetchPrevious", "@brief Virtual method bool QSqlResult::fetchPrevious()\nThis method can be reimplemented in a derived class.", false, &_init_cbs_fetchPrevious_0_0, &_call_cbs_fetchPrevious_0_0, &_set_callback_cbs_fetchPrevious_0_0);
}


// bool QSqlResult::isNull(int i)

static void _init_cbs_isNull_767_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("i");
  decl->add_arg<int > (argspec_0);
  decl->set_return<bool > ();
}

static void _call_cbs_isNull_767_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  int arg1 = args.read<int > ();
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->cbs_isNull_767_0 (arg1));
}

static void _set_callback_cbs_isNull_767_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_isNull_767_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_isNull_767_0 ()
{
  return new qt_gsi::GenericMethod ("*isNull", "@hide", false, &_init_cbs_isNull_767_0, &_call_cbs_isNull_767_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_isNull_767_0 ()
{
  return new qt_gsi::GenericMethod ("*isNull", "@brief Virtual method bool QSqlResult::isNull(int i)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_isNull_767_0, &_call_cbs_isNull_767_0, &_set_callback_cbs_isNull_767_0);
}


// QVariant QSqlResult::lastInsertId()

static void _init_cbs_lastInsertId_c0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QVariant > ();
}

static void _call_cbs_lastInsertId_c0_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<QVariant > ((QVariant)((QSqlResult_Adaptor *)cls)->cbs_lastInsertId_c0_0 ());
}

static void _set_callback_cbs_lastInsertId_c0_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_lastInsertId_c0_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_lastInsertId_c0_0 ()
{
  return new qt_gsi::GenericMethod ("*lastInsertId", "@hide", true, &_init_cbs_lastInsertId_c0_0, &_call_cbs_lastInsertId_c0_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_lastInsertId_c0_0 ()
{
  return new qt_gsi::GenericMethod ("*lastInsertId", "@brief Virtual method QVariant QSqlResult::lastInsertId()\nThis method can be reimplemented in a derived class.", true, &_init_cbs_lastInsertId_c0_0, &_call_cbs_lastInsertId_c0_0, &_set_callback_cbs_lastInsertId_c0_0);
}


// int QSqlResult::numRowsAffected()

static void _init_cbs_numRowsAffected_0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<int > ();
}

static void _call_cbs_numRowsAffected_0_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<int > ((int)((QSqlResult_Adaptor *)cls)->cbs_numRowsAffected_0_0 ());
}

static void _set_callback_cbs_numRowsAffected_0_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_numRowsAffected_0_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_numRowsAffected_0_0 ()
{
  return new qt_gsi::GenericMethod ("*numRowsAffected", "@hide", false, &_init_cbs_numRowsAffected_0_0, &_call_cbs_numRowsAffected_0_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_numRowsAffected_0_0 ()
{
  return new qt_gsi::GenericMethod ("*numRowsAffected", "@brief Virtual method int QSqlResult::numRowsAffected()\nThis method can be reimplemented in a derived class.", false, &_init_cbs_numRowsAffected_0_0, &_call_cbs_numRowsAffected_0_0, &_set_callback_cbs_numRowsAffected_0_0);
}


// bool QSqlResult::prepare(const QString &query)

static void _init_cbs_prepare_2025_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("query");
  decl->add_arg<const QString & > (argspec_0);
  decl->set_return<bool > ();
}

static void _call_cbs_prepare_2025_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  const QString &arg1 = args.read<const QString & > ();
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->cbs_prepare_2025_0 (arg1));
}

static void _set_callback_cbs_prepare_2025_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_prepare_2025_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_prepare_2025_0 ()
{
  return new qt_gsi::GenericMethod ("*prepare", "@hide", false, &_init_cbs_prepare_2025_0, &_call_cbs_prepare_2025_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_prepare_2025_0 ()
{
  return new qt_gsi::GenericMethod ("*prepare", "@brief Virtual method bool QSqlResult::prepare(const QString &query)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_prepare_2025_0, &_call_cbs_prepare_2025_0, &_set_callback_cbs_prepare_2025_0);
}


// QSqlRecord QSqlResult::record()

static void _init_cbs_record_c0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QSqlRecord > ();
}

static void _call_cbs_record_c0_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<QSqlRecord > ((QSqlRecord)((QSqlResult_Adaptor *)cls)->cbs_record_c0_0 ());
}

static void _set_callback_cbs_record_c0_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_record_c0_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_record_c0_0 ()
{
  return new qt_gsi::GenericMethod ("*record", "@hide", true, &_init_cbs_record_c0_0, &_call_cbs_record_c0_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_record_c0_0 ()
{
  return new qt_gsi::GenericMethod ("*record", "@brief Virtual method QSqlRecord QSqlResult::record()\nThis method can be reimplemented in a derived class.", true, &_init_cbs_record_c0_0, &_call_cbs_record_c0_0, &_set_callback_cbs_record_c0_0);
}


// bool QSqlResult::reset(const QString &sqlquery)

static void _init_cbs_reset_2025_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("sqlquery");
  decl->add_arg<const QString & > (argspec_0);
  decl->set_return<bool > ();
}

static void _call_cbs_reset_2025_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  const QString &arg1 = args.read<const QString & > ();
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->cbs_reset_2025_0 (arg1));
}

static void _set_callback_cbs_reset_2025_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_reset_2025_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_reset_2025_0 ()
{
  return new qt_gsi::GenericMethod ("*reset", "@hide", false, &_init_cbs_reset_2025_0, &_call_cbs_reset_2025_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_reset_2025_0 ()
{
  return new qt_gsi::GenericMethod ("*reset", "@brief Virtual method bool QSqlResult::reset(const QString &sqlquery)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_reset_2025_0, &_call_cbs_reset_2025_0, &_set_callback_cbs_reset_2025_0);
}


// bool QSqlResult::savePrepare(const QString &sqlquery)

static void _init_cbs_savePrepare_2025_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("sqlquery");
  decl->add_arg<const QString & > (argspec_0);
  decl->set_return<bool > ();
}

static void _call_cbs_savePrepare_2025_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  const QString &arg1 = args.read<const QString & > ();
  ret.write<bool > ((bool)((QSqlResult_Adaptor *)cls)->cbs_savePrepare_2025_0 (arg1));
}

static void _set_callback_cbs_savePrepare_2025_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_savePrepare_2025_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_savePrepare_2025_0 ()
{
  return new qt_gsi::GenericMethod ("*savePrepare", "@hide", false, &_init_cbs_savePrepare_2025_0, &_call_cbs_savePrepare_2025_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_savePrepare_2025_0 ()
{
  return new qt_gsi::GenericMethod ("*savePrepare", "@brief Virtual method bool QSqlResult::savePrepare(const QString &sqlquery)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_savePrepare_2025_0, &_call_cbs_savePrepare_2025_0, &_set_callback_cbs_savePrepare_2025_0);
}


// void QSqlResult::setActive(bool a)

static void _init_cbs_setActive_864_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("a");
  decl->add_arg<bool > (argspec_0);
  decl->set_return<void > ();
}

static void _call_cbs_setActive_864_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  bool arg1 = args.read<bool > ();
  ((QSqlResult_Adaptor *)cls)->cbs_setActive_864_0 (arg1);
}

static void _set_callback_cbs_setActive_864_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_setActive_864_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_setActive_864_0 ()
{
  return new qt_gsi::GenericMethod ("*setActive", "@hide", false, &_init_cbs_setActive_864_0, &_call_cbs_setActive_864_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_setActive_864_0 ()
{
  return new qt_gsi::GenericMethod ("*setActive", "@brief Virtual method void QSqlResult::setActive(bool a)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_setActive_864_0, &_call_cbs_setActive_864_0, &_set_callback_cbs_setActive_864_0);
}


// void QSqlResult::setAt(int at)

static void _init_cbs_setAt_767_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("at");
  decl->add_arg<int > (argspec_0);
  decl->set_return<void > ();
}

static void _call_cbs_setAt_767_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  int arg1 = args.read<int > ();
  ((QSqlResult_Adaptor *)cls)->cbs_setAt_767_0 (arg1);
}

static void _set_callback_cbs_setAt_767_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_setAt_767_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_setAt_767_0 ()
{
  return new qt_gsi::GenericMethod ("*setAt", "@hide", false, &_init_cbs_setAt_767_0, &_call_cbs_setAt_767_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_setAt_767_0 ()
{
  return new qt_gsi::GenericMethod ("*setAt", "@brief Virtual method void QSqlResult::setAt(int at)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_setAt_767_0, &_call_cbs_setAt_767_0, &_set_callback_cbs_setAt_767_0);
}


// void QSqlResult::setForwardOnly(bool forward)

static void _init_cbs_setForwardOnly_864_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("forward");
  decl->add_arg<bool > (argspec_0);
  decl->set_return<void > ();
}

static void _call_cbs_setForwardOnly_864_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  bool arg1 = args.read<bool > ();
  ((QSqlResult_Adaptor *)cls)->cbs_setForwardOnly_864_0 (arg1);
}

static void _set_callback_cbs_setForwardOnly_864_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_setForwardOnly_864_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_setForwardOnly_864_0 ()
{
  return new qt_gsi::GenericMethod ("*setForwardOnly", "@hide", false, &_init_cbs_setForwardOnly_864_0, &_call_cbs_setForwardOnly_864_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_setForwardOnly_864_0 ()
{
  return new qt_gsi::GenericMethod ("*setForwardOnly", "@brief Virtual method void QSqlResult::setForwardOnly(bool forward)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_setForwardOnly_864_0, &_call_cbs_setForwardOnly_864_0, &_set_callback_cbs_setForwardOnly_864_0);
}


// void QSqlResult::setLastError(const QSqlError &e)

static void _init_cbs_setLastError_2220_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("e");
  decl->add_arg<const QSqlError & > (argspec_0);
  decl->set_return<void > ();
}

static void _call_cbs_setLastError_2220_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  const QSqlError &arg1 = args.read<const QSqlError & > ();
  ((QSqlResult_Adaptor *)cls)->cbs_setLastError_2220_0 (arg1);
}

static void _set_callback_cbs_setLastError_2220_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_setLastError_2220_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_setLastError_2220_0 ()
{
  return new qt_gsi::GenericMethod ("*setLastError", "@hide", false, &_init_cbs_setLastError_2220_0, &_call_cbs_setLastError_2220_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_setLastError_2220_0 ()
{
  return new qt_gsi::GenericMethod ("*setLastError", "@brief Virtual method void QSqlResult::setLastError(const QSqlError &e)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_setLastError_2220_0, &_call_cbs_setLastError_2220_0, &_set_callback_cbs_setLastError_2220_0);
}


// void QSqlResult::setQuery(const QString &query)

static void _init_cbs_setQuery_2025_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("query");
  decl->add_arg<const QString & > (argspec_0);
  decl->set_return<void > ();
}

static void _call_cbs_setQuery_2025_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  const QString &arg1 = args.read<const QString & > ();
  ((QSqlResult_Adaptor *)cls)->cbs_setQuery_2025_0 (arg1);
}

static void _set_callback_cbs_setQuery_2025_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_setQuery_2025_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_setQuery_2025_0 ()
{
  return new qt_gsi::GenericMethod ("*setQuery", "@hide", false, &_init_cbs_setQuery_2025_0, &_call_cbs_setQuery_2025_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_setQuery_2025_0 ()
{
  return new qt_gsi::GenericMethod ("*setQuery", "@brief Virtual method void QSqlResult::setQuery(const QString &query)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_setQuery_2025_0, &_call_cbs_setQuery_2025_0, &_set_callback_cbs_setQuery_2025_0);
}


// void QSqlResult::setSelect(bool s)

static void _init_cbs_setSelect_864_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("s");
  decl->add_arg<bool > (argspec_0);
  decl->set_return<void > ();
}

static void _call_cbs_setSelect_864_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  bool arg1 = args.read<bool > ();
  ((QSqlResult_Adaptor *)cls)->cbs_setSelect_864_0 (arg1);
}

static void _set_callback_cbs_setSelect_864_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_setSelect_864_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_setSelect_864_0 ()
{
  return new qt_gsi::GenericMethod ("*setSelect", "@hide", false, &_init_cbs_setSelect_864_0, &_call_cbs_setSelect_864_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_setSelect_864_0 ()
{
  return new qt_gsi::GenericMethod ("*setSelect", "@brief Virtual method void QSqlResult::setSelect(bool s)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_setSelect_864_0, &_call_cbs_setSelect_864_0, &_set_callback_cbs_setSelect_864_0);
}


// int QSqlResult::size()

static void _init_cbs_size_0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<int > ();
}

static void _call_cbs_size_0_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<int > ((int)((QSqlResult_Adaptor *)cls)->cbs_size_0_0 ());
}

static void _set_callback_cbs_size_0_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_size_0_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_size_0_0 ()
{
  return new qt_gsi::GenericMethod ("*size", "@hide", false, &_init_cbs_size_0_0, &_call_cbs_size_0_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_size_0_0 ()
{
  return new qt_gsi::GenericMethod ("*size", "@brief Virtual method int QSqlResult::size()\nThis method can be reimplemented in a derived class.", false, &_init_cbs_size_0_0, &_call_cbs_size_0_0, &_set_callback_cbs_size_0_0);
}


// void QSqlResult::virtual_hook(int id, void *data)

static void _init_cbs_virtual_hook_1715_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("id");
  decl->add_arg<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("data");
  decl->add_arg<void * > (argspec_1);
  decl->set_return<void > ();
}

static void _call_cbs_virtual_hook_1715_0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  int arg1 = args.read<int > ();
  void *arg2 = args.read<void * > ();
  ((QSqlResult_Adaptor *)cls)->cbs_virtual_hook_1715_0 (arg1, arg2);
}

static void _set_callback_cbs_virtual_hook_1715_0 (void *cls, const gsi::Callback &cb)
{
  ((QSqlResult_Adaptor *)cls)->cb_virtual_hook_1715_0 = cb;
}

static qt_gsi::GenericMethod *_create_cbs_virtual_hook_1715_0 ()
{
  return new qt_gsi::GenericMethod ("*virtual_hook", "@hide", false, &_init_cbs_virtual_hook_1715_0, &_call_cbs_virtual_hook_1715_0);
}

static qt_gsi::GenericMethod *_create_callback_cbs_virtual_hook_1715_0 ()
{
  return new qt_gsi::GenericMethod ("*virtual_hook", "@brief Virtual method void QSqlResult::virtual_hook(int id, void *data)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_virtual_hook_1715_0, &_call_cbs_virtual_hook_1715_0, &_set_callback_cbs_virtual_hook_1715_0);
}


namespace gsi
{

extern gsi::Class<QSqlResult> decl_QSqlResult;

gsi::Class<QSqlResult_Adaptor> decl_QSqlResult_Adaptor (decl_QSqlResult, "QSqlResult",
  gsi::Methods(_create_fp_addBindValue_4937 ()) +
  gsi::Methods(_create_fp_at_c0 ()) +
  gsi::Methods(_create_fp_bindValueType_c2025 ()) +
  gsi::Methods(_create_fp_bindValueType_c767 ()) +
  gsi::Methods(_create_fp_bindingSyntax_c0 ()) +
  gsi::Methods(_create_fp_boundValue_c2025 ()) +
  gsi::Methods(_create_fp_boundValue_c767 ()) +
  gsi::Methods(_create_fp_boundValueCount_c0 ()) +
  gsi::Methods(_create_fp_boundValueName_c767 ()) +
  gsi::Methods(_create_fp_boundValues_c0 ()) +
  gsi::Methods(_create_fp_clear_0 ()) +
  gsi::Methods(_create_fp_detachFromResultSet_0 ()) +
  gsi::Methods(_create_fp_driver_c0 ()) +
  gsi::Methods(_create_fp_execBatch_864 ()) +
  gsi::Methods(_create_fp_executedQuery_c0 ()) +
  gsi::Methods(_create_fp_hasOutValues_c0 ()) +
  gsi::Methods(_create_fp_isActive_c0 ()) +
  gsi::Methods(_create_fp_isForwardOnly_c0 ()) +
  gsi::Methods(_create_fp_isSelect_c0 ()) +
  gsi::Methods(_create_fp_isValid_c0 ()) +
  gsi::Methods(_create_fp_lastError_c0 ()) +
  gsi::Methods(_create_fp_lastQuery_c0 ()) +
  gsi::Methods(_create_fp_nextResult_0 ()) +
  gsi::Methods(_create_fp_numericalPrecisionPolicy_c0 ()) +
  gsi::Methods(_create_fp_setNumericalPrecisionPolicy_3429 ()) +
  gsi::Methods(_create_cbs_handle_c0_0 ()) +
  gsi::Methods(_create_callback_cbs_handle_c0_0 ()) +
  gsi::Methods(_create_cbs_bindValue_5596_0 ()) +
  gsi::Methods(_create_callback_cbs_bindValue_5596_0 ()) +
  gsi::Methods(_create_cbs_bindValue_6854_0 ()) +
  gsi::Methods(_create_callback_cbs_bindValue_6854_0 ()) +
  gsi::Methods(_create_cbs_data_767_0 ()) +
  gsi::Methods(_create_callback_cbs_data_767_0 ()) +
  gsi::Methods(_create_cbs_exec_0_0 ()) +
  gsi::Methods(_create_callback_cbs_exec_0_0 ()) +
  gsi::Methods(_create_cbs_fetch_767_0 ()) +
  gsi::Methods(_create_callback_cbs_fetch_767_0 ()) +
  gsi::Methods(_create_cbs_fetchFirst_0_0 ()) +
  gsi::Methods(_create_callback_cbs_fetchFirst_0_0 ()) +
  gsi::Methods(_create_cbs_fetchLast_0_0 ()) +
  gsi::Methods(_create_callback_cbs_fetchLast_0_0 ()) +
  gsi::Methods(_create_cbs_fetchNext_0_0 ()) +
  gsi::Methods(_create_callback_cbs_fetchNext_0_0 ()) +
  gsi::Methods(_create_cbs_fetchPrevious_0_0 ()) +
  gsi::Methods(_create_callback_cbs_fetchPrevious_0_0 ()) +
  gsi::Methods(_create_cbs_isNull_767_0 ()) +
  gsi::Methods(_create_callback_cbs_isNull_767_0 ()) +
  gsi::Methods(_create_cbs_lastInsertId_c0_0 ()) +
  gsi::Methods(_create_callback_cbs_lastInsertId_c0_0 ()) +
  gsi::Methods(_create_cbs_numRowsAffected_0_0 ()) +
  gsi::Methods(_create_callback_cbs_numRowsAffected_0_0 ()) +
  gsi::Methods(_create_cbs_prepare_2025_0 ()) +
  gsi::Methods(_create_callback_cbs_prepare_2025_0 ()) +
  gsi::Methods(_create_cbs_record_c0_0 ()) +
  gsi::Methods(_create_callback_cbs_record_c0_0 ()) +
  gsi::Methods(_create_cbs_reset_2025_0 ()) +
  gsi::Methods(_create_callback_cbs_reset_2025_0 ()) +
  gsi::Methods(_create_cbs_savePrepare_2025_0 ()) +
  gsi::Methods(_create_callback_cbs_savePrepare_2025_0 ()) +
  gsi::Methods(_create_cbs_setActive_864_0 ()) +
  gsi::Methods(_create_callback_cbs_setActive_864_0 ()) +
  gsi::Methods(_create_cbs_setAt_767_0 ()) +
  gsi::Methods(_create_callback_cbs_setAt_767_0 ()) +
  gsi::Methods(_create_cbs_setForwardOnly_864_0 ()) +
  gsi::Methods(_create_callback_cbs_setForwardOnly_864_0 ()) +
  gsi::Methods(_create_cbs_setLastError_2220_0 ()) +
  gsi::Methods(_create_callback_cbs_setLastError_2220_0 ()) +
  gsi::Methods(_create_cbs_setQuery_2025_0 ()) +
  gsi::Methods(_create_callback_cbs_setQuery_2025_0 ()) +
  gsi::Methods(_create_cbs_setSelect_864_0 ()) +
  gsi::Methods(_create_callback_cbs_setSelect_864_0 ()) +
  gsi::Methods(_create_cbs_size_0_0 ()) +
  gsi::Methods(_create_callback_cbs_size_0_0 ()) +
  gsi::Methods(_create_cbs_virtual_hook_1715_0 ()) +
  gsi::Methods(_create_callback_cbs_virtual_hook_1715_0 ()),
  "@qt\n@brief Binding of QSqlResult");

}

