/*
 * Module code.
 *
 * Generated by SIP 4.16.9
 *
 * Copyright (c) 2015 Riverbank Computing Limited <info@riverbankcomputing.com>
 * 
 * This file is part of PyQt5.
 * 
 * This file may be used under the terms of the GNU General Public License
 * version 3.0 as published by the Free Software Foundation and appearing in
 * the file LICENSE included in the packaging of this file.  Please review the
 * following information to ensure the GNU General Public License version 3.0
 * requirements will be met: http://www.gnu.org/copyleft/gpl.html.
 * 
 * If you do not wish to use this file under the terms of the GPL version 3.0
 * then you may purchase a commercial license.  For more information contact
 * info@riverbankcomputing.com.
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include "sipAPIEnginio.h"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 29 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

/* Define the strings used by this module. */
const char sipStrings_Enginio[] = {
    'E', 'n', 'g', 'i', 'n', 'i', 'o', ':', ':', 'A', 'u', 't', 'h', 'e', 'n', 't', 'i', 'c', 'a', 't', 'i', 'o', 'n', 'S', 't', 'a', 't', 'e', 0,
    'P', 'y', 'Q', 't', '5', '.', 'Q', 't', 'C', 'o', 'r', 'e', '.', 'p', 'y', 'q', 't', 'W', 'r', 'a', 'p', 'p', 'e', 'r', 'T', 'y', 'p', 'e', 0,
    'E', 'n', 'g', 'i', 'n', 'i', 'o', 'O', 'A', 'u', 't', 'h', '2', 'A', 'u', 't', 'h', 'e', 'n', 't', 'i', 'c', 'a', 't', 'i', 'o', 'n', 0,
    'a', 'u', 't', 'h', 'e', 'n', 't', 'i', 'c', 'a', 't', 'i', 'o', 'n', 'S', 't', 'a', 't', 'e', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    's', 'e', 's', 's', 'i', 'o', 'n', 'A', 'u', 't', 'h', 'e', 'n', 't', 'i', 'c', 'a', 't', 'i', 'o', 'n', 'E', 'r', 'r', 'o', 'r', 0,
    'U', 's', 'e', 'r', 'g', 'r', 'o', 'u', 'p', 'M', 'e', 'm', 'b', 'e', 'r', 's', 'O', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'c', 'h', 'a', 'n', 'g', 'e', 'P', 'e', 'r', 's', 'i', 's', 't', 'e', 'n', 't', 'I', 'n', 'd', 'e', 'x', 'L', 'i', 's', 't', 0,
    'E', 'n', 'g', 'i', 'n', 'i', 'o', 'C', 'l', 'i', 'e', 'n', 't', 'C', 'o', 'n', 'n', 'e', 'c', 't', 'i', 'o', 'n', 0,
    'A', 'c', 'c', 'e', 's', 's', 'C', 'o', 'n', 't', 'r', 'o', 'l', 'O', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'A', 'u', 't', 'h', 'e', 'n', 't', 'i', 'c', 'a', 't', 'i', 'o', 'n', 'F', 'a', 'i', 'l', 'u', 'r', 'e', 0,
    'c', 'h', 'a', 'n', 'g', 'e', 'P', 'e', 'r', 's', 'i', 's', 't', 'e', 'n', 't', 'I', 'n', 'd', 'e', 'x', 0,
    's', 'e', 's', 's', 'i', 'o', 'n', 'A', 'u', 't', 'h', 'e', 'n', 't', 'i', 'c', 'a', 't', 'e', 'd', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'D', 'r', 'a', 'g', 'A', 'c', 't', 'i', 'o', 'n', 's', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'D', 'r', 'o', 'p', 'A', 'c', 't', 'i', 'o', 'n', 's', 0,
    'a', 'u', 't', 'h', 'e', 'n', 't', 'i', 'c', 'a', 't', 'i', 'o', 'n', 'S', 't', 'a', 't', 'e', 0,
    'p', 'e', 'r', 's', 'i', 's', 't', 'e', 'n', 't', 'I', 'n', 'd', 'e', 'x', 'L', 'i', 's', 't', 0,
    'E', 'n', 'g', 'i', 'n', 'i', 'o', ':', ':', 'E', 'r', 'r', 'o', 'r', 'T', 'y', 'p', 'e', 0,
    'C', 'u', 's', 't', 'o', 'm', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'R', 'o', 'l', 'e', 0,
    'U', 's', 'e', 'r', 'g', 'r', 'o', 'u', 'p', 'O', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'E', 'n', 'g', 'i', 'n', 'i', 'o', ':', ':', 'O', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'b', 'e', 'g', 'i', 'n', 'R', 'e', 'm', 'o', 'v', 'e', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    'b', 'e', 'g', 'i', 'n', 'I', 'n', 's', 'e', 'r', 't', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    's', 'e', 'r', 'v', 'i', 'c', 'e', 'U', 'r', 'l', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    's', 'e', 's', 's', 'i', 'o', 'n', 'T', 'e', 'r', 'm', 'i', 'n', 'a', 't', 'e', 'd', 0,
    'i', 's', 'S', 'i', 'g', 'n', 'a', 'l', 'C', 'o', 'n', 'n', 'e', 'c', 't', 'e', 'd', 0,
    's', 'e', 'n', 'd', 'e', 'r', 'S', 'i', 'g', 'n', 'a', 'l', 'I', 'n', 'd', 'e', 'x', 0,
    'r', 'e', 's', 'e', 't', 'I', 'n', 't', 'e', 'r', 'n', 'a', 'l', 'D', 'a', 't', 'a', 0,
    's', 'i', 'p', '.', 's', 'i', 'm', 'p', 'l', 'e', 'w', 'r', 'a', 'p', 'p', 'e', 'r', 0,
    'o', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'b', 'a', 'c', 'k', 'e', 'n', 'd', 'I', 'd', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'N', 'o', 't', 'A', 'u', 't', 'h', 'e', 'n', 't', 'i', 'c', 'a', 't', 'e', 'd', 0,
    'd', 'i', 's', 'c', 'o', 'n', 'n', 'e', 'c', 't', 'N', 'o', 't', 'i', 'f', 'y', 0,
    'b', 'e', 'g', 'i', 'n', 'M', 'o', 'v', 'e', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    'e', 'n', 'd', 'R', 'e', 'm', 'o', 'v', 'e', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    'e', 'n', 'd', 'I', 'n', 's', 'e', 'r', 't', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    'p', 'a', 's', 's', 'w', 'o', 'r', 'd', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'E', 'n', 'g', 'i', 'n', 'i', 'o', 'I', 'd', 'e', 'n', 't', 'i', 't', 'y', 0,
    'i', 'd', 'e', 'n', 't', 'i', 't', 'y', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'O', 'b', 'j', 'e', 'c', 't', 'O', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'c', 'a', 'n', 'D', 'r', 'o', 'p', 'M', 'i', 'm', 'e', 'D', 'a', 't', 'a', 0,
    'b', 'e', 'g', 'i', 'n', 'R', 'e', 's', 'e', 't', 'M', 'o', 'd', 'e', 'l', 0,
    'b', 'e', 'g', 'i', 'n', 'R', 'e', 'm', 'o', 'v', 'e', 'R', 'o', 'w', 's', 0,
    'b', 'e', 'g', 'i', 'n', 'I', 'n', 's', 'e', 'r', 't', 'R', 'o', 'w', 's', 0,
    'n', 'e', 't', 'w', 'o', 'r', 'k', 'M', 'a', 'n', 'a', 'g', 'e', 'r', 0,
    'f', 'u', 'l', 'l', 'T', 'e', 'x', 't', 'S', 'e', 'a', 'r', 'c', 'h', 0,
    'J', 's', 'o', 'n', 'O', 'b', 'j', 'e', 'c', 't', 'R', 'o', 'l', 'e', 0,
    'O', 'b', 'j', 'e', 'c', 't', 'T', 'y', 'p', 'e', 'R', 'o', 'l', 'e', 0,
    'A', 'u', 't', 'h', 'e', 'n', 't', 'i', 'c', 'a', 't', 'i', 'n', 'g', 0,
    'e', 'n', 'd', 'M', 'o', 'v', 'e', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    'b', 'a', 'c', 'k', 'e', 'n', 'd', 'S', 't', 'a', 't', 'u', 's', 0,
    'c', 'l', 'i', 'e', 'n', 't', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    's', 'e', 't', 'S', 'e', 'r', 'v', 'i', 'c', 'e', 'U', 'r', 'l', 0,
    'E', 'n', 'g', 'i', 'n', 'i', 'o', 'C', 'l', 'i', 'e', 'n', 't', 0,
    'U', 'p', 'd', 'a', 't', 'e', 'd', 'A', 't', 'R', 'o', 'l', 'e', 0,
    'C', 'r', 'e', 'a', 't', 'e', 'd', 'A', 't', 'R', 'o', 'l', 'e', 0,
    'E', 'n', 'g', 'i', 'n', 'i', 'o', ':', ':', 'R', 'o', 'l', 'e', 0,
    'F', 'i', 'l', 'e', 'O', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'U', 's', 'e', 'r', 'O', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'e', 'n', 'd', 'R', 'e', 's', 'e', 't', 'M', 'o', 'd', 'e', 'l', 0,
    'b', 'e', 'g', 'i', 'n', 'M', 'o', 'v', 'e', 'R', 'o', 'w', 's', 0,
    'e', 'n', 'd', 'R', 'e', 'm', 'o', 'v', 'e', 'R', 'o', 'w', 's', 0,
    'e', 'n', 'd', 'I', 'n', 's', 'e', 'r', 't', 'R', 'o', 'w', 's', 0,
    'r', 'e', 'm', 'o', 'v', 'e', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    'i', 'n', 's', 'e', 'r', 't', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    's', 'e', 't', 'H', 'e', 'a', 'd', 'e', 'r', 'D', 'a', 't', 'a', 0,
    'P', 'y', 'Q', 't', '5', '.', 'E', 'n', 'g', 'i', 'n', 'i', 'o', 0,
    'n', 'e', 't', 'w', 'o', 'r', 'k', 'E', 'r', 'r', 'o', 'r', 0,
    'E', 'n', 'g', 'i', 'n', 'i', 'o', 'R', 'e', 'p', 'l', 'y', 0,
    'q', 'u', 'e', 'r', 'y', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'E', 'n', 'g', 'i', 'n', 'i', 'o', 'M', 'o', 'd', 'e', 'l', 0,
    's', 'e', 't', 'B', 'a', 'c', 'k', 'e', 'n', 'd', 'I', 'd', 0,
    'B', 'a', 'c', 'k', 'e', 'n', 'd', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'e', 't', 'O', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'N', 'e', 't', 'w', 'o', 'r', 'k', 'E', 'r', 'r', 'o', 'r', 0,
    'c', 'a', 'n', 'F', 'e', 't', 'c', 'h', 'M', 'o', 'r', 'e', 0,
    'd', 'r', 'o', 'p', 'M', 'i', 'm', 'e', 'D', 'a', 't', 'a', 0,
    'u', 's', 'e', 'r', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'd', 'o', 'w', 'n', 'l', 'o', 'a', 'd', 'U', 'r', 'l', 0,
    's', 'e', 't', 'I', 'd', 'e', 'n', 't', 'i', 't', 'y', 0,
    's', 'e', 't', 'P', 'a', 's', 's', 'w', 'o', 'r', 'd', 0,
    'c', 'u', 's', 't', 'o', 'm', 'E', 'v', 'e', 'n', 't', 0,
    'e', 'v', 'e', 'n', 't', 'F', 'i', 'l', 't', 'e', 'r', 0,
    'e', 'r', 'r', 'o', 'r', 'S', 't', 'r', 'i', 'n', 'g', 0,
    'e', 'n', 'd', 'M', 'o', 'v', 'e', 'R', 'o', 'w', 's', 0,
    'c', 'r', 'e', 'a', 't', 'e', 'I', 'n', 'd', 'e', 'x', 0,
    'd', 'a', 't', 'a', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    's', 'e', 't', 'I', 't', 'e', 'm', 'D', 'a', 't', 'a', 0,
    's', 'e', 'r', 'v', 'i', 'c', 'e', 'U', 'r', 'l', 0,
    'u', 'p', 'l', 'o', 'a', 'd', 'F', 'i', 'l', 'e', 0,
    'S', 'y', 'n', 'c', 'e', 'd', 'R', 'o', 'l', 'e', 0,
    'i', 's', 'F', 'i', 'n', 'i', 's', 'h', 'e', 'd', 0,
    'c', 'h', 'i', 'l', 'd', 'E', 'v', 'e', 'n', 't', 0,
    't', 'i', 'm', 'e', 'r', 'E', 'v', 'e', 'n', 't', 0,
    'd', 'e', 'c', 'o', 'd', 'e', 'D', 'a', 't', 'a', 0,
    'e', 'n', 'c', 'o', 'd', 'e', 'D', 'a', 't', 'a', 0,
    'r', 'e', 'm', 'o', 'v', 'e', 'R', 'o', 'w', 's', 0,
    'i', 'n', 's', 'e', 'r', 't', 'R', 'o', 'w', 's', 0,
    'h', 'e', 'a', 'd', 'e', 'r', 'D', 'a', 't', 'a', 0,
    'e', 'r', 'r', 'o', 'r', 'T', 'y', 'p', 'e', 0,
    's', 'e', 't', 'C', 'l', 'i', 'e', 'n', 't', 0,
    'b', 'a', 'c', 'k', 'e', 'n', 'd', 'I', 'd', 0,
    'o', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', 0,
    'r', 'e', 'c', 'e', 'i', 'v', 'e', 'r', 's', 0,
    'p', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 0,
    'r', 'o', 'l', 'e', 'N', 'a', 'm', 'e', 's', 0,
    'f', 'e', 't', 'c', 'h', 'M', 'o', 'r', 'e', 0,
    'm', 'i', 'm', 'e', 'T', 'y', 'p', 'e', 's', 0,
    'i', 'd', 'e', 'n', 't', 'i', 't', 'y', 0,
    'p', 'r', 'o', 't', 'o', 'c', 'o', 'l', 0,
    's', 'e', 't', 'Q', 'u', 'e', 'r', 'y', 0,
    'p', 'a', 's', 's', 'w', 'o', 'r', 'd', 0,
    'n', 'a', 'm', 'e', 'T', 'y', 'p', 'e', 0,
    'p', 'r', 'o', 'g', 'r', 'e', 's', 's', 0,
    'm', 'i', 'm', 'e', 'D', 'a', 't', 'a', 0,
    'i', 't', 'e', 'm', 'D', 'a', 't', 'a', 0,
    'r', 'o', 'w', 'C', 'o', 'u', 'n', 't', 0,
    'f', 'i', 'n', 'i', 's', 'h', 'e', 'd', 0,
    'i', 's', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'e', 't', 'U', 's', 'e', 'r', 0,
    'N', 'o', 'E', 'r', 'r', 'o', 'r', 0,
    'f', 'i', 'l', 't', 'e', 'r', 's', 0,
    'e', 'n', 'a', 'b', 'l', 'e', 'd', 0,
    'o', 'p', 't', 'i', 'o', 'n', 's', 0,
    's', 'e', 't', 'D', 'a', 't', 'a', 0,
    's', 'i', 'b', 'l', 'i', 'n', 'g', 0,
    'r', 'e', 'l', 'o', 'a', 'd', 0,
    'c', 'l', 'i', 'e', 'n', 't', 0,
    'u', 'p', 'd', 'a', 't', 'e', 0,
    'I', 'd', 'R', 'o', 'l', 'e', 0,
    'c', 'r', 'e', 'a', 't', 'e', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 0,
    's', 'e', 'n', 'd', 'e', 'r', 0,
    'v', 'a', 'l', 'u', 'e', '9', 0,
    'v', 'a', 'l', 'u', 'e', '8', 0,
    'v', 'a', 'l', 'u', 'e', '7', 0,
    'v', 'a', 'l', 'u', 'e', '6', 0,
    'v', 'a', 'l', 'u', 'e', '5', 0,
    'v', 'a', 'l', 'u', 'e', '4', 0,
    'v', 'a', 'l', 'u', 'e', '3', 0,
    'v', 'a', 'l', 'u', 'e', '2', 0,
    'v', 'a', 'l', 'u', 'e', '1', 0,
    'v', 'a', 'l', 'u', 'e', '0', 0,
    's', 'y', 'm', 'b', 'o', 'l', 0,
    's', 'u', 'f', 'f', 'i', 'x', 0,
    'p', 'r', 'e', 'f', 'i', 'x', 0,
    'd', 'e', 'v', 'i', 'c', 'e', 0,
    'l', 'o', 'c', 'a', 'l', 'e', 0,
    'f', 'o', 'r', 'm', 'a', 't', 0,
    'r', 'e', 'm', 'o', 'v', 'e', 0,
    'a', 'p', 'p', 'e', 'n', 'd', 0,
    'r', 'e', 'v', 'e', 'r', 't', 0,
    's', 'u', 'b', 'm', 'i', 't', 0,
    'o', 'b', 'j', 'e', 'c', 't', 0,
    'p', 'a', 'r', 'e', 'n', 't', 0,
    'q', 'u', 'e', 'r', 'y', 0,
    'e', 'r', 'r', 'o', 'r', 0,
    'm', 'a', 't', 'c', 'h', 0,
    'b', 'u', 'd', 'd', 'y', 0,
    'i', 'n', 'd', 'e', 'x', 0,
    'f', 'l', 'a', 'g', 's', 0,
    'e', 'v', 'e', 'n', 't', 0,
    'm', 's', 'e', 'c', 's', 0,
    'u', 's', 'e', 'r', 0,
    'p', 'o', 'r', 't', 0,
    'm', 'o', 'd', 'e', 0,
    'n', 'a', 'm', 'e', 0,
    'b', 'a', 's', 'e', 0,
    'f', 'r', 'o', 'm', 0,
    's', 'p', 'a', 'n', 0,
    's', 'o', 'r', 't', 0,
    'd', 'a', 't', 'a', 0,
};


/* Convert to a sub-class if possible. */
extern "C" {static const sipTypeDef *sipSubClass_EnginioClient(void **);}
static const sipTypeDef *sipSubClass_EnginioClient(void **sipCppRet)
{
    QObject *sipCpp = reinterpret_cast<QObject *>(*sipCppRet);
    const sipTypeDef *sipType;

#line 32 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginioclient.sip"
    static struct class_graph {
        const char *name;
        sipTypeDef **type;
        int yes, no;
    } graph[] = {
        {sipName_EnginioReply, &sipType_EnginioReply, -1, 1},
        {sipName_EnginioModel, &sipType_EnginioModel, -1, 2},
        {sipName_EnginioClientConnection, &sipType_EnginioClientConnection, 4, 3},
        {sipName_EnginioIdentity, &sipType_EnginioIdentity, 5, -1},
        {sipName_EnginioClient, &sipType_EnginioClient, -1, -1},
        {sipName_EnginioOAuth2Authentication, &sipType_EnginioOAuth2Authentication, -1, -1},
    };
    
    int i = 0;
    
    sipType = NULL;
    
    do
    {
        struct class_graph *cg = &graph[i];
    
        if (cg->name != NULL && sipCpp->inherits(cg->name))
        {
            sipType = *cg->type;
            i = cg->yes;
        }
        else
            i = cg->no;
    }
    while (i >= 0);
#line 246 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

    return sipType;
}
static sipEnumTypeDef enumTypes[] = {
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_Enginio__ErrorType, {0}}, sipNameNr_ErrorType, 0, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_Enginio__Role, {0}}, sipNameNr_Role, 0, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_Enginio__Operation, {0}}, sipNameNr_Operation, 0, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_Enginio__AuthenticationState, {0}}, sipNameNr_AuthenticationState, 0, NULL},
};


/*
 * This defines each type in this module.
 */
static sipTypeDef *typesTable[] = {
    &sipTypeDef_Enginio_Enginio.super.ctd_base,
    &enumTypes[3].etd_base,
    &enumTypes[0].etd_base,
    &enumTypes[2].etd_base,
    &enumTypes[1].etd_base,
    &sipTypeDef_Enginio_EnginioClient.super.ctd_base,
    &sipTypeDef_Enginio_EnginioClientConnection.super.ctd_base,
    &sipTypeDef_Enginio_EnginioIdentity.super.ctd_base,
    &sipTypeDef_Enginio_EnginioModel.super.ctd_base,
    &sipTypeDef_Enginio_EnginioOAuth2Authentication.super.ctd_base,
    &sipTypeDef_Enginio_EnginioReply.super.ctd_base,
};


/* This defines the modules that this module needs to import. */
static sipImportedModuleDef importsTable[] = {
    {"PyQt5.QtCore", 1, NULL},
    {"PyQt5.QtNetwork", -1, NULL},
    {NULL, -1, NULL}
};


/* This defines the class sub-convertors that this module defines. */
static sipSubClassConvertorDef convertorsTable[] = {
    {sipSubClass_EnginioClient, {163, 0, 0}, NULL},
    {NULL, {0, 0, 0}, NULL}
};


/* This defines this module. */
sipExportedModuleDef sipModuleAPI_Enginio = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt5_Enginio,
    0,
    -1,
    sipStrings_Enginio,
    importsTable,
    NULL,
    11,
    typesTable,
    NULL,
    0,
    NULL,
    0,
    NULL,
    NULL,
    NULL,
    convertorsTable,
    {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};


/* The SIP API and the APIs of any imported modules. */
const sipAPIDef *sipAPI_Enginio;
const sipExportedModuleDef *sipModuleAPI_Enginio_QtCore;
const sipExportedModuleDef *sipModuleAPI_Enginio_QtNetwork;

sip_qt_metaobject_func sip_Enginio_qt_metaobject;
sip_qt_metacall_func sip_Enginio_qt_metacall;
sip_qt_metacast_func sip_Enginio_qt_metacast;


/* The Python module initialisation function. */
#if PY_MAJOR_VERSION >= 3
#define SIP_MODULE_ENTRY        PyInit_Enginio
#define SIP_MODULE_TYPE         PyObject *
#define SIP_MODULE_DISCARD(r)   Py_DECREF(r)
#define SIP_MODULE_RETURN(r)    return (r)
#else
#define SIP_MODULE_ENTRY        initEnginio
#define SIP_MODULE_TYPE         void
#define SIP_MODULE_DISCARD(r)
#define SIP_MODULE_RETURN(r)    return
#endif

#if defined(SIP_STATIC_MODULE)
extern "C" SIP_MODULE_TYPE SIP_MODULE_ENTRY()
#else
PyMODINIT_FUNC SIP_MODULE_ENTRY()
#endif
{
    static PyMethodDef sip_methods[] = {
        {0, 0, 0, 0}
    };

#if PY_MAJOR_VERSION >= 3
    static PyModuleDef sip_module_def = {
        PyModuleDef_HEAD_INIT,
        "PyQt5.Enginio",
        NULL,
        -1,
        sip_methods,
        NULL,
        NULL,
        NULL,
        NULL
    };
#endif

    PyObject *sipModule, *sipModuleDict;
    PyObject *sip_sipmod, *sip_capiobj;

    /* Initialise the module and get it's dictionary. */
#if PY_MAJOR_VERSION >= 3
    sipModule = PyModule_Create(&sip_module_def);
#elif PY_VERSION_HEX >= 0x02050000
    sipModule = Py_InitModule(sipName_PyQt5_Enginio, sip_methods);
#else
    sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt5_Enginio), sip_methods);
#endif

    if (sipModule == NULL)
        SIP_MODULE_RETURN(NULL);

    sipModuleDict = PyModule_GetDict(sipModule);

    /* Get the SIP module's API. */
#if PY_VERSION_HEX >= 0x02050000
    sip_sipmod = PyImport_ImportModule(SIP_MODULE_NAME);
#else
    sip_sipmod = PyImport_ImportModule(const_cast<char *>(SIP_MODULE_NAME));
#endif

    if (sip_sipmod == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

    sip_capiobj = PyDict_GetItemString(PyModule_GetDict(sip_sipmod), "_C_API");
    Py_DECREF(sip_sipmod);

#if defined(SIP_USE_PYCAPSULE)
    if (sip_capiobj == NULL || !PyCapsule_CheckExact(sip_capiobj))
#else
    if (sip_capiobj == NULL || !PyCObject_Check(sip_capiobj))
#endif
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

#if defined(SIP_USE_PYCAPSULE)
    sipAPI_Enginio = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, SIP_MODULE_NAME "._C_API"));
#else
    sipAPI_Enginio = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif

#if defined(SIP_USE_PYCAPSULE)
    if (sipAPI_Enginio == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }
#endif

    /* Export the module and publish it's API. */
    if (sipExportModule(&sipModuleAPI_Enginio,SIP_API_MAJOR_NR,SIP_API_MINOR_NR,0) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    sip_Enginio_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
    sip_Enginio_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
    sip_Enginio_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");

    if (!sip_Enginio_qt_metacast)
        Py_FatalError("Unable to import qtcore_qt_metacast");

    /* Initialise the module now all its dependencies have been set up. */
    if (sipInitModule(&sipModuleAPI_Enginio,sipModuleDict) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    /* Get the APIs of the modules that this one is dependent on. */
    sipModuleAPI_Enginio_QtCore = sipModuleAPI_Enginio.em_imports[0].im_module;
    sipModuleAPI_Enginio_QtNetwork = sipModuleAPI_Enginio.em_imports[1].im_module;

    SIP_MODULE_RETURN(sipModule);
}

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginioreply.sip"
#include <enginioreply.h>
#line 457 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 461 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtNetwork/qnetworkreply.sip"
#include <qnetworkreply.h>
#line 464 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginio.sip"
#include <enginio.h>
#line 467 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 24 "sip/QtCore/qjsonobject.sip"
#include <qjsonobject.h>
#line 470 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 473 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 476 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 244 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 479 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 232 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 482 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 485 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 488 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 491 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 32 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 494 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 144 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 497 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 500 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 503 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 506 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 509 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 512 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 515 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"


PyDoc_STRVAR(doc_EnginioReply_data, "EnginioReply.data() -> dict-of-str-QJsonValue");

extern "C" {static PyObject *meth_EnginioReply_data(PyObject *, PyObject *);}
static PyObject *meth_EnginioReply_data(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioReply *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioReply, &sipCpp))
        {
            QJsonObject*sipRes;

            sipRes = new QJsonObject(sipCpp->data());

            return sipConvertFromNewType(sipRes,sipType_QJsonObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioReply, sipName_data, doc_EnginioReply_data);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioReply_errorType, "EnginioReply.errorType() -> Enginio.ErrorType");

extern "C" {static PyObject *meth_EnginioReply_errorType(PyObject *, PyObject *);}
static PyObject *meth_EnginioReply_errorType(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioReply *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioReply, &sipCpp))
        {
            Enginio::ErrorType sipRes;

            sipRes = sipCpp->errorType();

            return sipConvertFromEnum(sipRes,sipType_Enginio_ErrorType);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioReply, sipName_errorType, doc_EnginioReply_errorType);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioReply_networkError, "EnginioReply.networkError() -> QNetworkReply.NetworkError");

extern "C" {static PyObject *meth_EnginioReply_networkError(PyObject *, PyObject *);}
static PyObject *meth_EnginioReply_networkError(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioReply *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioReply, &sipCpp))
        {
            QNetworkReply::NetworkError sipRes;

            sipRes = sipCpp->networkError();

            return sipConvertFromEnum(sipRes,sipType_QNetworkReply_NetworkError);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioReply, sipName_networkError, doc_EnginioReply_networkError);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioReply_errorString, "EnginioReply.errorString() -> str");

extern "C" {static PyObject *meth_EnginioReply_errorString(PyObject *, PyObject *);}
static PyObject *meth_EnginioReply_errorString(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioReply *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioReply, &sipCpp))
        {
            QString*sipRes;

            sipRes = new QString(sipCpp->errorString());

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioReply, sipName_errorString, doc_EnginioReply_errorString);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioReply_backendStatus, "EnginioReply.backendStatus() -> int");

extern "C" {static PyObject *meth_EnginioReply_backendStatus(PyObject *, PyObject *);}
static PyObject *meth_EnginioReply_backendStatus(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioReply *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioReply, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->backendStatus();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioReply, sipName_backendStatus, doc_EnginioReply_backendStatus);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioReply_isError, "EnginioReply.isError() -> bool");

extern "C" {static PyObject *meth_EnginioReply_isError(PyObject *, PyObject *);}
static PyObject *meth_EnginioReply_isError(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioReply *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioReply, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isError();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioReply, sipName_isError, doc_EnginioReply_isError);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioReply_isFinished, "EnginioReply.isFinished() -> bool");

extern "C" {static PyObject *meth_EnginioReply_isFinished(PyObject *, PyObject *);}
static PyObject *meth_EnginioReply_isFinished(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioReply *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioReply, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isFinished();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioReply, sipName_isFinished, doc_EnginioReply_isFinished);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_EnginioReply(void *, const sipTypeDef *);}
static void *cast_EnginioReply(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_EnginioReply)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(EnginioReply *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_EnginioReply(void *, int);}
static void release_EnginioReply(void *sipCppV,int)
{
    EnginioReply *sipCpp = reinterpret_cast<EnginioReply *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


extern "C" {static void dealloc_EnginioReply(sipSimpleWrapper *);}
static void dealloc_EnginioReply(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_EnginioReply(sipGetAddress(sipSelf),0);
    }
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_EnginioReply[] = {{163, 0, 1}};


static PyMethodDef methods_EnginioReply[] = {
    {SIP_MLNAME_CAST(sipName_backendStatus), meth_EnginioReply_backendStatus, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioReply_backendStatus)},
    {SIP_MLNAME_CAST(sipName_data), meth_EnginioReply_data, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioReply_data)},
    {SIP_MLNAME_CAST(sipName_errorString), meth_EnginioReply_errorString, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioReply_errorString)},
    {SIP_MLNAME_CAST(sipName_errorType), meth_EnginioReply_errorType, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioReply_errorType)},
    {SIP_MLNAME_CAST(sipName_isError), meth_EnginioReply_isError, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioReply_isError)},
    {SIP_MLNAME_CAST(sipName_isFinished), meth_EnginioReply_isFinished, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioReply_isFinished)},
    {SIP_MLNAME_CAST(sipName_networkError), meth_EnginioReply_networkError, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioReply_networkError)}
};


/* Define this type's signals. */
static const pyqt5QtSignal signals_EnginioReply[] = {
    {"dataChanged()", "\1EnginioReply.dataChanged", 0, 0},
    {"finished(EnginioReply*)", "\1EnginioReply.finished[EnginioReply]", 0, 0},
    {"progress(qint64,qint64)", "\1EnginioReply.progress[int, int]", 0, 0},
    {0, 0, 0, 0}
};


pyqt5ClassTypeDef sipTypeDef_Enginio_EnginioReply = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_EnginioReply,
        {0}
    },
    {
        sipNameNr_EnginioReply,
        {0, 0, 1},
        7, methods_EnginioReply,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    -1,
    -1,
    supers_EnginioReply,
    0,
    0,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_EnginioReply,
    0,
    0,
    0,
    release_EnginioReply,
    cast_EnginioReply,
    0,
    0,
    0,
    0,
    0,
    0
},
    &EnginioReply::staticMetaObject,
    0,
    signals_EnginioReply,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginiooauth2authentication.sip"
#include <enginiooauth2authentication.h>
#line 826 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 830 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 833 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 836 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 839 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 244 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 842 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 232 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 845 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 848 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 851 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 32 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 854 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 144 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 857 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 860 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 863 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 866 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 869 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 872 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 875 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"


class sipEnginioOAuth2Authentication : public EnginioOAuth2Authentication
{
public:
    sipEnginioOAuth2Authentication(QObject*);
    virtual ~sipEnginioOAuth2Authentication();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool,QTimerEvent*);
    void sipProtectVirt_childEvent(bool,QChildEvent*);
    void sipProtectVirt_customEvent(bool,QEvent*);
    void sipProtectVirt_connectNotify(bool,const QMetaMethod&);
    void sipProtectVirt_disconnectNotify(bool,const QMetaMethod&);
    int sipProtect_senderSignalIndex() const;
    bool sipProtect_isSignalConnected(const QMetaMethod&) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const QMetaMethod&);
    void connectNotify(const QMetaMethod&);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipEnginioOAuth2Authentication(const sipEnginioOAuth2Authentication &);
    sipEnginioOAuth2Authentication &operator = (const sipEnginioOAuth2Authentication &);

    char sipPyMethods[7];
};

sipEnginioOAuth2Authentication::sipEnginioOAuth2Authentication(QObject*a0): EnginioOAuth2Authentication(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipEnginioOAuth2Authentication::~sipEnginioOAuth2Authentication()
{
    sipCommonDtor(sipPySelf);
}

const QMetaObject *sipEnginioOAuth2Authentication::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_Enginio_qt_metaobject(sipPySelf,sipType_EnginioOAuth2Authentication);
}

int sipEnginioOAuth2Authentication::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = EnginioOAuth2Authentication::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_Enginio_qt_metacall(sipPySelf,sipType_EnginioOAuth2Authentication,_c,_id,_a);

    return _id;
}

void *sipEnginioOAuth2Authentication::qt_metacast(const char *_clname)
{
    void *sipCpp;

    return (sip_Enginio_qt_metacast(sipPySelf, sipType_EnginioOAuth2Authentication, _clname, &sipCpp) ? sipCpp : EnginioOAuth2Authentication::qt_metacast(_clname));
}

void sipEnginioOAuth2Authentication::disconnectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
        EnginioOAuth2Authentication::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_Enginio_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioOAuth2Authentication::connectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
        EnginioOAuth2Authentication::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_Enginio_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioOAuth2Authentication::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
        EnginioOAuth2Authentication::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_Enginio_QtCore->em_virthandlers[25]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioOAuth2Authentication::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
        EnginioOAuth2Authentication::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_47)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_47)(sipModuleAPI_Enginio_QtCore->em_virthandlers[47]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioOAuth2Authentication::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
        EnginioOAuth2Authentication::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_Enginio_QtCore->em_virthandlers[9]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipEnginioOAuth2Authentication::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return EnginioOAuth2Authentication::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_26)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_26)(sipModuleAPI_Enginio_QtCore->em_virthandlers[26]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

bool sipEnginioOAuth2Authentication::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return EnginioOAuth2Authentication::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_Enginio_QtCore->em_virthandlers[5]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QObject* sipEnginioOAuth2Authentication::sipProtect_sender() const
{
    return QObject::sender();
}

int sipEnginioOAuth2Authentication::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipEnginioOAuth2Authentication::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipEnginioOAuth2Authentication::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipEnginioOAuth2Authentication::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipEnginioOAuth2Authentication::sipProtectVirt_connectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipEnginioOAuth2Authentication::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipEnginioOAuth2Authentication::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

bool sipEnginioOAuth2Authentication::sipProtect_isSignalConnected(const QMetaMethod& a0) const
{
    return QObject::isSignalConnected(a0);
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_sender, "EnginioOAuth2Authentication.sender() -> QObject");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipEnginioOAuth2Authentication *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp))
        {
            QObject*sipRes = 0;

#line 546 "sip/QtCore/qobject.sip"
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        if (!sipRes)
        {
            typedef QObject *(*qtcore_qobject_sender_t)();
        
            static qtcore_qobject_sender_t qtcore_qobject_sender = 0;
        
            if (!qtcore_qobject_sender)
                qtcore_qobject_sender = (qtcore_qobject_sender_t)sipImportSymbol("qtcore_qobject_sender");
        
            if (qtcore_qobject_sender)
                sipRes = qtcore_qobject_sender();
        }
#line 1163 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_sender, doc_EnginioOAuth2Authentication_sender);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_receivers, "EnginioOAuth2Authentication.receivers(signal) -> int");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        const sipEnginioOAuth2Authentication *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 575 "sip/QtCore/qobject.sip"
        // We need to handle the signal object.  Import the helper if it hasn't already
        // been done.
        typedef sipErrorState (*pyqt5_get_signal_signature_t)(PyObject *, const QObject *, const QByteArray &);
        
        static pyqt5_get_signal_signature_t pyqt5_get_signal_signature = 0;
        
        if (!pyqt5_get_signal_signature)
            pyqt5_get_signal_signature = (pyqt5_get_signal_signature_t)sipImportSymbol("pyqt5_get_signal_signature");
        
        if (pyqt5_get_signal_signature)
        {
            QByteArray signal_signature;
            
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            if ((sipError = pyqt5_get_signal_signature(a0, sipCpp, signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->receivers(signal_signature.constData());
            }
        #else
            if ((sipError = pyqt5_get_signal_signature(a0, static_cast<const QObject *>(sipCpp), signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->sipProtect_receivers(signal_signature.constData());
            }
        #endif
            else if (sipError == sipErrorContinue)
            {
                sipError = sipBadCallableArg(0, a0);
            }
        }
#line 1222 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_receivers, doc_EnginioOAuth2Authentication_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_timerEvent, "EnginioOAuth2Authentication.timerEvent(QTimerEvent)");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QTimerEvent* a0;
        sipEnginioOAuth2Authentication *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp, sipType_QTimerEvent, &a0))
        {
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_timerEvent, doc_EnginioOAuth2Authentication_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_childEvent, "EnginioOAuth2Authentication.childEvent(QChildEvent)");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QChildEvent* a0;
        sipEnginioOAuth2Authentication *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp, sipType_QChildEvent, &a0))
        {
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_childEvent, doc_EnginioOAuth2Authentication_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_customEvent, "EnginioOAuth2Authentication.customEvent(QEvent)");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        sipEnginioOAuth2Authentication *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp, sipType_QEvent, &a0))
        {
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_customEvent, doc_EnginioOAuth2Authentication_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_connectNotify, "EnginioOAuth2Authentication.connectNotify(QMetaMethod)");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QMetaMethod* a0;
        sipEnginioOAuth2Authentication *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_connectNotify, doc_EnginioOAuth2Authentication_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_disconnectNotify, "EnginioOAuth2Authentication.disconnectNotify(QMetaMethod)");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QMetaMethod* a0;
        sipEnginioOAuth2Authentication *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_disconnectNotify, doc_EnginioOAuth2Authentication_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_senderSignalIndex, "EnginioOAuth2Authentication.senderSignalIndex() -> int");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipEnginioOAuth2Authentication *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_senderSignalIndex, doc_EnginioOAuth2Authentication_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_isSignalConnected, "EnginioOAuth2Authentication.isSignalConnected(QMetaMethod) -> bool");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_isSignalConnected(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_isSignalConnected(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QMetaMethod* a0;
        const sipEnginioOAuth2Authentication *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp, sipType_QMetaMethod, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtect_isSignalConnected(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_isSignalConnected, doc_EnginioOAuth2Authentication_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_user, "EnginioOAuth2Authentication.user() -> str");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_user(PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_user(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioOAuth2Authentication *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp))
        {
            QString*sipRes;

            sipRes = new QString(sipCpp->user());

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_user, doc_EnginioOAuth2Authentication_user);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_password, "EnginioOAuth2Authentication.password() -> str");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_password(PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_password(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioOAuth2Authentication *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp))
        {
            QString*sipRes;

            sipRes = new QString(sipCpp->password());

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_password, doc_EnginioOAuth2Authentication_password);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_setUser, "EnginioOAuth2Authentication.setUser(str)");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_setUser(PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_setUser(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        EnginioOAuth2Authentication *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setUser(*a0);
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_setUser, doc_EnginioOAuth2Authentication_setUser);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioOAuth2Authentication_setPassword, "EnginioOAuth2Authentication.setPassword(str)");

extern "C" {static PyObject *meth_EnginioOAuth2Authentication_setPassword(PyObject *, PyObject *);}
static PyObject *meth_EnginioOAuth2Authentication_setPassword(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        EnginioOAuth2Authentication *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_EnginioOAuth2Authentication, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setPassword(*a0);
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioOAuth2Authentication, sipName_setPassword, doc_EnginioOAuth2Authentication_setPassword);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_EnginioOAuth2Authentication(void *, const sipTypeDef *);}
static void *cast_EnginioOAuth2Authentication(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_EnginioOAuth2Authentication)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_EnginioIdentity)->ctd_cast((EnginioIdentity *)(EnginioOAuth2Authentication *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_EnginioOAuth2Authentication(void *, int);}
static void release_EnginioOAuth2Authentication(void *sipCppV,int)
{
    EnginioOAuth2Authentication *sipCpp = reinterpret_cast<EnginioOAuth2Authentication *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


extern "C" {static void dealloc_EnginioOAuth2Authentication(sipSimpleWrapper *);}
static void dealloc_EnginioOAuth2Authentication(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipEnginioOAuth2Authentication *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_EnginioOAuth2Authentication(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_EnginioOAuth2Authentication(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_EnginioOAuth2Authentication(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipEnginioOAuth2Authentication *sipCpp = 0;

    {
        QObject* a0 = 0;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JH", sipType_QObject, &a0, sipOwner))
        {
            sipCpp = new sipEnginioOAuth2Authentication(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_EnginioOAuth2Authentication[] = {{7, 255, 1}};


static PyMethodDef methods_EnginioOAuth2Authentication[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_EnginioOAuth2Authentication_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_EnginioOAuth2Authentication_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_EnginioOAuth2Authentication_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_EnginioOAuth2Authentication_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_EnginioOAuth2Authentication_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_password), meth_EnginioOAuth2Authentication_password, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioOAuth2Authentication_password)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_EnginioOAuth2Authentication_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_EnginioOAuth2Authentication_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_EnginioOAuth2Authentication_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setPassword), meth_EnginioOAuth2Authentication_setPassword, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioOAuth2Authentication_setPassword)},
    {SIP_MLNAME_CAST(sipName_setUser), meth_EnginioOAuth2Authentication_setUser, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioOAuth2Authentication_setUser)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_EnginioOAuth2Authentication_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_user), meth_EnginioOAuth2Authentication_user, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioOAuth2Authentication_user)}
};


/* Define this type's signals. */
static const pyqt5QtSignal signals_EnginioOAuth2Authentication[] = {
    {"passwordChanged(QString)", "\1EnginioOAuth2Authentication.passwordChanged[str]", 0, 0},
    {"userChanged(QString)", "\1EnginioOAuth2Authentication.userChanged[str]", 0, 0},
    {0, 0, 0, 0}
};

PyDoc_STRVAR(doc_EnginioOAuth2Authentication, "\1EnginioOAuth2Authentication(QObject parent=None)");


pyqt5ClassTypeDef sipTypeDef_Enginio_EnginioOAuth2Authentication = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_EnginioOAuth2Authentication,
        {0}
    },
    {
        sipNameNr_EnginioOAuth2Authentication,
        {0, 0, 1},
        13, methods_EnginioOAuth2Authentication,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_EnginioOAuth2Authentication,
    -1,
    -1,
    supers_EnginioOAuth2Authentication,
    0,
    init_type_EnginioOAuth2Authentication,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_EnginioOAuth2Authentication,
    0,
    0,
    0,
    release_EnginioOAuth2Authentication,
    cast_EnginioOAuth2Authentication,
    0,
    0,
    0,
    0,
    0,
    0
},
    &EnginioOAuth2Authentication::staticMetaObject,
    0,
    signals_EnginioOAuth2Authentication,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginiomodel.sip"
#include <enginiomodel.h>
#line 1706 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 1710 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginio.sip"
#include <enginio.h>
#line 1713 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginioclient.sip"
#include <enginioclient.h>
#line 1716 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 24 "sip/QtCore/qjsonobject.sip"
#include <qjsonobject.h>
#line 1719 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginioreply.sip"
#include <enginioreply.h>
#line 1722 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 1725 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 1728 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qabstractitemmodel.sip"
#include <qabstractitemmodel.h>
#line 1731 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 1734 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qmimedata.sip"
#include <qmimedata.h>
#line 1737 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 1740 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 266 "sip/QtCore/qpycore_qhash.sip"
#include <qhash.h>
#line 1743 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 32 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 1746 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 1749 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1752 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qdatastream.sip"
#include <qdatastream.h>
#line 1755 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1758 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 70 "sip/QtCore/qabstractitemmodel.sip"
#include <qabstractitemmodel.h>
#line 1761 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 105 "sip/QtCore/qabstractitemmodel.sip"
#include <qabstractitemmodel.h>
#line 1764 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 321 "sip/QtCore/qpycore_qvector.sip"
#include <qvector.h>
#line 1767 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qsize.sip"
#include <qsize.h>
#line 1770 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 1773 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 34 "sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 1776 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 144 "sip/QtCore/qpycore_qmap.sip"
#include <qmap.h>
#line 1779 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 1782 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 1785 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 244 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 1788 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 232 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 1791 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1794 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 144 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1797 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 1800 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 1803 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 1806 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 1809 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 1812 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"


class sipEnginioModel : public EnginioModel
{
public:
    sipEnginioModel(QObject*);
    virtual ~sipEnginioModel();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool,QTimerEvent*);
    void sipProtectVirt_childEvent(bool,QChildEvent*);
    void sipProtectVirt_customEvent(bool,QEvent*);
    void sipProtectVirt_connectNotify(bool,const QMetaMethod&);
    void sipProtectVirt_disconnectNotify(bool,const QMetaMethod&);
    int sipProtect_senderSignalIndex() const;
    bool sipProtect_isSignalConnected(const QMetaMethod&) const;
    void sipProtect_encodeData(const QModelIndexList&,QDataStream&) const;
    bool sipProtect_decodeData(int,int,const QModelIndex&,QDataStream&);
    void sipProtect_beginInsertRows(const QModelIndex&,int,int);
    void sipProtect_endInsertRows();
    void sipProtect_beginRemoveRows(const QModelIndex&,int,int);
    void sipProtect_endRemoveRows();
    void sipProtect_beginInsertColumns(const QModelIndex&,int,int);
    void sipProtect_endInsertColumns();
    void sipProtect_beginRemoveColumns(const QModelIndex&,int,int);
    void sipProtect_endRemoveColumns();
    QModelIndexList sipProtect_persistentIndexList() const;
    void sipProtect_changePersistentIndex(const QModelIndex&,const QModelIndex&);
    void sipProtect_changePersistentIndexList(const QModelIndexList&,const QModelIndexList&);
    QModelIndex sipProtect_createIndex(int,int,void*) const;
    bool sipProtect_beginMoveRows(const QModelIndex&,int,int,const QModelIndex&,int);
    void sipProtect_endMoveRows();
    bool sipProtect_beginMoveColumns(const QModelIndex&,int,int,const QModelIndex&,int);
    void sipProtect_endMoveColumns();
    void sipProtect_beginResetModel();
    void sipProtect_endResetModel();
    void sipProtect_resetInternalData();

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const QMetaMethod&);
    void connectNotify(const QMetaMethod&);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    bool moveColumns(const QModelIndex&,int,int,const QModelIndex&,int);
    bool moveRows(const QModelIndex&,int,int,const QModelIndex&,int);
    bool canDropMimeData(const QMimeData*,Qt::DropAction,int,int,const QModelIndex&) const;
    QHash<int,QByteArray> roleNames() const;
    Qt::DropActions supportedDragActions() const;
    void revert();
    bool submit();
    QSize span(const QModelIndex&) const;
    QModelIndexList match(const QModelIndex&,int,const QVariant&,int,Qt::MatchFlags) const;
    QModelIndex buddy(const QModelIndex&) const;
    void sort(int,Qt::SortOrder);
    bool canFetchMore(const QModelIndex&) const;
    void fetchMore(const QModelIndex&);
    bool removeColumns(int,int,const QModelIndex&);
    bool removeRows(int,int,const QModelIndex&);
    bool insertColumns(int,int,const QModelIndex&);
    bool insertRows(int,int,const QModelIndex&);
    Qt::DropActions supportedDropActions() const;
    QMimeData* mimeData(const QModelIndexList&) const;
    QStringList mimeTypes() const;
    bool setItemData(const QModelIndex&,const QMap<int,QVariant>&);
    QMap<int,QVariant> itemData(const QModelIndex&) const;
    bool setHeaderData(int,Qt::Orientation,const QVariant&,int);
    QVariant headerData(int,Qt::Orientation,int) const;
    QVariant data(const QModelIndex&,int) const;
    int rowCount(const QModelIndex&) const;
    QModelIndex sibling(int,int,const QModelIndex&) const;
    Qt::ItemFlags flags(const QModelIndex&) const;
    bool dropMimeData(const QMimeData*,Qt::DropAction,int,int,const QModelIndex&);
    QModelIndex index(int,int,const QModelIndex&) const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipEnginioModel(const sipEnginioModel &);
    sipEnginioModel &operator = (const sipEnginioModel &);

    char sipPyMethods[37];
};

sipEnginioModel::sipEnginioModel(QObject*a0): EnginioModel(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipEnginioModel::~sipEnginioModel()
{
    sipCommonDtor(sipPySelf);
}

const QMetaObject *sipEnginioModel::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_Enginio_qt_metaobject(sipPySelf,sipType_EnginioModel);
}

int sipEnginioModel::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = EnginioModel::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_Enginio_qt_metacall(sipPySelf,sipType_EnginioModel,_c,_id,_a);

    return _id;
}

void *sipEnginioModel::qt_metacast(const char *_clname)
{
    void *sipCpp;

    return (sip_Enginio_qt_metacast(sipPySelf, sipType_EnginioModel, _clname, &sipCpp) ? sipCpp : EnginioModel::qt_metacast(_clname));
}

void sipEnginioModel::disconnectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
        EnginioModel::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_Enginio_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioModel::connectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
        EnginioModel::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_Enginio_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioModel::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
        EnginioModel::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_Enginio_QtCore->em_virthandlers[25]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioModel::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
        EnginioModel::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_47)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_47)(sipModuleAPI_Enginio_QtCore->em_virthandlers[47]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioModel::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
        EnginioModel::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_Enginio_QtCore->em_virthandlers[9]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipEnginioModel::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return EnginioModel::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_26)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_26)(sipModuleAPI_Enginio_QtCore->em_virthandlers[26]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

bool sipEnginioModel::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return EnginioModel::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_Enginio_QtCore->em_virthandlers[5]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipEnginioModel::moveColumns(const QModelIndex& a0,int a1,int a2,const QModelIndex& a3,int a4)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,NULL,sipName_moveColumns);

    if (!sipMeth)
        return EnginioModel::moveColumns(a0,a1,a2,a3,a4);

    typedef bool (*sipVH_QtCore_59)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,int,int,const QModelIndex&,int);

    return ((sipVH_QtCore_59)(sipModuleAPI_Enginio_QtCore->em_virthandlers[59]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2, a3, a4);
}

bool sipEnginioModel::moveRows(const QModelIndex& a0,int a1,int a2,const QModelIndex& a3,int a4)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,NULL,sipName_moveRows);

    if (!sipMeth)
        return EnginioModel::moveRows(a0,a1,a2,a3,a4);

    typedef bool (*sipVH_QtCore_59)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,int,int,const QModelIndex&,int);

    return ((sipVH_QtCore_59)(sipModuleAPI_Enginio_QtCore->em_virthandlers[59]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2, a3, a4);
}

bool sipEnginioModel::canDropMimeData(const QMimeData*a0,Qt::DropAction a1,int a2,int a3,const QModelIndex& a4) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[9]),sipPySelf,NULL,sipName_canDropMimeData);

    if (!sipMeth)
        return EnginioModel::canDropMimeData(a0,a1,a2,a3,a4);

    typedef bool (*sipVH_QtCore_33)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMimeData*,Qt::DropAction,int,int,const QModelIndex&);

    return ((sipVH_QtCore_33)(sipModuleAPI_Enginio_QtCore->em_virthandlers[33]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2, a3, a4);
}

QHash<int,QByteArray> sipEnginioModel::roleNames() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[10]),sipPySelf,NULL,sipName_roleNames);

    if (!sipMeth)
        return EnginioModel::roleNames();

    typedef QHash<int,QByteArray> (*sipVH_QtCore_60)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_60)(sipModuleAPI_Enginio_QtCore->em_virthandlers[60]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

Qt::DropActions sipEnginioModel::supportedDragActions() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[11]),sipPySelf,NULL,sipName_supportedDragActions);

    if (!sipMeth)
        return EnginioModel::supportedDragActions();

    typedef Qt::DropActions (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_18)(sipModuleAPI_Enginio_QtCore->em_virthandlers[18]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

void sipEnginioModel::revert()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[12],sipPySelf,NULL,sipName_revert);

    if (!sipMeth)
    {
        EnginioModel::revert();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_Enginio_QtCore->em_virthandlers[11]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

bool sipEnginioModel::submit()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[13],sipPySelf,NULL,sipName_submit);

    if (!sipMeth)
        return EnginioModel::submit();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_Enginio_QtCore->em_virthandlers[7]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

QSize sipEnginioModel::span(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[14]),sipPySelf,NULL,sipName_span);

    if (!sipMeth)
        return EnginioModel::span(a0);

    typedef QSize (*sipVH_QtCore_29)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_29)(sipModuleAPI_Enginio_QtCore->em_virthandlers[29]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QModelIndexList sipEnginioModel::match(const QModelIndex& a0,int a1,const QVariant& a2,int a3,Qt::MatchFlags a4) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[15]),sipPySelf,NULL,sipName_match);

    if (!sipMeth)
        return EnginioModel::match(a0,a1,a2,a3,a4);

    typedef QList<QModelIndex> (*sipVH_QtCore_28)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,int,const QVariant&,int,Qt::MatchFlags);

    return ((sipVH_QtCore_28)(sipModuleAPI_Enginio_QtCore->em_virthandlers[28]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2, a3, a4);
}

QModelIndex sipEnginioModel::buddy(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[16]),sipPySelf,NULL,sipName_buddy);

    if (!sipMeth)
        return EnginioModel::buddy(a0);

    typedef QModelIndex (*sipVH_QtCore_30)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_30)(sipModuleAPI_Enginio_QtCore->em_virthandlers[30]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioModel::sort(int a0,Qt::SortOrder a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[17],sipPySelf,NULL,sipName_sort);

    if (!sipMeth)
    {
        EnginioModel::sort(a0,a1);
        return;
    }

    typedef void (*sipVH_QtCore_19)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::SortOrder);

    ((sipVH_QtCore_19)(sipModuleAPI_Enginio_QtCore->em_virthandlers[19]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

bool sipEnginioModel::canFetchMore(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[18]),sipPySelf,NULL,sipName_canFetchMore);

    if (!sipMeth)
        return EnginioModel::canFetchMore(a0);

    typedef bool (*sipVH_QtCore_31)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_31)(sipModuleAPI_Enginio_QtCore->em_virthandlers[31]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioModel::fetchMore(const QModelIndex& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[19],sipPySelf,NULL,sipName_fetchMore);

    if (!sipMeth)
    {
        EnginioModel::fetchMore(a0);
        return;
    }

    typedef void (*sipVH_QtCore_32)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    ((sipVH_QtCore_32)(sipModuleAPI_Enginio_QtCore->em_virthandlers[32]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipEnginioModel::removeColumns(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[20],sipPySelf,NULL,sipName_removeColumns);

    if (!sipMeth)
        return EnginioModel::removeColumns(a0,a1,a2);

    typedef bool (*sipVH_QtCore_20)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_20)(sipModuleAPI_Enginio_QtCore->em_virthandlers[20]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2);
}

bool sipEnginioModel::removeRows(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[21],sipPySelf,NULL,sipName_removeRows);

    if (!sipMeth)
        return EnginioModel::removeRows(a0,a1,a2);

    typedef bool (*sipVH_QtCore_20)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_20)(sipModuleAPI_Enginio_QtCore->em_virthandlers[20]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2);
}

bool sipEnginioModel::insertColumns(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[22],sipPySelf,NULL,sipName_insertColumns);

    if (!sipMeth)
        return EnginioModel::insertColumns(a0,a1,a2);

    typedef bool (*sipVH_QtCore_20)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_20)(sipModuleAPI_Enginio_QtCore->em_virthandlers[20]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2);
}

bool sipEnginioModel::insertRows(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[23],sipPySelf,NULL,sipName_insertRows);

    if (!sipMeth)
        return EnginioModel::insertRows(a0,a1,a2);

    typedef bool (*sipVH_QtCore_20)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_20)(sipModuleAPI_Enginio_QtCore->em_virthandlers[20]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2);
}

Qt::DropActions sipEnginioModel::supportedDropActions() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[24]),sipPySelf,NULL,sipName_supportedDropActions);

    if (!sipMeth)
        return EnginioModel::supportedDropActions();

    typedef Qt::DropActions (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_18)(sipModuleAPI_Enginio_QtCore->em_virthandlers[18]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

QMimeData* sipEnginioModel::mimeData(const QModelIndexList& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[25]),sipPySelf,NULL,sipName_mimeData);

    if (!sipMeth)
        return EnginioModel::mimeData(a0);

    typedef QMimeData* (*sipVH_QtCore_34)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QList<QModelIndex>&);

    return ((sipVH_QtCore_34)(sipModuleAPI_Enginio_QtCore->em_virthandlers[34]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QStringList sipEnginioModel::mimeTypes() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[26]),sipPySelf,NULL,sipName_mimeTypes);

    if (!sipMeth)
        return EnginioModel::mimeTypes();

    typedef QStringList (*sipVH_QtCore_27)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_27)(sipModuleAPI_Enginio_QtCore->em_virthandlers[27]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

bool sipEnginioModel::setItemData(const QModelIndex& a0,const QMap<int,QVariant>& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[27],sipPySelf,NULL,sipName_setItemData);

    if (!sipMeth)
        return EnginioModel::setItemData(a0,a1);

    typedef bool (*sipVH_QtCore_56)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,const QMap<int,QVariant>&);

    return ((sipVH_QtCore_56)(sipModuleAPI_Enginio_QtCore->em_virthandlers[56]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

QMap<int,QVariant> sipEnginioModel::itemData(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[28]),sipPySelf,NULL,sipName_itemData);

    if (!sipMeth)
        return EnginioModel::itemData(a0);

    typedef QMap<int,QVariant> (*sipVH_QtCore_57)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_57)(sipModuleAPI_Enginio_QtCore->em_virthandlers[57]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipEnginioModel::setHeaderData(int a0,Qt::Orientation a1,const QVariant& a2,int a3)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[29],sipPySelf,NULL,sipName_setHeaderData);

    if (!sipMeth)
        return EnginioModel::setHeaderData(a0,a1,a2,a3);

    typedef bool (*sipVH_QtCore_35)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::Orientation,const QVariant&,int);

    return ((sipVH_QtCore_35)(sipModuleAPI_Enginio_QtCore->em_virthandlers[35]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2, a3);
}

QVariant sipEnginioModel::headerData(int a0,Qt::Orientation a1,int a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[30]),sipPySelf,NULL,sipName_headerData);

    if (!sipMeth)
        return EnginioModel::headerData(a0,a1,a2);

    typedef QVariant (*sipVH_QtCore_36)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::Orientation,int);

    return ((sipVH_QtCore_36)(sipModuleAPI_Enginio_QtCore->em_virthandlers[36]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2);
}

QVariant sipEnginioModel::data(const QModelIndex& a0,int a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[31]),sipPySelf,sipName_EnginioModel,sipName_data);

    if (!sipMeth)
        return QVariant();

    typedef QVariant (*sipVH_QtCore_23)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,int);

    return ((sipVH_QtCore_23)(sipModuleAPI_Enginio_QtCore->em_virthandlers[23]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

int sipEnginioModel::rowCount(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[32]),sipPySelf,sipName_EnginioModel,sipName_rowCount);

    if (!sipMeth)
        return 0;

    typedef int (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_24)(sipModuleAPI_Enginio_QtCore->em_virthandlers[24]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QModelIndex sipEnginioModel::sibling(int a0,int a1,const QModelIndex& a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[33]),sipPySelf,NULL,sipName_sibling);

    if (!sipMeth)
        return EnginioModel::sibling(a0,a1,a2);

    typedef QModelIndex (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_17)(sipModuleAPI_Enginio_QtCore->em_virthandlers[17]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2);
}

Qt::ItemFlags sipEnginioModel::flags(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[34]),sipPySelf,NULL,sipName_flags);

    if (!sipMeth)
        return EnginioModel::flags(a0);

    typedef Qt::ItemFlags (*sipVH_QtCore_21)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_21)(sipModuleAPI_Enginio_QtCore->em_virthandlers[21]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipEnginioModel::dropMimeData(const QMimeData*a0,Qt::DropAction a1,int a2,int a3,const QModelIndex& a4)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[35],sipPySelf,NULL,sipName_dropMimeData);

    if (!sipMeth)
        return EnginioModel::dropMimeData(a0,a1,a2,a3,a4);

    typedef bool (*sipVH_QtCore_33)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMimeData*,Qt::DropAction,int,int,const QModelIndex&);

    return ((sipVH_QtCore_33)(sipModuleAPI_Enginio_QtCore->em_virthandlers[33]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2, a3, a4);
}

QModelIndex sipEnginioModel::index(int a0,int a1,const QModelIndex& a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[36]),sipPySelf,NULL,sipName_index);

    if (!sipMeth)
        return EnginioModel::index(a0,a1,a2);

    typedef QModelIndex (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_17)(sipModuleAPI_Enginio_QtCore->em_virthandlers[17]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2);
}

QObject* sipEnginioModel::sipProtect_sender() const
{
    return QObject::sender();
}

int sipEnginioModel::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipEnginioModel::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipEnginioModel::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipEnginioModel::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipEnginioModel::sipProtectVirt_connectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipEnginioModel::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipEnginioModel::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

bool sipEnginioModel::sipProtect_isSignalConnected(const QMetaMethod& a0) const
{
    return QObject::isSignalConnected(a0);
}

void sipEnginioModel::sipProtect_encodeData(const QModelIndexList& a0,QDataStream& a1) const
{
    QAbstractItemModel::encodeData(a0,a1);
}

bool sipEnginioModel::sipProtect_decodeData(int a0,int a1,const QModelIndex& a2,QDataStream& a3)
{
    return QAbstractItemModel::decodeData(a0,a1,a2,a3);
}

void sipEnginioModel::sipProtect_beginInsertRows(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginInsertRows(a0,a1,a2);
}

void sipEnginioModel::sipProtect_endInsertRows()
{
    QAbstractItemModel::endInsertRows();
}

void sipEnginioModel::sipProtect_beginRemoveRows(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginRemoveRows(a0,a1,a2);
}

void sipEnginioModel::sipProtect_endRemoveRows()
{
    QAbstractItemModel::endRemoveRows();
}

void sipEnginioModel::sipProtect_beginInsertColumns(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginInsertColumns(a0,a1,a2);
}

void sipEnginioModel::sipProtect_endInsertColumns()
{
    QAbstractItemModel::endInsertColumns();
}

void sipEnginioModel::sipProtect_beginRemoveColumns(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginRemoveColumns(a0,a1,a2);
}

void sipEnginioModel::sipProtect_endRemoveColumns()
{
    QAbstractItemModel::endRemoveColumns();
}

QModelIndexList sipEnginioModel::sipProtect_persistentIndexList() const
{
    return QAbstractItemModel::persistentIndexList();
}

void sipEnginioModel::sipProtect_changePersistentIndex(const QModelIndex& a0,const QModelIndex& a1)
{
    QAbstractItemModel::changePersistentIndex(a0,a1);
}

void sipEnginioModel::sipProtect_changePersistentIndexList(const QModelIndexList& a0,const QModelIndexList& a1)
{
    QAbstractItemModel::changePersistentIndexList(a0,a1);
}

QModelIndex sipEnginioModel::sipProtect_createIndex(int a0,int a1,void*a2) const
{
    return QAbstractItemModel::createIndex(a0,a1,a2);
}

bool sipEnginioModel::sipProtect_beginMoveRows(const QModelIndex& a0,int a1,int a2,const QModelIndex& a3,int a4)
{
    return QAbstractItemModel::beginMoveRows(a0,a1,a2,a3,a4);
}

void sipEnginioModel::sipProtect_endMoveRows()
{
    QAbstractItemModel::endMoveRows();
}

bool sipEnginioModel::sipProtect_beginMoveColumns(const QModelIndex& a0,int a1,int a2,const QModelIndex& a3,int a4)
{
    return QAbstractItemModel::beginMoveColumns(a0,a1,a2,a3,a4);
}

void sipEnginioModel::sipProtect_endMoveColumns()
{
    QAbstractItemModel::endMoveColumns();
}

void sipEnginioModel::sipProtect_beginResetModel()
{
    QAbstractItemModel::beginResetModel();
}

void sipEnginioModel::sipProtect_endResetModel()
{
    QAbstractItemModel::endResetModel();
}

void sipEnginioModel::sipProtect_resetInternalData()
{
    QAbstractItemModel::resetInternalData();
}


PyDoc_STRVAR(doc_EnginioModel_sender, "EnginioModel.sender() -> QObject");

extern "C" {static PyObject *meth_EnginioModel_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            QObject*sipRes = 0;

#line 546 "sip/QtCore/qobject.sip"
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        if (!sipRes)
        {
            typedef QObject *(*qtcore_qobject_sender_t)();
        
            static qtcore_qobject_sender_t qtcore_qobject_sender = 0;
        
            if (!qtcore_qobject_sender)
                qtcore_qobject_sender = (qtcore_qobject_sender_t)sipImportSymbol("qtcore_qobject_sender");
        
            if (qtcore_qobject_sender)
                sipRes = qtcore_qobject_sender();
        }
#line 2715 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_sender, doc_EnginioModel_sender);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_receivers, "EnginioModel.receivers(signal) -> int");

extern "C" {static PyObject *meth_EnginioModel_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        const sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_EnginioModel, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 575 "sip/QtCore/qobject.sip"
        // We need to handle the signal object.  Import the helper if it hasn't already
        // been done.
        typedef sipErrorState (*pyqt5_get_signal_signature_t)(PyObject *, const QObject *, const QByteArray &);
        
        static pyqt5_get_signal_signature_t pyqt5_get_signal_signature = 0;
        
        if (!pyqt5_get_signal_signature)
            pyqt5_get_signal_signature = (pyqt5_get_signal_signature_t)sipImportSymbol("pyqt5_get_signal_signature");
        
        if (pyqt5_get_signal_signature)
        {
            QByteArray signal_signature;
            
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            if ((sipError = pyqt5_get_signal_signature(a0, sipCpp, signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->receivers(signal_signature.constData());
            }
        #else
            if ((sipError = pyqt5_get_signal_signature(a0, static_cast<const QObject *>(sipCpp), signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->sipProtect_receivers(signal_signature.constData());
            }
        #endif
            else if (sipError == sipErrorContinue)
            {
                sipError = sipBadCallableArg(0, a0);
            }
        }
#line 2774 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_receivers, doc_EnginioModel_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_timerEvent, "EnginioModel.timerEvent(QTimerEvent)");

extern "C" {static PyObject *meth_EnginioModel_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QTimerEvent* a0;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QTimerEvent, &a0))
        {
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_timerEvent, doc_EnginioModel_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_childEvent, "EnginioModel.childEvent(QChildEvent)");

extern "C" {static PyObject *meth_EnginioModel_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QChildEvent* a0;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QChildEvent, &a0))
        {
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_childEvent, doc_EnginioModel_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_customEvent, "EnginioModel.customEvent(QEvent)");

extern "C" {static PyObject *meth_EnginioModel_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QEvent, &a0))
        {
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_customEvent, doc_EnginioModel_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_connectNotify, "EnginioModel.connectNotify(QMetaMethod)");

extern "C" {static PyObject *meth_EnginioModel_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QMetaMethod* a0;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_connectNotify, doc_EnginioModel_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_disconnectNotify, "EnginioModel.disconnectNotify(QMetaMethod)");

extern "C" {static PyObject *meth_EnginioModel_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QMetaMethod* a0;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_disconnectNotify, doc_EnginioModel_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_senderSignalIndex, "EnginioModel.senderSignalIndex() -> int");

extern "C" {static PyObject *meth_EnginioModel_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_senderSignalIndex, doc_EnginioModel_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_isSignalConnected, "EnginioModel.isSignalConnected(QMetaMethod) -> bool");

extern "C" {static PyObject *meth_EnginioModel_isSignalConnected(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_isSignalConnected(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QMetaMethod* a0;
        const sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QMetaMethod, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtect_isSignalConnected(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_isSignalConnected, doc_EnginioModel_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_encodeData, "EnginioModel.encodeData(list-of-QModelIndex, QDataStream)");

extern "C" {static PyObject *meth_EnginioModel_encodeData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_encodeData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndexList* a0;
        int a0State = 0;
        QDataStream* a1;
        const sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J9", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QList_0100QModelIndex,&a0, &a0State, sipType_QDataStream, &a1))
        {
            sipCpp->sipProtect_encodeData(*a0,*a1);
            sipReleaseType(const_cast<QModelIndexList *>(a0),sipType_QList_0100QModelIndex,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_encodeData, doc_EnginioModel_encodeData);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_decodeData, "EnginioModel.decodeData(int, int, QModelIndex, QDataStream) -> bool");

extern "C" {static PyObject *meth_EnginioModel_decodeData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_decodeData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        int a1;
        const QModelIndex* a2;
        QDataStream* a3;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BiiJ9J9", &sipSelf, sipType_EnginioModel, &sipCpp, &a0, &a1, sipType_QModelIndex, &a2, sipType_QDataStream, &a3))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtect_decodeData(a0,a1,*a2,*a3);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_decodeData, doc_EnginioModel_decodeData);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_beginInsertRows, "EnginioModel.beginInsertRows(QModelIndex, int, int)");

extern "C" {static PyObject *meth_EnginioModel_beginInsertRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_beginInsertRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            sipCpp->sipProtect_beginInsertRows(*a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_beginInsertRows, doc_EnginioModel_beginInsertRows);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_endInsertRows, "EnginioModel.endInsertRows()");

extern "C" {static PyObject *meth_EnginioModel_endInsertRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_endInsertRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            sipCpp->sipProtect_endInsertRows();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_endInsertRows, doc_EnginioModel_endInsertRows);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_beginRemoveRows, "EnginioModel.beginRemoveRows(QModelIndex, int, int)");

extern "C" {static PyObject *meth_EnginioModel_beginRemoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_beginRemoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            sipCpp->sipProtect_beginRemoveRows(*a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_beginRemoveRows, doc_EnginioModel_beginRemoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_endRemoveRows, "EnginioModel.endRemoveRows()");

extern "C" {static PyObject *meth_EnginioModel_endRemoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_endRemoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            sipCpp->sipProtect_endRemoveRows();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_endRemoveRows, doc_EnginioModel_endRemoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_beginInsertColumns, "EnginioModel.beginInsertColumns(QModelIndex, int, int)");

extern "C" {static PyObject *meth_EnginioModel_beginInsertColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_beginInsertColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            sipCpp->sipProtect_beginInsertColumns(*a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_beginInsertColumns, doc_EnginioModel_beginInsertColumns);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_endInsertColumns, "EnginioModel.endInsertColumns()");

extern "C" {static PyObject *meth_EnginioModel_endInsertColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_endInsertColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            sipCpp->sipProtect_endInsertColumns();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_endInsertColumns, doc_EnginioModel_endInsertColumns);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_beginRemoveColumns, "EnginioModel.beginRemoveColumns(QModelIndex, int, int)");

extern "C" {static PyObject *meth_EnginioModel_beginRemoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_beginRemoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            sipCpp->sipProtect_beginRemoveColumns(*a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_beginRemoveColumns, doc_EnginioModel_beginRemoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_endRemoveColumns, "EnginioModel.endRemoveColumns()");

extern "C" {static PyObject *meth_EnginioModel_endRemoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_endRemoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            sipCpp->sipProtect_endRemoveColumns();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_endRemoveColumns, doc_EnginioModel_endRemoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_persistentIndexList, "EnginioModel.persistentIndexList() -> list-of-QModelIndex");

extern "C" {static PyObject *meth_EnginioModel_persistentIndexList(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_persistentIndexList(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            QModelIndexList*sipRes;

            sipRes = new QModelIndexList(sipCpp->sipProtect_persistentIndexList());

            return sipConvertFromNewType(sipRes,sipType_QList_0100QModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_persistentIndexList, doc_EnginioModel_persistentIndexList);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_changePersistentIndex, "EnginioModel.changePersistentIndex(QModelIndex, QModelIndex)");

extern "C" {static PyObject *meth_EnginioModel_changePersistentIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_changePersistentIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        const QModelIndex* a1;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9J9", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QModelIndex, &a0, sipType_QModelIndex, &a1))
        {
            sipCpp->sipProtect_changePersistentIndex(*a0,*a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_changePersistentIndex, doc_EnginioModel_changePersistentIndex);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_changePersistentIndexList, "EnginioModel.changePersistentIndexList(list-of-QModelIndex, list-of-QModelIndex)");

extern "C" {static PyObject *meth_EnginioModel_changePersistentIndexList(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_changePersistentIndexList(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndexList* a0;
        int a0State = 0;
        const QModelIndexList* a1;
        int a1State = 0;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J1", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QList_0100QModelIndex,&a0, &a0State, sipType_QList_0100QModelIndex,&a1, &a1State))
        {
            sipCpp->sipProtect_changePersistentIndexList(*a0,*a1);
            sipReleaseType(const_cast<QModelIndexList *>(a0),sipType_QList_0100QModelIndex,a0State);
            sipReleaseType(const_cast<QModelIndexList *>(a1),sipType_QList_0100QModelIndex,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_changePersistentIndexList, doc_EnginioModel_changePersistentIndexList);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_createIndex, "EnginioModel.createIndex(int, int, object object=0) -> QModelIndex");

extern "C" {static PyObject *meth_EnginioModel_createIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_createIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        int a1;
        PyObject * a2 = 0;
        const sipEnginioModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_object,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bii|P0", &sipSelf, sipType_EnginioModel, &sipCpp, &a0, &a1, &a2))
        {
            QModelIndex*sipRes = 0;

#line 194 "sip/QtCore/qabstractitemmodel.sip"
        // The Qt API is broken (and won't be fixed as it would break binary
        // compatibility) regarding the internal id of a model index on different
        // architectures (32 vs 64 bits).  We choose to work around the breakage as it
        // is fairly subtle and continues to catch people out.  Instead of letting Qt
        // convert betweed an integer id and a pointer id (the internal format used by
        // Qt) we let Python do it.
        
        void *ptr;
        
        if (a2)
        {
            // Try and convert it to a Python long and fallback to the object's
            // address if it fails.
            ptr = PyLong_AsVoidPtr(a2);
        
            if (PyErr_Occurred())
            {
                PyErr_Clear();
                ptr = a2;
            }
        }
        else
        {
            ptr = 0;
        }
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = new QModelIndex(sipCpp->createIndex(a0, a1, ptr));
        #else
        sipRes = new QModelIndex(sipCpp->sipProtect_createIndex(a0, a1, ptr));
        #endif
#line 3413 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

            return sipConvertFromNewType(sipRes,sipType_QModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_createIndex, doc_EnginioModel_createIndex);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_beginMoveRows, "EnginioModel.beginMoveRows(QModelIndex, int, int, QModelIndex, int) -> bool");

extern "C" {static PyObject *meth_EnginioModel_beginMoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_beginMoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        const QModelIndex* a3;
        int a4;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9iiJ9i", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2, sipType_QModelIndex, &a3, &a4))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtect_beginMoveRows(*a0,a1,a2,*a3,a4);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_beginMoveRows, doc_EnginioModel_beginMoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_endMoveRows, "EnginioModel.endMoveRows()");

extern "C" {static PyObject *meth_EnginioModel_endMoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_endMoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            sipCpp->sipProtect_endMoveRows();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_endMoveRows, doc_EnginioModel_endMoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_beginMoveColumns, "EnginioModel.beginMoveColumns(QModelIndex, int, int, QModelIndex, int) -> bool");

extern "C" {static PyObject *meth_EnginioModel_beginMoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_beginMoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        const QModelIndex* a3;
        int a4;
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9iiJ9i", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2, sipType_QModelIndex, &a3, &a4))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtect_beginMoveColumns(*a0,a1,a2,*a3,a4);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_beginMoveColumns, doc_EnginioModel_beginMoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_endMoveColumns, "EnginioModel.endMoveColumns()");

extern "C" {static PyObject *meth_EnginioModel_endMoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_endMoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            sipCpp->sipProtect_endMoveColumns();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_endMoveColumns, doc_EnginioModel_endMoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_beginResetModel, "EnginioModel.beginResetModel()");

extern "C" {static PyObject *meth_EnginioModel_beginResetModel(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_beginResetModel(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            sipCpp->sipProtect_beginResetModel();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_beginResetModel, doc_EnginioModel_beginResetModel);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_endResetModel, "EnginioModel.endResetModel()");

extern "C" {static PyObject *meth_EnginioModel_endResetModel(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_endResetModel(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            sipCpp->sipProtect_endResetModel();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_endResetModel, doc_EnginioModel_endResetModel);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_resetInternalData, "EnginioModel.resetInternalData()");

extern "C" {static PyObject *meth_EnginioModel_resetInternalData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_resetInternalData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipEnginioModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            sipCpp->sipProtect_resetInternalData();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_resetInternalData, doc_EnginioModel_resetInternalData);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_client, "EnginioModel.client() -> EnginioClient");

extern "C" {static PyObject *meth_EnginioModel_client(PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_client(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            EnginioClient*sipRes;

            sipRes = sipCpp->client();

            return sipConvertFromType(sipRes,sipType_EnginioClient,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_client, doc_EnginioModel_client);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_setClient, "EnginioModel.setClient(EnginioClient)");

extern "C" {static PyObject *meth_EnginioModel_setClient(PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_setClient(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioClient* a0;
        EnginioModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_EnginioClient, &a0))
        {
            sipCpp->setClient(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_setClient, doc_EnginioModel_setClient);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_query, "EnginioModel.query() -> dict-of-str-QJsonValue");

extern "C" {static PyObject *meth_EnginioModel_query(PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_query(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        EnginioModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            QJsonObject*sipRes;

            sipRes = new QJsonObject(sipCpp->query());

            return sipConvertFromNewType(sipRes,sipType_QJsonObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_query, doc_EnginioModel_query);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_setQuery, "EnginioModel.setQuery(dict-of-str-QJsonValue)");

extern "C" {static PyObject *meth_EnginioModel_setQuery(PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_setQuery(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QJsonObject* a0;
        int a0State = 0;
        EnginioModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QJsonObject,&a0, &a0State))
        {
            sipCpp->setQuery(*a0);
            sipReleaseType(const_cast<QJsonObject *>(a0),sipType_QJsonObject,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_setQuery, doc_EnginioModel_setQuery);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_operation, "EnginioModel.operation() -> Enginio.Operation");

extern "C" {static PyObject *meth_EnginioModel_operation(PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_operation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            Enginio::Operation sipRes;

            sipRes = sipCpp->operation();

            return sipConvertFromEnum(sipRes,sipType_Enginio_Operation);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_operation, doc_EnginioModel_operation);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_setOperation, "EnginioModel.setOperation(Enginio.Operation)");

extern "C" {static PyObject *meth_EnginioModel_setOperation(PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_setOperation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        Enginio::Operation a0;
        EnginioModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_Enginio_Operation, &a0))
        {
            sipCpp->setOperation(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_setOperation, doc_EnginioModel_setOperation);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_append, "EnginioModel.append(dict-of-str-QJsonValue) -> EnginioReply");

extern "C" {static PyObject *meth_EnginioModel_append(PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_append(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QJsonObject* a0;
        int a0State = 0;
        EnginioModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_EnginioModel, &sipCpp, sipType_QJsonObject,&a0, &a0State))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->append(*a0);
            sipReleaseType(const_cast<QJsonObject *>(a0),sipType_QJsonObject,a0State);

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_append, doc_EnginioModel_append);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_remove, "EnginioModel.remove(int) -> EnginioReply");

extern "C" {static PyObject *meth_EnginioModel_remove(PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_remove(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        EnginioModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_EnginioModel, &sipCpp, &a0))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->remove(a0);

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_remove, doc_EnginioModel_remove);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_setData, "EnginioModel.setData(int, QVariant, str) -> EnginioReply\n"
    "EnginioModel.setData(int, dict-of-str-QJsonValue) -> EnginioReply");

extern "C" {static PyObject *meth_EnginioModel_setData(PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_setData(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QVariant* a1;
        int a1State = 0;
        const QString* a2;
        int a2State = 0;
        EnginioModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ1J1", &sipSelf, sipType_EnginioModel, &sipCpp, &a0, sipType_QVariant, &a1, &a1State, sipType_QString,&a2, &a2State))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->setData(a0,*a1,*a2);
            sipReleaseType(const_cast<QVariant *>(a1),sipType_QVariant,a1State);
            sipReleaseType(const_cast<QString *>(a2),sipType_QString,a2State);

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    {
        int a0;
        const QJsonObject* a1;
        int a1State = 0;
        EnginioModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ1", &sipSelf, sipType_EnginioModel, &sipCpp, &a0, sipType_QJsonObject,&a1, &a1State))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->setData(a0,*a1);
            sipReleaseType(const_cast<QJsonObject *>(a1),sipType_QJsonObject,a1State);

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_setData, doc_EnginioModel_setData);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioModel_reload, "EnginioModel.reload() -> EnginioReply");

extern "C" {static PyObject *meth_EnginioModel_reload(PyObject *, PyObject *);}
static PyObject *meth_EnginioModel_reload(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        EnginioModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioModel, &sipCpp))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->reload();

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioModel, sipName_reload, doc_EnginioModel_reload);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_EnginioModel(void *, const sipTypeDef *);}
static void *cast_EnginioModel(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_EnginioModel)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QAbstractListModel)->ctd_cast((QAbstractListModel *)(EnginioModel *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_EnginioModel(void *, int);}
static void release_EnginioModel(void *sipCppV,int)
{
    EnginioModel *sipCpp = reinterpret_cast<EnginioModel *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


extern "C" {static void dealloc_EnginioModel(sipSimpleWrapper *);}
static void dealloc_EnginioModel(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipEnginioModel *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_EnginioModel(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_EnginioModel(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_EnginioModel(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipEnginioModel *sipCpp = 0;

    {
        QObject* a0 = 0;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JH", sipType_QObject, &a0, sipOwner))
        {
            sipCpp = new sipEnginioModel(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_EnginioModel[] = {{8, 0, 1}};


static PyMethodDef methods_EnginioModel[] = {
    {SIP_MLNAME_CAST(sipName_append), meth_EnginioModel_append, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioModel_append)},
    {SIP_MLNAME_CAST(sipName_beginInsertColumns), (PyCFunction)meth_EnginioModel_beginInsertColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginInsertRows), (PyCFunction)meth_EnginioModel_beginInsertRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginMoveColumns), (PyCFunction)meth_EnginioModel_beginMoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginMoveRows), (PyCFunction)meth_EnginioModel_beginMoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginRemoveColumns), (PyCFunction)meth_EnginioModel_beginRemoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginRemoveRows), (PyCFunction)meth_EnginioModel_beginRemoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginResetModel), (PyCFunction)meth_EnginioModel_beginResetModel, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_changePersistentIndex), (PyCFunction)meth_EnginioModel_changePersistentIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_changePersistentIndexList), (PyCFunction)meth_EnginioModel_changePersistentIndexList, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_EnginioModel_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_client), meth_EnginioModel_client, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioModel_client)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_EnginioModel_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_createIndex), (PyCFunction)meth_EnginioModel_createIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_EnginioModel_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_decodeData), (PyCFunction)meth_EnginioModel_decodeData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_EnginioModel_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_encodeData), (PyCFunction)meth_EnginioModel_encodeData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endInsertColumns), (PyCFunction)meth_EnginioModel_endInsertColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endInsertRows), (PyCFunction)meth_EnginioModel_endInsertRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endMoveColumns), (PyCFunction)meth_EnginioModel_endMoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endMoveRows), (PyCFunction)meth_EnginioModel_endMoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endRemoveColumns), (PyCFunction)meth_EnginioModel_endRemoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endRemoveRows), (PyCFunction)meth_EnginioModel_endRemoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endResetModel), (PyCFunction)meth_EnginioModel_endResetModel, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_EnginioModel_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_operation), meth_EnginioModel_operation, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioModel_operation)},
    {SIP_MLNAME_CAST(sipName_persistentIndexList), (PyCFunction)meth_EnginioModel_persistentIndexList, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_query), meth_EnginioModel_query, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioModel_query)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_EnginioModel_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_reload), meth_EnginioModel_reload, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioModel_reload)},
    {SIP_MLNAME_CAST(sipName_remove), meth_EnginioModel_remove, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioModel_remove)},
    {SIP_MLNAME_CAST(sipName_resetInternalData), (PyCFunction)meth_EnginioModel_resetInternalData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_EnginioModel_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_EnginioModel_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setClient), meth_EnginioModel_setClient, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioModel_setClient)},
    {SIP_MLNAME_CAST(sipName_setData), meth_EnginioModel_setData, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioModel_setData)},
    {SIP_MLNAME_CAST(sipName_setOperation), meth_EnginioModel_setOperation, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioModel_setOperation)},
    {SIP_MLNAME_CAST(sipName_setQuery), meth_EnginioModel_setQuery, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioModel_setQuery)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_EnginioModel_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};


/* Define this type's signals. */
static const pyqt5QtSignal signals_EnginioModel[] = {
    {"operationChanged(Enginio::Operation)", "\1EnginioModel.operationChanged[Enginio.Operation]", 0, 0},
    {"clientChanged(EnginioClient*)", "\1EnginioModel.clientChanged[EnginioClient]", 0, 0},
    {"queryChanged(QJsonObject)", "\1EnginioModel.queryChanged[dict-of-str-QJsonValue]", 0, 0},
    {0, 0, 0, 0}
};

PyDoc_STRVAR(doc_EnginioModel, "\1EnginioModel(QObject parent=None)");


pyqt5ClassTypeDef sipTypeDef_Enginio_EnginioModel = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_EnginioModel,
        {0}
    },
    {
        sipNameNr_EnginioModel,
        {0, 0, 1},
        40, methods_EnginioModel,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_EnginioModel,
    -1,
    -1,
    supers_EnginioModel,
    0,
    init_type_EnginioModel,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_EnginioModel,
    0,
    0,
    0,
    release_EnginioModel,
    cast_EnginioModel,
    0,
    0,
    0,
    0,
    0,
    0
},
    &EnginioModel::staticMetaObject,
    0,
    signals_EnginioModel,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginioidentity.sip"
#include <enginioidentity.h>
#line 4105 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

#line 30 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 4109 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4112 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 244 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4115 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 232 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4118 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 4121 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 4124 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 4127 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 4130 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 32 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 4133 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 144 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 4136 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 4139 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 4142 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 4145 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 4148 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 4151 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 4154 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_EnginioIdentity(void *, const sipTypeDef *);}
static void *cast_EnginioIdentity(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_EnginioIdentity)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(EnginioIdentity *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_EnginioIdentity(void *, int);}
static void release_EnginioIdentity(void *sipCppV,int)
{
    EnginioIdentity *sipCpp = reinterpret_cast<EnginioIdentity *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


extern "C" {static void dealloc_EnginioIdentity(sipSimpleWrapper *);}
static void dealloc_EnginioIdentity(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_EnginioIdentity(sipGetAddress(sipSelf),0);
    }
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_EnginioIdentity[] = {{163, 0, 1}};


pyqt5ClassTypeDef sipTypeDef_Enginio_EnginioIdentity = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_EnginioIdentity,
        {0}
    },
    {
        sipNameNr_EnginioIdentity,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    -1,
    -1,
    supers_EnginioIdentity,
    0,
    0,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_EnginioIdentity,
    0,
    0,
    0,
    release_EnginioIdentity,
    cast_EnginioIdentity,
    0,
    0,
    0,
    0,
    0,
    0
},
    &EnginioIdentity::staticMetaObject,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginioclient.sip"
#include <enginioclient.h>
#line 4256 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 4260 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginioreply.sip"
#include <enginioreply.h>
#line 4263 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 24 "sip/QtCore/qjsonobject.sip"
#include <qjsonobject.h>
#line 4266 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 100 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 4269 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginio.sip"
#include <enginio.h>
#line 4272 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginioidentity.sip"
#include <enginioidentity.h>
#line 4275 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 32 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 4278 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtNetwork/qnetworkaccessmanager.sip"
#include <qnetworkaccessmanager.h>
#line 4281 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 4284 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4287 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 244 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4290 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 232 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4293 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 4296 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 4299 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 4302 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 144 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 4305 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 4308 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 4311 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 4314 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 4317 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 4320 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 4323 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"


class sipEnginioClient : public EnginioClient
{
public:
    sipEnginioClient(QObject*);
    virtual ~sipEnginioClient();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool,QTimerEvent*);
    void sipProtectVirt_childEvent(bool,QChildEvent*);
    void sipProtectVirt_customEvent(bool,QEvent*);
    void sipProtectVirt_connectNotify(bool,const QMetaMethod&);
    void sipProtectVirt_disconnectNotify(bool,const QMetaMethod&);
    int sipProtect_senderSignalIndex() const;
    bool sipProtect_isSignalConnected(const QMetaMethod&) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const QMetaMethod&);
    void connectNotify(const QMetaMethod&);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipEnginioClient(const sipEnginioClient &);
    sipEnginioClient &operator = (const sipEnginioClient &);

    char sipPyMethods[7];
};

sipEnginioClient::sipEnginioClient(QObject*a0): EnginioClient(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipEnginioClient::~sipEnginioClient()
{
    sipCommonDtor(sipPySelf);
}

const QMetaObject *sipEnginioClient::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_Enginio_qt_metaobject(sipPySelf,sipType_EnginioClient);
}

int sipEnginioClient::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = EnginioClient::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_Enginio_qt_metacall(sipPySelf,sipType_EnginioClient,_c,_id,_a);

    return _id;
}

void *sipEnginioClient::qt_metacast(const char *_clname)
{
    void *sipCpp;

    return (sip_Enginio_qt_metacast(sipPySelf, sipType_EnginioClient, _clname, &sipCpp) ? sipCpp : EnginioClient::qt_metacast(_clname));
}

void sipEnginioClient::disconnectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
        EnginioClient::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_Enginio_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioClient::connectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
        EnginioClient::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_Enginio_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioClient::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
        EnginioClient::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_Enginio_QtCore->em_virthandlers[25]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioClient::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
        EnginioClient::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_47)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_47)(sipModuleAPI_Enginio_QtCore->em_virthandlers[47]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipEnginioClient::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
        EnginioClient::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_Enginio_QtCore->em_virthandlers[9]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipEnginioClient::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return EnginioClient::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_26)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_26)(sipModuleAPI_Enginio_QtCore->em_virthandlers[26]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

bool sipEnginioClient::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return EnginioClient::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_Enginio_QtCore->em_virthandlers[5]))(sipGILState, sipModuleAPI_Enginio_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QObject* sipEnginioClient::sipProtect_sender() const
{
    return QObject::sender();
}

int sipEnginioClient::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipEnginioClient::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipEnginioClient::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipEnginioClient::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipEnginioClient::sipProtectVirt_connectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipEnginioClient::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipEnginioClient::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

bool sipEnginioClient::sipProtect_isSignalConnected(const QMetaMethod& a0) const
{
    return QObject::isSignalConnected(a0);
}


PyDoc_STRVAR(doc_EnginioClient_sender, "EnginioClient.sender() -> QObject");

extern "C" {static PyObject *meth_EnginioClient_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipEnginioClient *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioClient, &sipCpp))
        {
            QObject*sipRes = 0;

#line 546 "sip/QtCore/qobject.sip"
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        if (!sipRes)
        {
            typedef QObject *(*qtcore_qobject_sender_t)();
        
            static qtcore_qobject_sender_t qtcore_qobject_sender = 0;
        
            if (!qtcore_qobject_sender)
                qtcore_qobject_sender = (qtcore_qobject_sender_t)sipImportSymbol("qtcore_qobject_sender");
        
            if (qtcore_qobject_sender)
                sipRes = qtcore_qobject_sender();
        }
#line 4611 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_sender, doc_EnginioClient_sender);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_receivers, "EnginioClient.receivers(signal) -> int");

extern "C" {static PyObject *meth_EnginioClient_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        const sipEnginioClient *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_EnginioClient, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 575 "sip/QtCore/qobject.sip"
        // We need to handle the signal object.  Import the helper if it hasn't already
        // been done.
        typedef sipErrorState (*pyqt5_get_signal_signature_t)(PyObject *, const QObject *, const QByteArray &);
        
        static pyqt5_get_signal_signature_t pyqt5_get_signal_signature = 0;
        
        if (!pyqt5_get_signal_signature)
            pyqt5_get_signal_signature = (pyqt5_get_signal_signature_t)sipImportSymbol("pyqt5_get_signal_signature");
        
        if (pyqt5_get_signal_signature)
        {
            QByteArray signal_signature;
            
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            if ((sipError = pyqt5_get_signal_signature(a0, sipCpp, signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->receivers(signal_signature.constData());
            }
        #else
            if ((sipError = pyqt5_get_signal_signature(a0, static_cast<const QObject *>(sipCpp), signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->sipProtect_receivers(signal_signature.constData());
            }
        #endif
            else if (sipError == sipErrorContinue)
            {
                sipError = sipBadCallableArg(0, a0);
            }
        }
#line 4670 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_receivers, doc_EnginioClient_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_timerEvent, "EnginioClient.timerEvent(QTimerEvent)");

extern "C" {static PyObject *meth_EnginioClient_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QTimerEvent* a0;
        sipEnginioClient *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QTimerEvent, &a0))
        {
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_timerEvent, doc_EnginioClient_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_childEvent, "EnginioClient.childEvent(QChildEvent)");

extern "C" {static PyObject *meth_EnginioClient_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QChildEvent* a0;
        sipEnginioClient *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QChildEvent, &a0))
        {
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_childEvent, doc_EnginioClient_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_customEvent, "EnginioClient.customEvent(QEvent)");

extern "C" {static PyObject *meth_EnginioClient_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        sipEnginioClient *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QEvent, &a0))
        {
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_customEvent, doc_EnginioClient_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_connectNotify, "EnginioClient.connectNotify(QMetaMethod)");

extern "C" {static PyObject *meth_EnginioClient_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QMetaMethod* a0;
        sipEnginioClient *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_connectNotify, doc_EnginioClient_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_disconnectNotify, "EnginioClient.disconnectNotify(QMetaMethod)");

extern "C" {static PyObject *meth_EnginioClient_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QMetaMethod* a0;
        sipEnginioClient *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_disconnectNotify, doc_EnginioClient_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_senderSignalIndex, "EnginioClient.senderSignalIndex() -> int");

extern "C" {static PyObject *meth_EnginioClient_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipEnginioClient *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_EnginioClient, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_senderSignalIndex, doc_EnginioClient_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_isSignalConnected, "EnginioClient.isSignalConnected(QMetaMethod) -> bool");

extern "C" {static PyObject *meth_EnginioClient_isSignalConnected(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_isSignalConnected(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QMetaMethod* a0;
        const sipEnginioClient *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QMetaMethod, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtect_isSignalConnected(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_isSignalConnected, doc_EnginioClient_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_fullTextSearch, "EnginioClient.fullTextSearch(dict-of-str-QJsonValue) -> EnginioReply");

extern "C" {static PyObject *meth_EnginioClient_fullTextSearch(PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_fullTextSearch(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QJsonObject* a0;
        int a0State = 0;
        EnginioClient *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QJsonObject,&a0, &a0State))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->fullTextSearch(*a0);
            sipReleaseType(const_cast<QJsonObject *>(a0),sipType_QJsonObject,a0State);

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_fullTextSearch, doc_EnginioClient_fullTextSearch);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_query, "EnginioClient.query(dict-of-str-QJsonValue, Enginio.Operation operation=Enginio.ObjectOperation) -> EnginioReply");

extern "C" {static PyObject *meth_EnginioClient_query(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_query(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QJsonObject* a0;
        int a0State = 0;
        Enginio::Operation a1 = Enginio::ObjectOperation;
        EnginioClient *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_operation,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|E", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QJsonObject,&a0, &a0State, sipType_Enginio_Operation, &a1))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->query(*a0,a1);
            sipReleaseType(const_cast<QJsonObject *>(a0),sipType_QJsonObject,a0State);

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_query, doc_EnginioClient_query);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_create, "EnginioClient.create(dict-of-str-QJsonValue, Enginio.Operation operation=Enginio.ObjectOperation) -> EnginioReply");

extern "C" {static PyObject *meth_EnginioClient_create(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_create(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QJsonObject* a0;
        int a0State = 0;
        Enginio::Operation a1 = Enginio::ObjectOperation;
        EnginioClient *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_operation,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|E", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QJsonObject,&a0, &a0State, sipType_Enginio_Operation, &a1))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->create(*a0,a1);
            sipReleaseType(const_cast<QJsonObject *>(a0),sipType_QJsonObject,a0State);

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_create, doc_EnginioClient_create);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_update, "EnginioClient.update(dict-of-str-QJsonValue, Enginio.Operation operation=Enginio.ObjectOperation) -> EnginioReply");

extern "C" {static PyObject *meth_EnginioClient_update(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_update(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QJsonObject* a0;
        int a0State = 0;
        Enginio::Operation a1 = Enginio::ObjectOperation;
        EnginioClient *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_operation,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|E", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QJsonObject,&a0, &a0State, sipType_Enginio_Operation, &a1))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->update(*a0,a1);
            sipReleaseType(const_cast<QJsonObject *>(a0),sipType_QJsonObject,a0State);

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_update, doc_EnginioClient_update);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_remove, "EnginioClient.remove(dict-of-str-QJsonValue, Enginio.Operation operation=Enginio.ObjectOperation) -> EnginioReply");

extern "C" {static PyObject *meth_EnginioClient_remove(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_remove(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QJsonObject* a0;
        int a0State = 0;
        Enginio::Operation a1 = Enginio::ObjectOperation;
        EnginioClient *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_operation,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|E", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QJsonObject,&a0, &a0State, sipType_Enginio_Operation, &a1))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->remove(*a0,a1);
            sipReleaseType(const_cast<QJsonObject *>(a0),sipType_QJsonObject,a0State);

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_remove, doc_EnginioClient_remove);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_uploadFile, "EnginioClient.uploadFile(dict-of-str-QJsonValue, QUrl) -> EnginioReply");

extern "C" {static PyObject *meth_EnginioClient_uploadFile(PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_uploadFile(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QJsonObject* a0;
        int a0State = 0;
        const QUrl* a1;
        EnginioClient *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J9", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QJsonObject,&a0, &a0State, sipType_QUrl, &a1))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->uploadFile(*a0,*a1);
            sipReleaseType(const_cast<QJsonObject *>(a0),sipType_QJsonObject,a0State);

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_uploadFile, doc_EnginioClient_uploadFile);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClient_downloadUrl, "EnginioClient.downloadUrl(dict-of-str-QJsonValue) -> EnginioReply");

extern "C" {static PyObject *meth_EnginioClient_downloadUrl(PyObject *, PyObject *);}
static PyObject *meth_EnginioClient_downloadUrl(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QJsonObject* a0;
        int a0State = 0;
        EnginioClient *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_EnginioClient, &sipCpp, sipType_QJsonObject,&a0, &a0State))
        {
            EnginioReply*sipRes;

            sipRes = sipCpp->downloadUrl(*a0);
            sipReleaseType(const_cast<QJsonObject *>(a0),sipType_QJsonObject,a0State);

            return sipConvertFromType(sipRes,sipType_EnginioReply,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClient, sipName_downloadUrl, doc_EnginioClient_downloadUrl);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_EnginioClient(void *, const sipTypeDef *);}
static void *cast_EnginioClient(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_EnginioClient)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_EnginioClientConnection)->ctd_cast((EnginioClientConnection *)(EnginioClient *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_EnginioClient(void *, int);}
static void release_EnginioClient(void *sipCppV,int)
{
    EnginioClient *sipCpp = reinterpret_cast<EnginioClient *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


extern "C" {static void dealloc_EnginioClient(sipSimpleWrapper *);}
static void dealloc_EnginioClient(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipEnginioClient *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_EnginioClient(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_EnginioClient(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_EnginioClient(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipEnginioClient *sipCpp = 0;

    {
        QObject* a0 = 0;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JH", sipType_QObject, &a0, sipOwner))
        {
            sipCpp = new sipEnginioClient(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_EnginioClient[] = {{6, 255, 1}};


static PyMethodDef methods_EnginioClient[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_EnginioClient_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_EnginioClient_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_create), (PyCFunction)meth_EnginioClient_create, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_EnginioClient_create)},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_EnginioClient_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_EnginioClient_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_downloadUrl), meth_EnginioClient_downloadUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioClient_downloadUrl)},
    {SIP_MLNAME_CAST(sipName_fullTextSearch), meth_EnginioClient_fullTextSearch, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioClient_fullTextSearch)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_EnginioClient_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_query), (PyCFunction)meth_EnginioClient_query, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_EnginioClient_query)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_EnginioClient_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_remove), (PyCFunction)meth_EnginioClient_remove, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_EnginioClient_remove)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_EnginioClient_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_EnginioClient_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_EnginioClient_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_update), (PyCFunction)meth_EnginioClient_update, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_EnginioClient_update)},
    {SIP_MLNAME_CAST(sipName_uploadFile), meth_EnginioClient_uploadFile, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioClient_uploadFile)}
};


/* Define this type's signals. */
static const pyqt5QtSignal signals_EnginioClient[] = {
    {"error(EnginioReply*)", "\1EnginioClient.error[EnginioReply]", 0, 0},
    {"finished(EnginioReply*)", "\1EnginioClient.finished[EnginioReply]", 0, 0},
    {"sessionTerminated()", "\1EnginioClient.sessionTerminated", 0, 0},
    {"sessionAuthenticationError(EnginioReply*)", "\1EnginioClient.sessionAuthenticationError[EnginioReply]", 0, 0},
    {"sessionAuthenticated(EnginioReply*)", "\1EnginioClient.sessionAuthenticated[EnginioReply]", 0, 0},
    {0, 0, 0, 0}
};

PyDoc_STRVAR(doc_EnginioClient, "\1EnginioClient(QObject parent=None)");


pyqt5ClassTypeDef sipTypeDef_Enginio_EnginioClient = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_EnginioClient,
        {0}
    },
    {
        sipNameNr_EnginioClient,
        {0, 0, 1},
        16, methods_EnginioClient,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_EnginioClient,
    -1,
    -1,
    supers_EnginioClient,
    0,
    init_type_EnginioClient,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_EnginioClient,
    0,
    0,
    0,
    release_EnginioClient,
    cast_EnginioClient,
    0,
    0,
    0,
    0,
    0,
    0
},
    &EnginioClient::staticMetaObject,
    0,
    signals_EnginioClient,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginioclientconnection.sip"
#include <enginioclientconnection.h>
#line 5283 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginioidentity.sip"
#include <enginioidentity.h>
#line 5287 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginio.sip"
#include <enginio.h>
#line 5290 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 100 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 5293 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 32 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 5296 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtNetwork/qnetworkaccessmanager.sip"
#include <qnetworkaccessmanager.h>
#line 5299 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 5302 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 5305 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 244 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 5308 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 232 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 5311 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 5314 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 5317 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 5320 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 5323 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 144 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 5326 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 5329 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 5332 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 5335 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 5338 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 30 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 5341 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 5344 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"


PyDoc_STRVAR(doc_EnginioClientConnection_backendId, "EnginioClientConnection.backendId() -> QByteArray");

extern "C" {static PyObject *meth_EnginioClientConnection_backendId(PyObject *, PyObject *);}
static PyObject *meth_EnginioClientConnection_backendId(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioClientConnection *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioClientConnection, &sipCpp))
        {
            QByteArray*sipRes;

            sipRes = new QByteArray(sipCpp->backendId());

            return sipConvertFromNewType(sipRes,sipType_QByteArray,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClientConnection, sipName_backendId, doc_EnginioClientConnection_backendId);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClientConnection_setBackendId, "EnginioClientConnection.setBackendId(QByteArray)");

extern "C" {static PyObject *meth_EnginioClientConnection_setBackendId(PyObject *, PyObject *);}
static PyObject *meth_EnginioClientConnection_setBackendId(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QByteArray* a0;
        int a0State = 0;
        EnginioClientConnection *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_EnginioClientConnection, &sipCpp, sipType_QByteArray, &a0, &a0State))
        {
            sipCpp->setBackendId(*a0);
            sipReleaseType(const_cast<QByteArray *>(a0),sipType_QByteArray,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClientConnection, sipName_setBackendId, doc_EnginioClientConnection_setBackendId);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClientConnection_identity, "EnginioClientConnection.identity() -> EnginioIdentity");

extern "C" {static PyObject *meth_EnginioClientConnection_identity(PyObject *, PyObject *);}
static PyObject *meth_EnginioClientConnection_identity(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioClientConnection *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioClientConnection, &sipCpp))
        {
            EnginioIdentity*sipRes;

            sipRes = sipCpp->identity();

            return sipConvertFromType(sipRes,sipType_EnginioIdentity,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClientConnection, sipName_identity, doc_EnginioClientConnection_identity);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClientConnection_setIdentity, "EnginioClientConnection.setIdentity(EnginioIdentity)");

extern "C" {static PyObject *meth_EnginioClientConnection_setIdentity(PyObject *, PyObject *);}
static PyObject *meth_EnginioClientConnection_setIdentity(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        EnginioIdentity* a0;
        EnginioClientConnection *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_EnginioClientConnection, &sipCpp, sipType_EnginioIdentity, &a0))
        {
            sipCpp->setIdentity(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClientConnection, sipName_setIdentity, doc_EnginioClientConnection_setIdentity);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClientConnection_authenticationState, "EnginioClientConnection.authenticationState() -> Enginio.AuthenticationState");

extern "C" {static PyObject *meth_EnginioClientConnection_authenticationState(PyObject *, PyObject *);}
static PyObject *meth_EnginioClientConnection_authenticationState(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioClientConnection *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioClientConnection, &sipCpp))
        {
            Enginio::AuthenticationState sipRes;

            sipRes = sipCpp->authenticationState();

            return sipConvertFromEnum(sipRes,sipType_Enginio_AuthenticationState);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClientConnection, sipName_authenticationState, doc_EnginioClientConnection_authenticationState);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClientConnection_serviceUrl, "EnginioClientConnection.serviceUrl() -> QUrl");

extern "C" {static PyObject *meth_EnginioClientConnection_serviceUrl(PyObject *, PyObject *);}
static PyObject *meth_EnginioClientConnection_serviceUrl(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioClientConnection *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioClientConnection, &sipCpp))
        {
            QUrl*sipRes;

            sipRes = new QUrl(sipCpp->serviceUrl());

            return sipConvertFromNewType(sipRes,sipType_QUrl,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClientConnection, sipName_serviceUrl, doc_EnginioClientConnection_serviceUrl);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClientConnection_setServiceUrl, "EnginioClientConnection.setServiceUrl(QUrl)");

extern "C" {static PyObject *meth_EnginioClientConnection_setServiceUrl(PyObject *, PyObject *);}
static PyObject *meth_EnginioClientConnection_setServiceUrl(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QUrl* a0;
        EnginioClientConnection *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_EnginioClientConnection, &sipCpp, sipType_QUrl, &a0))
        {
            sipCpp->setServiceUrl(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClientConnection, sipName_setServiceUrl, doc_EnginioClientConnection_setServiceUrl);

    return NULL;
}


PyDoc_STRVAR(doc_EnginioClientConnection_networkManager, "EnginioClientConnection.networkManager() -> QNetworkAccessManager");

extern "C" {static PyObject *meth_EnginioClientConnection_networkManager(PyObject *, PyObject *);}
static PyObject *meth_EnginioClientConnection_networkManager(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const EnginioClientConnection *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_EnginioClientConnection, &sipCpp))
        {
            QNetworkAccessManager*sipRes;

            sipRes = sipCpp->networkManager();

            return sipConvertFromType(sipRes,sipType_QNetworkAccessManager,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_EnginioClientConnection, sipName_networkManager, doc_EnginioClientConnection_networkManager);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_EnginioClientConnection(void *, const sipTypeDef *);}
static void *cast_EnginioClientConnection(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_EnginioClientConnection)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(EnginioClientConnection *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_EnginioClientConnection(void *, int);}
static void release_EnginioClientConnection(void *sipCppV,int)
{
    EnginioClientConnection *sipCpp = reinterpret_cast<EnginioClientConnection *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


extern "C" {static void dealloc_EnginioClientConnection(sipSimpleWrapper *);}
static void dealloc_EnginioClientConnection(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_EnginioClientConnection(sipGetAddress(sipSelf),0);
    }
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_EnginioClientConnection[] = {{163, 0, 1}};


static PyMethodDef methods_EnginioClientConnection[] = {
    {SIP_MLNAME_CAST(sipName_authenticationState), meth_EnginioClientConnection_authenticationState, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioClientConnection_authenticationState)},
    {SIP_MLNAME_CAST(sipName_backendId), meth_EnginioClientConnection_backendId, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioClientConnection_backendId)},
    {SIP_MLNAME_CAST(sipName_identity), meth_EnginioClientConnection_identity, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioClientConnection_identity)},
    {SIP_MLNAME_CAST(sipName_networkManager), meth_EnginioClientConnection_networkManager, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioClientConnection_networkManager)},
    {SIP_MLNAME_CAST(sipName_serviceUrl), meth_EnginioClientConnection_serviceUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioClientConnection_serviceUrl)},
    {SIP_MLNAME_CAST(sipName_setBackendId), meth_EnginioClientConnection_setBackendId, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioClientConnection_setBackendId)},
    {SIP_MLNAME_CAST(sipName_setIdentity), meth_EnginioClientConnection_setIdentity, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioClientConnection_setIdentity)},
    {SIP_MLNAME_CAST(sipName_setServiceUrl), meth_EnginioClientConnection_setServiceUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_EnginioClientConnection_setServiceUrl)}
};


/* Define this type's signals. */
static const pyqt5QtSignal signals_EnginioClientConnection[] = {
    {"identityChanged(EnginioIdentity*)", "\1EnginioClientConnection.identityChanged[EnginioIdentity]", 0, 0},
    {"authenticationStateChanged(Enginio::AuthenticationState)", "\1EnginioClientConnection.authenticationStateChanged[Enginio.AuthenticationState]", 0, 0},
    {"serviceUrlChanged(QUrl)", "\1EnginioClientConnection.serviceUrlChanged[QUrl]", 0, 0},
    {"backendIdChanged(QByteArray)", "\1EnginioClientConnection.backendIdChanged[QByteArray]", 0, 0},
    {0, 0, 0, 0}
};


pyqt5ClassTypeDef sipTypeDef_Enginio_EnginioClientConnection = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_EnginioClientConnection,
        {0}
    },
    {
        sipNameNr_EnginioClientConnection,
        {0, 0, 1},
        8, methods_EnginioClientConnection,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    -1,
    -1,
    supers_EnginioClientConnection,
    0,
    0,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_EnginioClientConnection,
    0,
    0,
    0,
    release_EnginioClientConnection,
    cast_EnginioClientConnection,
    0,
    0,
    0,
    0,
    0,
    0
},
    &EnginioClientConnection::staticMetaObject,
    0,
    signals_EnginioClientConnection,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/sip/Enginio/enginio.sip"
#include <enginio.h>
#line 5686 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.x86_64/build/Enginio/sipEnginiopart0.cpp"



/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_Enginio(void *, const sipTypeDef *);}
static void *cast_Enginio(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_Enginio)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_Enginio(void *, int);}
static void release_Enginio(void *sipCppV,int)
{
    delete reinterpret_cast<Enginio *>(sipCppV);
}


extern "C" {static void dealloc_Enginio(sipSimpleWrapper *);}
static void dealloc_Enginio(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_Enginio(sipGetAddress(sipSelf),0);
    }
}

static sipEnumMemberDef enummembers_Enginio[] = {
    {sipName_AccessControlOperation, static_cast<int>(Enginio::AccessControlOperation), 3},
    {sipName_Authenticated, static_cast<int>(Enginio::Authenticated), 1},
    {sipName_Authenticating, static_cast<int>(Enginio::Authenticating), 1},
    {sipName_AuthenticationFailure, static_cast<int>(Enginio::AuthenticationFailure), 1},
    {sipName_BackendError, static_cast<int>(Enginio::BackendError), 2},
    {sipName_CreatedAtRole, static_cast<int>(Enginio::CreatedAtRole), 4},
    {sipName_CustomPropertyRole, static_cast<int>(Enginio::CustomPropertyRole), 4},
    {sipName_FileOperation, static_cast<int>(Enginio::FileOperation), 3},
    {sipName_IdRole, static_cast<int>(Enginio::IdRole), 4},
    {sipName_JsonObjectRole, static_cast<int>(Enginio::JsonObjectRole), 4},
    {sipName_NetworkError, static_cast<int>(Enginio::NetworkError), 2},
    {sipName_NoError, static_cast<int>(Enginio::NoError), 2},
    {sipName_NotAuthenticated, static_cast<int>(Enginio::NotAuthenticated), 1},
    {sipName_ObjectOperation, static_cast<int>(Enginio::ObjectOperation), 3},
    {sipName_ObjectTypeRole, static_cast<int>(Enginio::ObjectTypeRole), 4},
    {sipName_SyncedRole, static_cast<int>(Enginio::SyncedRole), 4},
    {sipName_UpdatedAtRole, static_cast<int>(Enginio::UpdatedAtRole), 4},
    {sipName_UserOperation, static_cast<int>(Enginio::UserOperation), 3},
    {sipName_UsergroupMembersOperation, static_cast<int>(Enginio::UsergroupMembersOperation), 3},
    {sipName_UsergroupOperation, static_cast<int>(Enginio::UsergroupOperation), 3},
};


pyqt5ClassTypeDef sipTypeDef_Enginio_Enginio = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_Enginio,
        {0}
    },
    {
        sipNameNr_Enginio,
        {0, 0, 1},
        0, 0,
        20, enummembers_Enginio,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    sipNameNr_PyQt5_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    0,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_Enginio,
    0,
    0,
    0,
    release_Enginio,
    cast_Enginio,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};
