/*
 * Module code.
 *
 * Generated by SIP 4.19.3
 *
 * Copyright (c) 2017 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 "sipAPIQtQml.h"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 29 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsengine.sip"
#include <qjsengine.h>
#line 32 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 35 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 38 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 41 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 44 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 47 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 96 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 50 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlabstracturlinterceptor.sip"
#include <qqmlabstracturlinterceptor.h>
#line 53 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlcontext.sip"
#include <qqmlcontext.h>
#line 56 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 62 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlincubator.sip"
#include <qqmlincubator.h>
#line 65 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtNetwork/qnetworkaccessmanager.sip"
#include <qnetworkaccessmanager.h>
#line 68 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 71 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 74 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlproperty.sip"
#include <qqmlproperty.h>
#line 77 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsengine.sip"
#include <qjsengine.h>
#line 80 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsvalue.sip"
#include <qjsvalue.h>
#line 83 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlerror.sip"
#include <qqmlerror.h>
#line 86 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmllist.sip"
#include <qqmllist.h>
#line 89 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlscriptstring.sip"
#include <qqmlscriptstring.h>
#line 92 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

/* Define the strings used by this module. */
const char sipStrings_QtQml[] = {
    'Q', 'Q', 'm', 'l', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'U', 'r', 'l', 'I', 'n', 't', 'e', 'r', 'c', 'e', 'p', 't', 'o', 'r', ':', ':', 'D', 'a', 't', 'a', 'T', 'y', 'p', 'e', 0,
    'Q', 'Q', 'm', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', ':', ':', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'T', 'y', 'p', 'e', 'C', 'a', 't', 'e', 'g', 'o', 'r', 'y', 0,
    's', 'e', 't', 'O', 'u', 't', 'p', 'u', 't', 'W', 'a', 'r', 'n', 'i', 'n', 'g', 's', 'T', 'o', 'S', 't', 'a', 'n', 'd', 'a', 'r', 'd', 'E', 'r', 'r', 'o', 'r', 0,
    'Q', 'Q', 'm', 'l', 'I', 'm', 'a', 'g', 'e', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 'B', 'a', 's', 'e', ':', ':', 'I', 'm', 'a', 'g', 'e', 'T', 'y', 'p', 'e', 0,
    'Q', 'Q', 'm', 'l', 'N', 'e', 't', 'w', 'o', 'r', 'k', 'A', 'c', 'c', 'e', 's', 's', 'M', 'a', 'n', 'a', 'g', 'e', 'r', 'F', 'a', 'c', 't', 'o', 'r', 'y', 0,
    'o', 'f', 'f', 'l', 'i', 'n', 'e', 'S', 't', 'o', 'r', 'a', 'g', 'e', 'D', 'a', 't', 'a', 'b', 'a', 's', 'e', 'F', 'i', 'l', 'e', 'P', 'a', 't', 'h', 0,
    's', 'e', 't', 'N', 'e', 't', 'w', 'o', 'r', 'k', 'A', 'c', 'c', 'e', 's', 's', 'M', 'a', 'n', 'a', 'g', 'e', 'r', 'F', 'a', 'c', 't', 'o', 'r', 'y', 0,
    'Q', 'Q', 'm', 'l', 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n', 't', ':', ':', 'C', 'o', 'm', 'p', 'i', 'l', 'a', 't', 'i', 'o', 'n', 'M', 'o', 'd', 'e', 0,
    'Q', 'Q', 'm', 'l', 'I', 'n', 'c', 'u', 'b', 'a', 't', 'o', 'r', ':', ':', 'I', 'n', 'c', 'u', 'b', 'a', 't', 'i', 'o', 'n', 'M', 'o', 'd', 'e', 0,
    'o', 'u', 't', 'p', 'u', 't', 'W', 'a', 'r', 'n', 'i', 'n', 'g', 's', 'T', 'o', 'S', 't', 'a', 'n', 'd', 'a', 'r', 'd', 'E', 'r', 'r', 'o', 'r', 0,
    'F', 'o', 'r', 'c', 'e', 'A', 's', 'y', 'n', 'c', 'h', 'r', 'o', 'n', 'o', 'u', 's', 'I', 'm', 'a', 'g', 'e', 'L', 'o', 'a', 'd', 'i', 'n', 'g', 0,
    'i', 'n', 'c', 'u', 'b', 'a', 't', 'i', 'n', 'g', 'O', 'b', 'j', 'e', 'c', 't', 'C', 'o', 'u', 'n', 't', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'Q', 'Q', 'm', 'l', 'I', 'm', 'a', 'g', 'e', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 'B', 'a', 's', 'e', ':', ':', 'F', 'l', 'a', 'g', 's', 0,
    'q', 'm', 'l', 'A', 't', 't', 'a', 'c', 'h', 'e', 'd', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'Q', 'Q', 'm', 'l', 'E', 'n', 'g', 'i', 'n', 'e', ':', ':', 'O', 'b', 'j', 'e', 'c', 't', 'O', 'w', 'n', 'e', 'r', 's', 'h', 'i', 'p', 0,
    'n', 'e', 't', 'w', 'o', 'r', 'k', 'A', 'c', 'c', 'e', 's', 's', 'M', 'a', 'n', 'a', 'g', 'e', 'r', 'F', 'a', 'c', 't', 'o', 'r', 'y', 0,
    'Q', 'Q', 'm', 'l', 'I', 'm', 'a', 'g', 'e', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 'B', 'a', 's', 'e', ':', ':', 'F', 'l', 'a', 'g', 0,
    'q', 'm', 'l', 'R', 'e', 'g', 'i', 's', 't', 'e', 'r', 'U', 'n', 'c', 'r', 'e', 'a', 't', 'a', 'b', 'l', 'e', 'T', 'y', 'p', 'e', 0,
    'Q', 'Q', 'm', 'l', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'U', 'r', 'l', 'I', 'n', 't', 'e', 'r', 'c', 'e', 'p', 't', 'o', 'r', 0,
    'G', 'a', 'r', 'b', 'a', 'g', 'e', 'C', 'o', 'l', 'l', 'e', 'c', 't', 'i', 'o', 'n', 'E', 'x', 't', 'e', 'n', 's', 'i', 'o', 'n', 0,
    'i', 'n', 's', 't', 'a', 'l', 'l', 'T', 'r', 'a', 'n', 's', 'l', 'a', 't', 'o', 'r', 'F', 'u', 'n', 'c', 't', 'i', 'o', 'n', 's', 0,
    'Q', 'Q', 'm', 'l', 'L', 'i', 's', 't', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', '<', 'Q', 'O', 'b', 'j', 'e', 'c', 't', '>', 0,
    'q', 'm', 'l', 'R', 'e', 'g', 'i', 's', 't', 'e', 'r', 'S', 'i', 'n', 'g', 'l', 'e', 't', 'o', 'n', 'T', 'y', 'p', 'e', 0,
    'Q', 'Q', 'm', 'l', 'I', 'n', 'c', 'u', 'b', 'a', 't', 'i', 'o', 'n', 'C', 'o', 'n', 't', 'r', 'o', 'l', 'l', 'e', 'r', 0,
    'Q', 'Q', 'm', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'V', 'a', 'l', 'u', 'e', 'S', 'o', 'u', 'r', 'c', 'e', 0,
    's', 'e', 't', 'N', 'o', 't', 'i', 'f', 'y', 'O', 'n', 'V', 'a', 'l', 'u', 'e', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    's', 'e', 't', 'I', 'n', 'c', 'u', 'b', 'a', 't', 'i', 'o', 'n', 'C', 'o', 'n', 't', 'r', 'o', 'l', 'l', 'e', 'r', 0,
    'Q', 'J', 'S', 'V', 'a', 'l', 'u', 'e', ':', ':', 'S', 'p', 'e', 'c', 'i', 'a', 'l', 'V', 'a', 'l', 'u', 'e', 0,
    'i', 'n', 'c', 'u', 'b', 'a', 't', 'i', 'n', 'g', 'O', 'b', 'j', 'e', 'c', 't', 'C', 'o', 'u', 'n', 't', 0,
    'Q', 'Q', 'm', 'l', 'I', 'n', 'c', 'u', 'b', 'a', 't', 'o', 'r', ':', ':', 'S', 't', 'a', 't', 'u', 's', 0,
    's', 'e', 't', 'O', 'f', 'f', 'l', 'i', 'n', 'e', 'S', 't', 'o', 'r', 'a', 'g', 'e', 'P', 'a', 't', 'h', 0,
    'Q', 'Q', 'm', 'l', 'I', 'm', 'a', 'g', 'e', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 'B', 'a', 's', 'e', 0,
    'Q', 'Q', 'm', 'l', 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n', 't', ':', ':', 'S', 't', 'a', 't', 'u', 's', 0,
    'Q', 'Q', 'm', 'l', 'A', 'p', 'p', 'l', 'i', 'c', 'a', 't', 'i', 'o', 'n', 'E', 'n', 'g', 'i', 'n', 'e', 0,
    'Q', 'J', 'S', 'E', 'n', 'g', 'i', 'n', 'e', ':', ':', 'E', 'x', 't', 'e', 'n', 's', 'i', 'o', 'n', 's', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'T', 'y', 'p', 'e', 'C', 'a', 't', 'e', 'g', 'o', 'r', 'y', 0,
    'A', 's', 'y', 'n', 'c', 'h', 'r', 'o', 'n', 'o', 'u', 's', 'I', 'f', 'N', 'e', 's', 't', 'e', 'd', 0,
    'n', 'o', 't', 'i', 'f', 'y', 'O', 'n', 'V', 'a', 'l', 'u', 'e', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'i', 'n', 'c', 'u', 'b', 'a', 't', 'i', 'o', 'n', 'C', 'o', 'n', 't', 'r', 'o', 'l', 'l', 'e', 'r', 0,
    'n', 'e', 't', 'w', 'o', 'r', 'k', 'A', 'c', 'c', 'e', 's', 's', 'M', 'a', 'n', 'a', 'g', 'e', 'r', 0,
    'T', 'r', 'a', 'n', 's', 'l', 'a', 't', 'i', 'o', 'n', 'E', 'x', 't', 'e', 'n', 's', 'i', 'o', 'n', 0,
    'Q', 'J', 'S', 'E', 'n', 'g', 'i', 'n', 'e', ':', ':', 'E', 'x', 't', 'e', 'n', 's', 'i', 'o', 'n', 0,
    'Q', 'L', 'i', 's', 't', '<', 'Q', 'Q', 'm', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', '>', 0,
    'q', 'm', 'l', 'R', 'e', 'g', 'i', 's', 't', 'e', 'r', 'R', 'e', 'v', 'i', 's', 'i', 'o', 'n', 0,
    'c', 'o', 'n', 'n', 'e', 'c', 't', 'N', 'o', 't', 'i', 'f', 'y', 'S', 'i', 'g', 'n', 'a', 'l', 0,
    'Q', 'Q', 'm', 'l', 'E', 'x', 't', 'e', 'n', 's', 'i', 'o', 'n', 'P', 'l', 'u', 'g', 'i', 'n', 0,
    'J', 'a', 'v', 'a', 'S', 'c', 'r', 'i', 'p', 't', 'O', 'w', 'n', 'e', 'r', 's', 'h', 'i', 'p', 0,
    's', 'e', 't', 'C', 'o', 'n', 't', 'e', 'x', 't', 'F', 'o', 'r', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'r', 'e', 'm', 'o', 'v', 'e', 'I', 'm', 'a', 'g', 'e', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 0,
    'c', 'l', 'e', 'a', 'r', 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n', 't', 'C', 'a', 'c', 'h', 'e', 0,
    'a', 't', 't', 'a', 'c', 'h', 'e', 'd', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's', 0,
    'i', 's', 'U', 'n', 'd', 'e', 'f', 'i', 'n', 'e', 'd', 'L', 'i', 't', 'e', 'r', 'a', 'l', 0,
    'Q', 'Q', 'm', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', ':', ':', 'T', 'y', 'p', 'e', 0,
    's', 'e', 't', 'O', 'b', 'j', 'e', 'c', 't', 'O', 'w', 'n', 'e', 'r', 's', 'h', 'i', 'p', 0,
    'o', 'f', 'f', 'l', 'i', 'n', 'e', 'S', 't', 'o', 'r', 'a', 'g', 'e', 'P', 'a', 't', 'h', 0,
    't', 'r', 'i', 'm', 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n', 't', 'C', 'a', 'c', 'h', 'e', 0,
    's', 'e', 't', 'C', 'o', 'n', 't', 'e', 'x', 't', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'n', 'e', 'e', 'd', 's', 'N', 'o', 't', 'i', 'f', 'y', 'S', 'i', 'g', 'n', 'a', 'l', 0,
    'c', 'o', 'm', 'p', 'o', 'n', 'e', 'n', 't', 'C', 'o', 'm', 'p', 'l', 'e', 't', 'e', 0,
    'Q', 'Q', 'm', 'l', 'L', 'i', 's', 't', 'R', 'e', 'f', 'e', 'r', 'e', 'n', 'c', 'e', 0,
    's', 'e', 't', 'S', 'o', 'u', 'r', 'c', 'e', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', 0,
    's', 'e', 't', 'P', 'l', 'u', 'g', 'i', 'n', 'P', 'a', 't', 'h', 'L', 'i', 's', 't', 0,
    's', 'e', 't', 'I', 'm', 'p', 'o', 'r', 't', 'P', 'a', 't', 'h', 'L', 'i', 's', 't', 0,
    'P', 'r', 'e', 'f', 'e', 'r', 'S', 'y', 'n', 'c', 'h', 'r', 'o', 'n', 'o', 'u', 's', 0,
    'c', 'a', 'l', 'l', 'A', 's', 'C', 'o', 'n', 's', 't', 'r', 'u', 'c', 't', 'o', 'r', 0,
    'i', 'n', 's', 't', 'a', 'l', 'l', 'E', 'x', 't', 'e', 'n', 's', 'i', 'o', 'n', 's', 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,
    's', 'e', 't', 'E', 'x', 't', 'r', 'a', 'S', 'e', 'l', 'e', 'c', 't', 'o', 'r', 's', 0,
    's', 'i', 'p', '.', 's', 'i', 'm', 'p', 'l', 'e', 'w', 'r', 'a', 'p', 'p', 'e', 'r', 0,
    'Q', 'L', 'i', 's', 't', '<', 'Q', 'Q', 'm', 'l', 'E', 'r', 'r', 'o', 'r', '>', 0,
    'Q', 'Q', 'm', 'l', 'S', 'c', 'r', 'i', 'p', 't', 'S', 't', 'r', 'i', 'n', 'g', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'T', 'y', 'p', 'e', 'N', 'a', 'm', 'e', 0,
    'i', 's', 'S', 'i', 'g', 'n', 'a', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'Q', 'Q', 'm', 'l', 'P', 'a', 'r', 's', 'e', 'r', 'S', 't', 'a', 't', 'u', 's', 0,
    'Q', 'Q', 'm', 'l', 'F', 'i', 'l', 'e', 'S', 'e', 'l', 'e', 'c', 't', 'o', 'r', 0,
    'i', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'E', 'n', 'g', 'i', 'n', 'e', 0,
    'v', 'a', 'l', 'u', 'e', 'I', 's', 'U', 'n', 'd', 'e', 'f', 'i', 'n', 'e', 'd', 0,
    'c', 'o', 'n', 't', 'e', 'x', 't', 'F', 'o', 'r', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'a', 'd', 'd', 'I', 'm', 'a', 'g', 'e', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 0,
    's', 'e', 't', 'C', 'o', 'n', 't', 'e', 'x', 't', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'Q', 'J', 'S', 'V', 'a', 'l', 'u', 'e', 'I', 't', 'e', 'r', 'a', 't', 'o', 'r', 0,
    'c', 'a', 'l', 'l', 'W', 'i', 't', 'h', 'I', 'n', 's', 't', 'a', 'n', 'c', 'e', 0,
    'C', 'o', 'n', 's', 'o', 'l', 'e', 'E', 'x', 't', 'e', 'n', 's', 'i', 'o', 'n', 0,
    'd', 'i', 's', 'c', 'o', 'n', 'n', 'e', 'c', 't', 'N', 'o', 't', 'i', 'f', 'y', 0,
    'Q', 'L', 'i', 's', 't', '<', 'Q', 'J', 'S', 'V', 'a', 'l', 'u', 'e', '>', 0,
    'q', 'm', 'l', 'R', 'e', 'g', 'i', 's', 't', 'e', 'r', 'T', 'y', 'p', 'e', 0,
    'Q', 'Q', 'm', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'M', 'a', 'p', 0,
    'I', 'n', 'v', 'a', 'l', 'i', 'd', 'C', 'a', 't', 'e', 'g', 'o', 'r', 'y', 0,
    'l', 'i', 's', 't', 'E', 'l', 'e', 'm', 'e', 'n', 't', 'T', 'y', 'p', 'e', 0,
    'f', 'o', 'r', 'c', 'e', 'C', 'o', 'm', 'p', 'l', 'e', 't', 'i', 'o', 'n', 0,
    'o', 'b', 'j', 'e', 'c', 't', 'O', 'w', 'n', 'e', 'r', 's', 'h', 'i', 'p', 0,
    'c', 'o', 'n', 't', 'e', 'x', 't', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'p', 'r', 'o', 'g', 'r', 'e', 's', 's', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'c', 'r', 'e', 'a', 't', 'i', 'o', 'n', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    's', 'e', 't', 'I', 'n', 'i', 't', 'i', 'a', 'l', 'S', 't', 'a', 't', 'e', 0,
    'h', 'a', 's', 'N', 'o', 't', 'i', 'f', 'y', 'S', 'i', 'g', 'n', 'a', 'l', 0,
    'b', 'o', 'o', 'l', 'e', 'a', 'n', 'L', 'i', 't', 'e', 'r', 'a', 'l', 0,
    'i', 'n', 'c', 'u', 'b', 'a', 't', 'i', 'o', 'n', 'M', 'o', 'd', 'e', 0,
    'Q', 'Q', 'm', 'l', 'E', 'x', 'p', 'r', 'e', 's', 's', 'i', 'o', 'n', 0,
    's', 'e', 't', 'M', 'e', 's', 's', 'a', 'g', 'e', 'T', 'y', 'p', 'e', 0,
    'a', 'd', 'd', 'N', 'a', 'm', 'e', 'd', 'B', 'u', 'n', 'd', 'l', 'e', 0,
    'p', 'l', 'u', 'g', 'i', 'n', 'P', 'a', 't', 'h', 'L', 'i', 's', 't', 0,
    'i', 'm', 'p', 'o', 'r', 't', 'P', 'a', 't', 'h', 'L', 'i', 's', 't', 0,
    'c', 'o', 'm', 'p', 'l', 'e', 't', 'e', 'C', 'r', 'e', 'a', 't', 'e', 0,
    'J', 'a', 'v', 'a', 'S', 'c', 'r', 'i', 'p', 't', 'F', 'i', 'l', 'e', 0,
    'd', 'e', 'l', 'e', 't', 'e', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'h', 'a', 's', 'O', 'w', 'n', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    's', 't', 'r', 'i', 'c', 't', 'l', 'y', 'E', 'q', 'u', 'a', 'l', 's', 0,
    'U', 'n', 'd', 'e', 'f', 'i', 'n', 'e', 'd', 'V', 'a', 'l', 'u', 'e', 0,
    'n', 'e', 'w', 'Q', 'M', 'e', 't', 'a', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'c', 'o', 'l', 'l', 'e', 'c', 't', 'G', 'a', 'r', 'b', 'a', 'g', 'e', 0,
    's', 'e', 't', 'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'i', 'o', 'n', 0,
    'n', 'u', 'm', 'b', 'e', 'r', 'L', 'i', 't', 'e', 'r', 'a', 'l', 0,
    's', 't', 'r', 'i', 'n', 'g', 'L', 'i', 't', 'e', 'r', 'a', 'l', 0,
    'i', 's', 'N', 'u', 'l', 'l', 'L', 'i', 't', 'e', 'r', 'a', 'l', 0,
    'i', 's', 'M', 'a', 'n', 'i', 'p', 'u', 'l', 'a', 'b', 'l', 'e', 0,
    'Q', 'Q', 'm', 'l', 'I', 'n', 'c', 'u', 'b', 'a', 't', 'o', 'r', 0,
    'r', 'e', 'g', 'i', 's', 't', 'e', 'r', 'T', 'y', 'p', 'e', 's', 0,
    's', 'e', 't', 'E', 'x', 'p', 'r', 'e', 's', 's', 'i', 'o', 'n', 0,
    'i', 'm', 'a', 'g', 'e', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 0,
    'a', 'd', 'd', 'P', 'l', 'u', 'g', 'i', 'n', 'P', 'a', 't', 'h', 0,
    'a', 'd', 'd', 'I', 'm', 'p', 'o', 'r', 't', 'P', 'a', 't', 'h', 0,
    'I', 'm', 'a', 'g', 'e', 'R', 'e', 's', 'p', 'o', 'n', 's', 'e', 0,
    'n', 'a', 'm', 'e', 'F', 'o', 'r', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'c', 'o', 'n', 't', 'e', 'x', 't', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'p', 'a', 'r', 'e', 'n', 't', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    's', 't', 'a', 't', 'u', 's', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'Q', 'Q', 'm', 'l', 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n', 't', 0,
    'o', 'b', 'j', 'e', 'c', 't', 'C', 'r', 'e', 'a', 't', 'e', 'd', 0,
    'A', 'l', 'l', 'E', 'x', 't', 'e', 'n', 's', 'i', 'o', 'n', 's', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 't', 'y', 'T', 'y', 'p', 'e', 0,
    'Q', 'Q', 'm', 'l', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'C', 'p', 'p', 'O', 'w', 'n', 'e', 'r', 's', 'h', 'i', 'p', 0,
    'i', 'm', 'p', 'o', 'r', 't', 'P', 'l', 'u', 'g', 'i', 'n', 0,
    'A', 's', 'y', 'n', 'c', 'h', 'r', 'o', 'n', 'o', 'u', 's', 0,
    's', 'e', 't', 'P', 'r', 'o', 't', 'o', 't', 'y', 'p', 'e', 0,
    'g', 'l', 'o', 'b', 'a', 'l', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 'N', 'u', 'm', 'b', 'e', 'r', 0,
    'v', 'a', 'l', 'u', 'e', 'C', 'h', 'a', 'n', 'g', 'e', 'd', 0,
    'i', 's', 'R', 'e', 's', 'e', 't', 't', 'a', 'b', 'l', 'e', 0,
    'i', 's', 'D', 'e', 's', 'i', 'g', 'n', 'a', 'b', 'l', 'e', 0,
    'u', 'p', 'd', 'a', 't', 'e', 'V', 'a', 'l', 'u', 'e', 0,
    'i', 'n', 'c', 'u', 'b', 'a', 't', 'e', 'F', 'o', 'r', 0,
    's', 'e', 't', 'S', 'e', 'l', 'e', 'c', 't', 'o', 'r', 0,
    's', 'c', 'o', 'p', 'e', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'm', 'e', 's', 's', 'a', 'g', 'e', 'T', 'y', 'p', 'e', 0,
    'r', 'o', 'o', 't', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    'r', 'e', 's', 'o', 'l', 'v', 'e', 'd', 'U', 'r', 'l', 0,
    'Q', 'Q', 'm', 'l', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    'b', 'e', 'g', 'i', 'n', 'C', 'r', 'e', 'a', 't', 'e', 0,
    'r', 'o', 'o', 't', 'O', 'b', 'j', 'e', 'c', 't', 's', 0,
    'h', 'a', 's', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'c', 'u', 's', 't', 'o', 'm', 'E', 'v', 'e', 'n', 't', 0,
    's', 'e', 't', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'e', 'v', 'e', 'n', 't', 'F', 'i', 'l', 't', 'e', 'r', 0,
    'i', 's', 'U', 'n', 'd', 'e', 'f', 'i', 'n', 'e', 'd', 0,
    'd', 'e', 's', 'c', 'r', 'i', 'p', 't', 'i', 'o', 'n', 0,
    '_', '_', 'g', 'e', 't', 'i', 't', 'e', 'm', '_', '_', 0,
    'P', 'y', 'Q', 't', '5', '.', 'Q', 't', 'Q', 'm', 'l', 0,
    'i', 's', 'P', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'c', 'l', 'a', 's', 's', 'B', 'e', 'g', 'i', 'n', 0,
    's', 'o', 'u', 'r', 'c', 'e', 'F', 'i', 'l', 'e', 0,
    'e', 'x', 'p', 'r', 'e', 's', 's', 'i', 'o', 'n', 0,
    's', 'e', 't', 'B', 'a', 's', 'e', 'U', 'r', 'l', 0,
    'f', 'o', 'r', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    'Q', 'Q', 'm', 'l', 'E', 'n', 'g', 'i', 'n', 'e', 0,
    'Q', 'm', 'l', 'd', 'i', 'r', 'F', 'i', 'l', 'e', 0,
    'i', 's', 'C', 'a', 'l', 'l', 'a', 'b', 'l', 'e', 0,
    'n', 'e', 'w', 'Q', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'l', 'i', 'n', 'e', 'N', 'u', 'm', 'b', 'e', 'r', 0,
    'c', 'l', 'e', 'a', 'r', 'E', 'r', 'r', 'o', 'r', 0,
    'c', 'h', 'i', 'l', 'd', 'E', 'v', 'e', 'n', 't', 0,
    't', 'i', 'm', 'e', 'r', 'E', 'v', 'e', 'n', 't', 0,
    't', 'o', 'D', 'a', 't', 'e', 'T', 'i', 'm', 'e', 0,
    'i', 's', 'W', 'r', 'i', 't', 'a', 'b', 'l', 'e', 0,
    'i', 's', 'R', 'e', 'a', 'd', 'a', 'b', 'l', 'e', 0,
    '_', '_', 'i', 'n', 'v', 'e', 'r', 't', '_', '_', 0,
    's', 'e', 't', 'T', 'a', 'r', 'g', 'e', 't', 0,
    'c', 'a', 'n', 'A', 'p', 'p', 'e', 'n', 'd', 0,
    's', 'e', 't', 'C', 'o', 'l', 'u', 'm', 'n', 0,
    'Q', 'Q', 'm', 'l', 'E', 'r', 'r', 'o', 'r', 0,
    'i', 'm', 'a', 'g', 'e', 'T', 'y', 'p', 'e', 0,
    'i', 's', 'L', 'o', 'a', 'd', 'i', 'n', 'g', 0,
    'i', 'n', 't', 'e', 'r', 'c', 'e', 'p', 't', 0,
    'U', 'r', 'l', 'S', 't', 'r', 'i', 'n', 'g', 0,
    'p', 'r', 'o', 't', 'o', 't', 'y', 'p', 'e', 0,
    't', 'o', 'Q', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'i', 's', 'Q', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'i', 's', 'V', 'a', 'r', 'i', 'a', 'n', 't', 0,
    'N', 'u', 'l', 'l', 'V', 'a', 'l', 'u', 'e', 0,
    'q', 'j', 's', 'E', 'n', 'g', 'i', 'n', 'e', 0,
    'n', 'e', 'w', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'Q', 'J', 'S', 'E', 'n', 'g', 'i', 'n', 'e', 0,
    'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', 0,
    'r', 'e', 'c', 'e', 'i', 'v', 'e', 'r', 's', 0,
    's', 'e', 't', 'O', 'b', 'j', 'e', 'c', 't', 0,
    't', 'o', 'V', 'a', 'r', 'i', 'a', 'n', 't', 0,
    'p', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 0,
    'c', 'a', 'n', 'C', 'o', 'u', 'n', 't', 0,
    'c', 'a', 'n', 'C', 'l', 'e', 'a', 'r', 0,
    's', 'e', 'l', 'e', 'c', 't', 'o', 'r', 0,
    'w', 'a', 'r', 'n', 'i', 'n', 'g', 's', 0,
    'l', 'o', 'a', 'd', 'D', 'a', 't', 'a', 0,
    't', 'o', 'N', 'u', 'm', 'b', 'e', 'r', 0,
    'i', 's', 'R', 'e', 'g', 'E', 'x', 'p', 0,
    'i', 's', 'N', 'u', 'm', 'b', 'e', 'r', 0,
    'Q', 'J', 'S', 'V', 'a', 'l', 'u', 'e', 0,
    'n', 'e', 'w', 'A', 'r', 'r', 'a', 'y', 0,
    'e', 'v', 'a', 'l', 'u', 'a', 't', 'e', 0,
    'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g', 0,
    'p', 'r', 'o', 't', 'o', 'c', 'o', 'l', 0,
    'h', 'a', 's', 'E', 'r', 'r', 'o', 'r', 0,
    'n', 'a', 'm', 'e', 'T', 'y', 'p', 'e', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'i', 's', 'S', 't', 'r', 'i', 'n', 'g', 0,
    'i', 's', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'p', 'r', 'o', 'g', 'r', 'e', 's', 's', 0,
    'f', 'i', 'l', 'e', 'N', 'a', 'm', 'e', 0,
    't', 'o', 'S', 't', 'r', 'i', 'n', 'g', 0,
    'c', 'o', 'n', 't', 'a', 'i', 'n', 's', 0,
    '_', '_', 'h', 'a', 's', 'h', '_', '_', 0,
    '_', '_', 'b', 'o', 'o', 'l', '_', '_', 0,
    '_', '_', 'i', 'x', 'o', 'r', '_', '_', 0,
    '_', '_', 'i', 'a', 'n', 'd', '_', '_', 0,
    'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    'b', 'a', 's', 'e', 'U', 'r', 'l', 0,
    'l', 'o', 'a', 'd', 'U', 'r', 'l', 0,
    'Q', 'm', 'l', 'F', 'i', 'l', 'e', 0,
    'i', 's', 'E', 'r', 'r', 'o', 'r', 0,
    'I', 'n', 'v', 'a', 'l', 'i', 'd', 0,
    'i', 's', 'R', 'e', 'a', 'd', 'y', 0,
    's', 'e', 't', 'L', 'i', 'n', 'e', 0,
    'i', 's', 'A', 'r', 'r', 'a', 'y', 0,
    'h', 'a', 's', 'N', 'e', 'x', 't', 0,
    'f', 'i', 'l', 't', 'e', 'r', 's', 0,
    'e', 'n', 'a', 'b', 'l', 'e', 'd', 0,
    'c', 'o', 'n', 't', 'e', 'x', 't', 0,
    'o', 'p', 't', 'i', 'o', 'n', 's', 0,
    'i', 's', 'E', 'm', 'p', 't', 'y', 0,
    '_', '_', 'l', 'e', 'n', '_', '_', 0,
    's', 'e', 't', 'D', 'a', 't', 'a', 0,
    'i', 's', 'V', 'a', 'l', 'i', 'd', 0,
    '_', '_', 'x', 'o', 'r', '_', '_', 0,
    '_', '_', 'i', 'o', 'r', '_', '_', 0,
    '_', '_', 'a', 'n', 'd', '_', '_', 0,
    '_', '_', 'i', 'n', 't', '_', '_', 0,
    'N', 'o', 'r', 'm', 'a', 'l', 0,
    'e', 'n', 'g', 'i', 'n', 'e', 0,
    'e', 'q', 'u', 'a', 'l', 's', 0,
    'i', 's', 'D', 'a', 't', 'e', 0,
    'e', 'r', 'r', 'o', 'r', 's', 0,
    'P', 'i', 'x', 'm', 'a', 'p', 0,
    's', 'e', 't', 'U', 'r', 'l', 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,
    't', 'o', 'B', 'o', 'o', 'l', 0,
    'i', 's', 'B', 'o', 'o', 'l', 0,
    's', 'u', 'f', 'f', 'i', 'x', 0,
    'p', 'r', 'e', 'f', 'i', 'x', 0,
    's', 't', 'a', 't', 'u', 's', 0,
    'd', 'e', 'v', 'i', 'c', 'e', 0,
    'm', 'e', 't', 'h', 'o', 'd', 0,
    'l', 'o', 'c', 'a', 'l', 'e', 0,
    'f', 'o', 'r', 'm', 'a', 't', 0,
    't', 'o', 'U', 'I', 'n', 't', 0,
    'i', 'n', 's', 'e', 'r', 't', 0,
    'a', 'p', 'p', 'e', 'n', 'd', 0,
    'l', 'e', 'n', 'g', 't', 'h', 0,
    'i', 's', 'N', 'u', 'l', 'l', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 0,
    'o', 'b', 'j', 'e', 'c', 't', 0,
    'p', 'a', 'r', 'e', 'n', 't', 0,
    '_', '_', 'n', 'e', '_', '_', 0,
    '_', '_', 'e', 'q', '_', '_', 0,
    '_', '_', 'o', 'r', '_', '_', 0,
    'c', 'a', 'n', 'A', 't', 0,
    'I', 'm', 'a', 'g', 'e', 0,
    's', 'c', 'o', 'p', 'e', 0,
    'w', 'r', 'i', 't', 'e', 0,
    'e', 'r', 'r', 'o', 'r', 0,
    'r', 'e', 's', 'e', 't', 0,
    't', 'o', 'I', 'n', 't', 0,
    'c', 'l', 'e', 'a', 'r', 0,
    'c', 'o', 'u', 'n', 't', 0,
    'v', 'a', 'l', 'u', 'e', 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,
    'c', 'a', 'l', 'l', 0,
    'a', 'r', 'g', 's', 0,
    'p', 'o', 'r', 't', 0,
    'k', 'e', 'y', 's', 0,
    'l', 'i', 'n', 'e', 0,
    'l', 'o', 'a', 'd', 0,
    'r', 'e', 'a', 'd', 0,
    'n', 'e', 'x', 't', 0,
    'q', 'u', 'i', 't', 0,
    'e', 'x', 'i', 't', 0,
    'm', 'o', 'd', 'e', 0,
    'n', 'a', 'm', 'e', 0,
    'b', 'a', 's', 'e', 0,
    's', 'i', 'z', 'e', 0,
    'f', 'r', 'o', 'm', 0,
    's', 'o', 'r', 't', 0,
    'u', 'r', 'l', 0,
};
#line 24 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsengine.sip"
#include <qjsengine.h>
#line 113 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlproperty.sip"
// Imports from QtCore.
pyqt5_qtqml_get_connection_parts_t pyqt5_qtqml_get_connection_parts;
#line 27 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qmlregistertype.sip"
// Imports from QtCore.
pyqt5_qtqml_get_qmetaobject_t pyqt5_qtqml_get_qmetaobject;
#line 424 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

void sipVH_QtQml_18(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const  ::QQmlProperty& a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "N", new  ::QQmlProperty(a0), sipType_QQmlProperty, NULL);
}

 ::QVariant sipVH_QtQml_17(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const  ::QString& a0,const  ::QVariant& a1)
{
     ::QVariant sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "NN", new  ::QString(a0), sipType_QString, NULL, new  ::QVariant(a1), sipType_QVariant, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QVariant, &sipRes);

    return sipRes;
}

 ::QNetworkAccessManager* sipVH_QtQml_16(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QObject*a0)
{
     ::QNetworkAccessManager* sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "D", a0, sipType_QObject, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H2", sipType_QNetworkAccessManager, &sipRes);

    return sipRes;
}

void sipVH_QtQml_15(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, int a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "i", a0);
}

void sipVH_QtQml_14(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QObject*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QObject, NULL);
}

void sipVH_QtQml_13(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QQmlIncubator::Status a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "F", a0, sipType_QQmlIncubator_Status);
}

void sipVH_QtQml_12(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QQmlEngine*a0,const char*a1)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "Ds", a0, sipType_QQmlEngine, NULL, a1);
}

void sipVH_QtQml_11(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const char*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "s", a0);
}

 ::QQmlImageProviderBase::Flags sipVH_QtQml_10(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
     ::QQmlImageProviderBase::Flags sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QQmlImageProviderBase_Flags, &sipRes);

    return sipRes;
}

 ::QQmlImageProviderBase::ImageType sipVH_QtQml_9(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
     ::QQmlImageProviderBase::ImageType sipRes = ( ::QQmlImageProviderBase::ImageType)0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "F", sipType_QQmlImageProviderBase_ImageType, &sipRes);

    return sipRes;
}

void sipVH_QtQml_8(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "");
}

 ::QObject* sipVH_QtQml_7(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QQmlContext*a0)
{
     ::QObject* sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "D", a0, sipType_QQmlContext, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H2", sipType_QObject, &sipRes);

    return sipRes;
}

 ::QUrl sipVH_QtQml_6(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const  ::QUrl& a0, ::QQmlAbstractUrlInterceptor::DataType a1)
{
     ::QUrl sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "NF", new  ::QUrl(a0), sipType_QUrl, NULL, a1, sipType_QQmlAbstractUrlInterceptor_DataType);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QUrl, &sipRes);

    return sipRes;
}

bool sipVH_QtQml_5(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QEvent*a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "D", a0, sipType_QEvent, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

bool sipVH_QtQml_4(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QObject*a0, ::QEvent*a1)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "DD", a0, sipType_QObject, NULL, a1, sipType_QEvent, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

void sipVH_QtQml_3(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QTimerEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QTimerEvent, NULL);
}

void sipVH_QtQml_2(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QChildEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QChildEvent, NULL);
}

void sipVH_QtQml_1(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QEvent, NULL);
}

void sipVH_QtQml_0(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const  ::QMetaMethod& a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "N", new  ::QMetaMethod(a0), sipType_QMetaMethod, NULL);
}


PyDoc_STRVAR(doc_qmlRegisterUncreatableType, "qmlRegisterUncreatableType(type, str, int, int, str, str) -> int\n"
    "qmlRegisterUncreatableType(type, int, str, int, int, str, str) -> int");

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

    {
        PyObject * a0;
        const char* a1;
        int a2;
        int a3;
        const char* a4;
        const  ::QString* a5;
        int a5State = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "TsiisJ1", &PyType_Type, &a0, &a1, &a2, &a3, &a4, sipType_QString,&a5, &a5State))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 92 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qmlregistertype.sip"
    if ((sipRes = qpyqml_register_uncreatable_type((PyTypeObject *)a0, a1, a2, a3, a4, *a5, -1)) < 0)
        sipError = sipErrorFail;
#line 589 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
            sipReleaseType(const_cast< ::QString *>(a5),sipType_QString,a5State);

            if (sipError == sipErrorFail)
                return 0;

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

            sipAddException(sipError, &sipParseErr);
        }
    }

    {
        PyObject * a0;
        int a1;
        const char* a2;
        int a3;
        int a4;
        const char* a5;
        const  ::QString* a6;
        int a6State = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "TisiisJ1", &PyType_Type, &a0, &a1, &a2, &a3, &a4, &a5, sipType_QString,&a6, &a6State))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 100 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qmlregistertype.sip"
    if ((sipRes = qpyqml_register_uncreatable_type((PyTypeObject *)a0, a2, a3, a4, a5, *a6, a1)) < 0)
        sipError = sipErrorFail;
#line 622 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
            sipReleaseType(const_cast< ::QString *>(a6),sipType_QString,a6State);

            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. */
    sipNoFunction(sipParseErr, sipName_qmlRegisterUncreatableType, doc_qmlRegisterUncreatableType);

    return NULL;
}


PyDoc_STRVAR(doc_qmlRegisterType, "qmlRegisterType(QUrl, str, int, int, str) -> int\n"
    "qmlRegisterType(type, attachedProperties: type = 0) -> int\n"
    "qmlRegisterType(type, str, int, int, str, attachedProperties: type = 0) -> int\n"
    "qmlRegisterType(type, int, str, int, int, str, attachedProperties: type = 0) -> int");

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

    {
        const  ::QUrl* a0;
        const char* a1;
        int a2;
        int a3;
        const char* a4;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "J9siis", sipType_QUrl, &a0, &a1, &a2, &a3, &a4))
        {
            int sipRes;

            sipRes = qmlRegisterType(*a0,a1,a2,a3,a4);

            return SIPLong_FromLong(sipRes);
        }
    }

    {
        PyObject * a0;
        PyObject * a1 = 0;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "T|T", &PyType_Type, &a0, &PyType_Type, &a1))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 68 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qmlregistertype.sip"
    if ((sipRes = qpyqml_register_type((PyTypeObject *)a0, (PyTypeObject *)a1)) < 0)
        sipError = sipErrorFail;
#line 692 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

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

            sipAddException(sipError, &sipParseErr);
        }
    }

    {
        PyObject * a0;
        const char* a1;
        int a2;
        int a3;
        const char* a4;
        PyObject * a5 = 0;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Tsiis|T", &PyType_Type, &a0, &a1, &a2, &a3, &a4, &PyType_Type, &a5))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 76 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qmlregistertype.sip"
    if ((sipRes = qpyqml_register_library_type((PyTypeObject *)a0, a1, a2, a3, a4, -1, (PyTypeObject *)a5)) < 0)
        sipError = sipErrorFail;
#line 731 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

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

            sipAddException(sipError, &sipParseErr);
        }
    }

    {
        PyObject * a0;
        int a1;
        const char* a2;
        int a3;
        int a4;
        const char* a5;
        PyObject * a6 = 0;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Tisiis|T", &PyType_Type, &a0, &a1, &a2, &a3, &a4, &a5, &PyType_Type, &a6))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 84 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qmlregistertype.sip"
    if ((sipRes = qpyqml_register_library_type((PyTypeObject *)a0, a2, a3, a4, a5, a1, (PyTypeObject *)a6)) < 0)
        sipError = sipErrorFail;
#line 772 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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. */
    sipNoFunction(sipParseErr, sipName_qmlRegisterType, doc_qmlRegisterType);

    return NULL;
}


PyDoc_STRVAR(doc_qmlRegisterSingletonType, "qmlRegisterSingletonType(QUrl, str, int, int, str) -> int\n"
    "qmlRegisterSingletonType(type, str, int, int, str, Callable[[], Any]) -> int");

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

    {
        const  ::QUrl* a0;
        const char* a1;
        int a2;
        int a3;
        const char* a4;

        if (sipParseArgs(&sipParseErr, sipArgs, "J9siis", sipType_QUrl, &a0, &a1, &a2, &a3, &a4))
        {
            int sipRes;

            sipRes = qmlRegisterSingletonType(*a0,a1,a2,a3,a4);

            return SIPLong_FromLong(sipRes);
        }
    }

    {
        PyObject * a0;
        const char* a1;
        int a2;
        int a3;
        const char* a4;
        PyObject * a5;

        if (sipParseArgs(&sipParseErr, sipArgs, "TsiisF", &PyType_Type, &a0, &a1, &a2, &a3, &a4, &a5))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 57 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qmlregistertype.sip"
    if ((sipRes = qpyqml_register_singleton_type((PyTypeObject *)a0, a1, a2, a3, a4, a5)) < 0)
        sipError = sipErrorFail;
#line 836 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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. */
    sipNoFunction(sipParseErr, sipName_qmlRegisterSingletonType, doc_qmlRegisterSingletonType);

    return NULL;
}


PyDoc_STRVAR(doc_qmlRegisterRevision, "qmlRegisterRevision(type, int, str, int, int, attachedProperties: type = 0) -> int");

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

    {
        PyObject * a0;
        int a1;
        const char* a2;
        int a3;
        int a4;
        PyObject * a5 = 0;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Tisii|T", &PyType_Type, &a0, &a1, &a2, &a3, &a4, &PyType_Type, &a5))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 43 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qmlregistertype.sip"
    if ((sipRes = qpyqml_register_library_type((PyTypeObject *)a0, a2, a3, a4, 0, a1, (PyTypeObject *)a5)) < 0)
        sipError = sipErrorFail;
#line 890 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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. */
    sipNoFunction(sipParseErr, sipName_qmlRegisterRevision, doc_qmlRegisterRevision);

    return NULL;
}


PyDoc_STRVAR(doc_qmlAttachedPropertiesObject, "qmlAttachedPropertiesObject(type, QObject, create: bool = True) -> QObject");

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

    {
        PyObject * a0;
         ::QObject* a1;
        bool a2 = 1;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "TJ8|b", &PyType_Type, &a0, sipType_QObject, &a1, &a2))
        {
             ::QObject*sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 29 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qmlattachedpropertiesobject.sip"
    QObject *proxy = qpyqml_find_proxy_for(a1);

    if (!proxy)
    {
        sipError = sipErrorFail;
    }
    else
    {
        static QHash<PyTypeObject *, int> cache;

        int idx = cache.value((PyTypeObject *)a0, -1);
        const QMetaObject *mo = pyqt5_qtqml_get_qmetaobject((PyTypeObject *)a0);

        sipRes = qmlAttachedPropertiesObject(&idx, proxy, mo, a2);

        cache.insert((PyTypeObject *)a0, idx);
    }
#line 953 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return sipConvertFromType(sipRes,sipType_QObject,NULL);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_qmlAttachedPropertiesObject, doc_qmlAttachedPropertiesObject);

    return NULL;
}


PyDoc_STRVAR(doc_qjsEngine, "qjsEngine(QObject) -> QJSEngine");

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

    {
        const  ::QObject* a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8", sipType_QObject, &a0))
        {
             ::QJSEngine*sipRes;

            sipRes = qjsEngine(a0);

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_qjsEngine, doc_qjsEngine);

    return NULL;
}


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

#line 34 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsengine.sip"
    static struct class_graph {
        const char *name;
        sipTypeDef **type;
        int yes, no;
    } graph[] = {
        {sipName_QQmlExpression, &sipType_QQmlExpression, -1, 1},
    #if QT_VERSION >= 0x050200
        {sipName_QQmlFileSelector, &sipType_QQmlFileSelector, -1, 2},
    #else
        {0, 0, -1, 2},
    #endif
        {sipName_QQmlContext, &sipType_QQmlContext, -1, 3},
        {sipName_QQmlPropertyMap, &sipType_QQmlPropertyMap, -1, 4},
        {sipName_QQmlComponent, &sipType_QQmlComponent, -1, 5},
        {sipName_QQmlExtensionPlugin, &sipType_QQmlExtensionPlugin, -1, 6},
        {sipName_QJSEngine, &sipType_QJSEngine, 7, -1},
        {sipName_QQmlEngine, &sipType_QQmlEngine, 8, -1},
    #if QT_VERSION >= 0x050100
        {sipName_QQmlApplicationEngine, &sipType_QQmlApplicationEngine, -1, -1},
    #else
        {0, 0, -1, -1},
    #endif
    };
    
    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 1051 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

    return sipType;
}


extern "C" {static PyObject *slot_QQmlImageProviderBase_Flag___or__(PyObject *,PyObject *);}
static PyObject *slot_QQmlImageProviderBase_Flag___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QQmlImageProviderBase::Flag a0;
         ::QQmlImageProviderBase::Flags* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "EJ1", sipType_QQmlImageProviderBase_Flag, &a0, sipType_QQmlImageProviderBase_Flags, &a1, &a1State))
        {
             ::QQmlImageProviderBase::Flags*sipRes;

            sipRes = new  ::QQmlImageProviderBase::Flags((a0 | *a1));
            sipReleaseType(a1,sipType_QQmlImageProviderBase_Flags,a1State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

static sipPySlotDef slots_QQmlImageProviderBase_Flag[] = {
    {(void *)slot_QQmlImageProviderBase_Flag___or__, or_slot},
    {0, (sipPySlotType)0}
};



extern "C" {static PyObject *slot_QJSEngine_Extension___or__(PyObject *,PyObject *);}
static PyObject *slot_QJSEngine_Extension___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QJSEngine::Extension a0;
         ::QJSEngine::Extensions* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "EJ1", sipType_QJSEngine_Extension, &a0, sipType_QJSEngine_Extensions, &a1, &a1State))
        {
             ::QJSEngine::Extensions*sipRes;

            sipRes = new  ::QJSEngine::Extensions((a0 | *a1));
            sipReleaseType(a1,sipType_QJSEngine_Extensions,a1State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

static sipPySlotDef slots_QJSEngine_Extension[] = {
    {(void *)slot_QJSEngine_Extension___or__, or_slot},
    {0, (sipPySlotType)0}
};

static sipEnumTypeDef enumTypes[] = {
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QQmlProperty__Type, {0}, 0}, sipNameNr_Type, 34, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QQmlProperty__PropertyTypeCategory, {0}, 0}, sipNameNr_PropertyTypeCategory, 34, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QQmlIncubator__Status, {0}, 0}, sipNameNr_Status, 27, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QQmlIncubator__IncubationMode, {0}, 0}, sipNameNr_IncubationMode, 27, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QQmlEngine__ObjectOwnership, {0}, 0}, sipNameNr_ObjectOwnership, 16, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QQmlImageProviderBase__Flag, {0}, 0}, sipNameNr_Flag, 22, slots_QQmlImageProviderBase_Flag},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QQmlImageProviderBase__ImageType, {0}, 0}, sipNameNr_ImageType, 22, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QQmlComponent__Status, {0}, 0}, sipNameNr_Status, 12, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QQmlComponent__CompilationMode, {0}, 0}, sipNameNr_CompilationMode, 12, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QQmlAbstractUrlInterceptor__DataType, {0}, 0}, sipNameNr_DataType, 9, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QJSValue__SpecialValue, {0}, 0}, sipNameNr_SpecialValue, 3, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QJSEngine__Extension, {0}, 0}, sipNameNr_Extension, 0, slots_QJSEngine_Extension},
};


/*
 * This defines each type in this module.
 */
sipTypeDef *sipExportedTypes_QtQml[] = {
    &sipTypeDef_QtQml_QJSEngine.ctd_base,
    &enumTypes[11].etd_base,
    &sipTypeDef_QtQml_QJSEngine_Extensions.ctd_base,
    &sipTypeDef_QtQml_QJSValue.ctd_base,
    &enumTypes[10].etd_base,
    &sipTypeDef_QtQml_QJSValueIterator.ctd_base,
    &sipTypeDef_QtQml_QList_0100QJSValue.mtd_base,
    &sipTypeDef_QtQml_QList_0100QQmlError.mtd_base,
    &sipTypeDef_QtQml_QList_0100QQmlProperty.mtd_base,
    &sipTypeDef_QtQml_QQmlAbstractUrlInterceptor.ctd_base,
    &enumTypes[9].etd_base,
    &sipTypeDef_QtQml_QQmlApplicationEngine.ctd_base,
    &sipTypeDef_QtQml_QQmlComponent.ctd_base,
    &enumTypes[8].etd_base,
    &enumTypes[7].etd_base,
    &sipTypeDef_QtQml_QQmlContext.ctd_base,
    &sipTypeDef_QtQml_QQmlEngine.ctd_base,
    &enumTypes[4].etd_base,
    &sipTypeDef_QtQml_QQmlError.ctd_base,
    &sipTypeDef_QtQml_QQmlExpression.ctd_base,
    &sipTypeDef_QtQml_QQmlExtensionPlugin.ctd_base,
    &sipTypeDef_QtQml_QQmlFileSelector.ctd_base,
    &sipTypeDef_QtQml_QQmlImageProviderBase.ctd_base,
    &enumTypes[5].etd_base,
    &sipTypeDef_QtQml_QQmlImageProviderBase_Flags.ctd_base,
    &enumTypes[6].etd_base,
    &sipTypeDef_QtQml_QQmlIncubationController.ctd_base,
    &sipTypeDef_QtQml_QQmlIncubator.ctd_base,
    &enumTypes[3].etd_base,
    &enumTypes[2].etd_base,
    &sipTypeDef_QtQml_QQmlListProperty_0100QObject.mtd_base,
    &sipTypeDef_QtQml_QQmlListReference.ctd_base,
    &sipTypeDef_QtQml_QQmlNetworkAccessManagerFactory.ctd_base,
    &sipTypeDef_QtQml_QQmlParserStatus.ctd_base,
    &sipTypeDef_QtQml_QQmlProperty.ctd_base,
    &enumTypes[1].etd_base,
    &enumTypes[0].etd_base,
    &sipTypeDef_QtQml_QQmlPropertyMap.ctd_base,
    &sipTypeDef_QtQml_QQmlPropertyValueSource.ctd_base,
    &sipTypeDef_QtQml_QQmlScriptString.ctd_base,
};


/*
 * These define each typedef in this module.
 */
static sipTypedefDef typedefsTable[] = {
    {"QJSValueList", "QList<QJSValue>"},
    {"QQmlProperties", "QList<QQmlProperty>"},
};


/* This defines the types that this module needs to import from QtCore. */
sipImportedTypeDef sipImportedTypes_QtQml_QtCore[] = {
    {"QByteArray"},
    {"QChildEvent"},
    {"QDateTime"},
    {"QEvent"},
    {"QFileSelector"},
    {"QList<QObject*>"},
    {"QMetaMethod"},
    {"QMetaObject"},
    {"QMetaProperty"},
    {"QObject"},
    {"QString"},
    {"QStringList"},
    {"QTimerEvent"},
    {"QUrl"},
    {"QVariant"},
    {"QtMsgType"},
    {NULL}
};


/*
 * This defines the virtual error handlers that this module needs to import
 * from QtCore.
 */
sipImportedVirtErrorHandlerDef sipImportedVirtErrorHandlers_QtQml_QtCore[] = {
    {"PyQt5"},
    {NULL}
};


/* This defines the types that this module needs to import from QtNetwork. */
sipImportedTypeDef sipImportedTypes_QtQml_QtNetwork[] = {
    {"QNetworkAccessManager"},
    {NULL}
};


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


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


/* This defines this module. */
sipExportedModuleDef sipModuleAPI_QtQml = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt5_QtQml,
    0,
    sipStrings_QtQml,
    importsTable,
    NULL,
    40,
    sipExportedTypes_QtQml,
    NULL,
    0,
    NULL,
    2,
    typedefsTable,
    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_QtQml;

sip_qt_metaobject_func sip_QtQml_qt_metaobject;
sip_qt_metacall_func sip_QtQml_qt_metacall;
sip_qt_metacast_func sip_QtQml_qt_metacast;


/* The Python module initialisation function. */
#if PY_MAJOR_VERSION >= 3
#define SIP_MODULE_ENTRY        PyInit_QtQml
#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        initQtQml
#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[] = {
        {SIP_MLNAME_CAST(sipName_qmlRegisterUncreatableType), func_qmlRegisterUncreatableType, METH_VARARGS, SIP_MLDOC_CAST(doc_qmlRegisterUncreatableType)},
        {SIP_MLNAME_CAST(sipName_qmlRegisterType), (PyCFunction)func_qmlRegisterType, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_qmlRegisterType)},
        {SIP_MLNAME_CAST(sipName_qmlRegisterSingletonType), func_qmlRegisterSingletonType, METH_VARARGS, SIP_MLDOC_CAST(doc_qmlRegisterSingletonType)},
        {SIP_MLNAME_CAST(sipName_qmlRegisterRevision), (PyCFunction)func_qmlRegisterRevision, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_qmlRegisterRevision)},
        {SIP_MLNAME_CAST(sipName_qmlAttachedPropertiesObject), (PyCFunction)func_qmlAttachedPropertiesObject, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_qmlAttachedPropertiesObject)},
        {SIP_MLNAME_CAST(sipName_qjsEngine), func_qjsEngine, METH_VARARGS, SIP_MLDOC_CAST(doc_qjsEngine)},
        {0, 0, 0, 0}
    };

#if PY_MAJOR_VERSION >= 3
    static PyModuleDef sip_module_def = {
        PyModuleDef_HEAD_INIT,
        "PyQt5.QtQml",
        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_QtQml, sip_methods);
#else
    sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt5_QtQml), 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_QtQml = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, SIP_MODULE_NAME "._C_API"));
#else
    sipAPI_QtQml = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif

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

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

    sip_QtQml_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
    sip_QtQml_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
    sip_QtQml_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");

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

    /* Initialise the module now all its dependencies have been set up. */
    if (sipInitModule(&sipModuleAPI_QtQml,sipModuleDict) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }
#line 127 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsengine.sip"
qpyqml_post_init(sipModuleDict);
#line 118 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlproperty.sip"
// Imports from QtCore.
pyqt5_qtqml_get_connection_parts = (pyqt5_qtqml_get_connection_parts_t)sipImportSymbol("pyqt5_get_connection_parts");
Q_ASSERT(pyqt5_qtqml_get_connection_parts);
#line 33 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qmlregistertype.sip"
// Imports from QtCore.
pyqt5_qtqml_get_qmetaobject = (pyqt5_qtqml_get_qmetaobject_t)sipImportSymbol(
        "pyqt5_get_qmetaobject");
Q_ASSERT(pyqt5_qtqml_get_qmetaobject);
#line 1424 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

    SIP_MODULE_RETURN(sipModule);
}

#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1431 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlerror.sip"
#include <qqmlerror.h>
#line 1435 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


extern "C" {static void assign_QList_0100QQmlError(void *, SIP_SSIZE_T, const void *);}
static void assign_QList_0100QQmlError(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QList< ::QQmlError> *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QList< ::QQmlError> *>(sipSrc);
}


extern "C" {static void *array_QList_0100QQmlError(SIP_SSIZE_T);}
static void *array_QList_0100QQmlError(SIP_SSIZE_T sipNrElem)
{
    return new QList< ::QQmlError>[sipNrElem];
}


extern "C" {static void *copy_QList_0100QQmlError(const void *, SIP_SSIZE_T);}
static void *copy_QList_0100QQmlError(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QList< ::QQmlError>(reinterpret_cast<const QList< ::QQmlError> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QList_0100QQmlError(void *, int);}
static void release_QList_0100QQmlError(void *ptr, int)
{
    delete reinterpret_cast<QList< ::QQmlError> *>(ptr);
}



extern "C" {static int convertTo_QList_0100QQmlError(PyObject *, void **, int *, PyObject *);}
static int convertTo_QList_0100QQmlError(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QList< ::QQmlError> **sipCppPtr = reinterpret_cast<QList< ::QQmlError> **>(sipCppPtrV);

#line 68 "sip/QtCore/qpycore_qlist.sip"
    PyObject *iter = PyObject_GetIter(sipPy);

    if (!sipIsErr)
    {
        Py_XDECREF(iter);

        return (iter
#if PY_MAJOR_VERSION < 3
                && !PyString_Check(sipPy)
#endif
                && !PyUnicode_Check(sipPy));
    }

    if (!iter)
    {
        *sipIsErr = 1;

        return 0;
    }

    QList<QQmlError> *ql = new QList<QQmlError>;
 
    for (Py_ssize_t i = 0; ; ++i)
    {
        PyErr_Clear();
        PyObject *itm = PyIter_Next(iter);

        if (!itm)
        {
            if (PyErr_Occurred())
            {
                delete ql;
                Py_DECREF(iter);
                *sipIsErr = 1;

                return 0;
            }

            break;
        }

        int state;
        QQmlError *t = reinterpret_cast<QQmlError *>(
                sipForceConvertToType(itm, sipType_QQmlError, sipTransferObj,
                        SIP_NOT_NONE, &state, sipIsErr));

        if (*sipIsErr)
        {
            PyErr_Format(PyExc_TypeError,
                    "index %zd has type '%s' but 'QQmlError' is expected", i,
                    sipPyTypeName(Py_TYPE(itm)));

            Py_DECREF(itm);
            delete ql;
            Py_DECREF(iter);

            return 0;
        }

        ql->append(*t);

        sipReleaseType(t, sipType_QQmlError, state);
        Py_DECREF(itm);
    }
 
    Py_DECREF(iter);

    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 1544 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0100QQmlError(void *, PyObject *);}
static PyObject *convertFrom_QList_0100QQmlError(void *sipCppV, PyObject *sipTransferObj)
{
   QList< ::QQmlError> *sipCpp = reinterpret_cast<QList< ::QQmlError> *>(sipCppV);

#line 42 "sip/QtCore/qpycore_qlist.sip"
    PyObject *l = PyList_New(sipCpp->size());

    if (!l)
        return 0;

    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QQmlError *t = new QQmlError(sipCpp->at(i));
        PyObject *tobj = sipConvertFromNewType(t, sipType_QQmlError,
                sipTransferObj);

        if (!tobj)
        {
            delete t;
            Py_DECREF(l);

            return 0;
        }

        PyList_SetItem(l, i, tobj);
    }

    return l;
#line 1577 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtQml_QList_0100QQmlError = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_1630,     /* QList<QQmlError> */
        {0},
        0
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QQmlError,
    array_QList_0100QQmlError,
    copy_QList_0100QQmlError,
    release_QList_0100QQmlError,
    convertTo_QList_0100QQmlError,
    convertFrom_QList_0100QQmlError
};

#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1609 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlproperty.sip"
#include <qqmlproperty.h>
#line 1613 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


extern "C" {static void assign_QList_0100QQmlProperty(void *, SIP_SSIZE_T, const void *);}
static void assign_QList_0100QQmlProperty(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QList< ::QQmlProperty> *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QList< ::QQmlProperty> *>(sipSrc);
}


extern "C" {static void *array_QList_0100QQmlProperty(SIP_SSIZE_T);}
static void *array_QList_0100QQmlProperty(SIP_SSIZE_T sipNrElem)
{
    return new QList< ::QQmlProperty>[sipNrElem];
}


extern "C" {static void *copy_QList_0100QQmlProperty(const void *, SIP_SSIZE_T);}
static void *copy_QList_0100QQmlProperty(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QList< ::QQmlProperty>(reinterpret_cast<const QList< ::QQmlProperty> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QList_0100QQmlProperty(void *, int);}
static void release_QList_0100QQmlProperty(void *ptr, int)
{
    delete reinterpret_cast<QList< ::QQmlProperty> *>(ptr);
}



extern "C" {static int convertTo_QList_0100QQmlProperty(PyObject *, void **, int *, PyObject *);}
static int convertTo_QList_0100QQmlProperty(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QList< ::QQmlProperty> **sipCppPtr = reinterpret_cast<QList< ::QQmlProperty> **>(sipCppPtrV);

#line 68 "sip/QtCore/qpycore_qlist.sip"
    PyObject *iter = PyObject_GetIter(sipPy);

    if (!sipIsErr)
    {
        Py_XDECREF(iter);

        return (iter
#if PY_MAJOR_VERSION < 3
                && !PyString_Check(sipPy)
#endif
                && !PyUnicode_Check(sipPy));
    }

    if (!iter)
    {
        *sipIsErr = 1;

        return 0;
    }

    QList<QQmlProperty> *ql = new QList<QQmlProperty>;
 
    for (Py_ssize_t i = 0; ; ++i)
    {
        PyErr_Clear();
        PyObject *itm = PyIter_Next(iter);

        if (!itm)
        {
            if (PyErr_Occurred())
            {
                delete ql;
                Py_DECREF(iter);
                *sipIsErr = 1;

                return 0;
            }

            break;
        }

        int state;
        QQmlProperty *t = reinterpret_cast<QQmlProperty *>(
                sipForceConvertToType(itm, sipType_QQmlProperty, sipTransferObj,
                        SIP_NOT_NONE, &state, sipIsErr));

        if (*sipIsErr)
        {
            PyErr_Format(PyExc_TypeError,
                    "index %zd has type '%s' but 'QQmlProperty' is expected", i,
                    sipPyTypeName(Py_TYPE(itm)));

            Py_DECREF(itm);
            delete ql;
            Py_DECREF(iter);

            return 0;
        }

        ql->append(*t);

        sipReleaseType(t, sipType_QQmlProperty, state);
        Py_DECREF(itm);
    }
 
    Py_DECREF(iter);

    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 1722 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0100QQmlProperty(void *, PyObject *);}
static PyObject *convertFrom_QList_0100QQmlProperty(void *sipCppV, PyObject *sipTransferObj)
{
   QList< ::QQmlProperty> *sipCpp = reinterpret_cast<QList< ::QQmlProperty> *>(sipCppV);

#line 42 "sip/QtCore/qpycore_qlist.sip"
    PyObject *l = PyList_New(sipCpp->size());

    if (!l)
        return 0;

    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QQmlProperty *t = new QQmlProperty(sipCpp->at(i));
        PyObject *tobj = sipConvertFromNewType(t, sipType_QQmlProperty,
                sipTransferObj);

        if (!tobj)
        {
            delete t;
            Py_DECREF(l);

            return 0;
        }

        PyList_SetItem(l, i, tobj);
    }

    return l;
#line 1755 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtQml_QList_0100QQmlProperty = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_1103,     /* QList<QQmlProperty> */
        {0},
        0
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QQmlProperty,
    array_QList_0100QQmlProperty,
    copy_QList_0100QQmlProperty,
    release_QList_0100QQmlProperty,
    convertTo_QList_0100QQmlProperty,
    convertFrom_QList_0100QQmlProperty
};

#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1787 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsvalue.sip"
#include <qjsvalue.h>
#line 1791 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


extern "C" {static void assign_QList_0100QJSValue(void *, SIP_SSIZE_T, const void *);}
static void assign_QList_0100QJSValue(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QList< ::QJSValue> *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QList< ::QJSValue> *>(sipSrc);
}


extern "C" {static void *array_QList_0100QJSValue(SIP_SSIZE_T);}
static void *array_QList_0100QJSValue(SIP_SSIZE_T sipNrElem)
{
    return new QList< ::QJSValue>[sipNrElem];
}


extern "C" {static void *copy_QList_0100QJSValue(const void *, SIP_SSIZE_T);}
static void *copy_QList_0100QJSValue(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QList< ::QJSValue>(reinterpret_cast<const QList< ::QJSValue> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QList_0100QJSValue(void *, int);}
static void release_QList_0100QJSValue(void *ptr, int)
{
    delete reinterpret_cast<QList< ::QJSValue> *>(ptr);
}



extern "C" {static int convertTo_QList_0100QJSValue(PyObject *, void **, int *, PyObject *);}
static int convertTo_QList_0100QJSValue(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QList< ::QJSValue> **sipCppPtr = reinterpret_cast<QList< ::QJSValue> **>(sipCppPtrV);

#line 68 "sip/QtCore/qpycore_qlist.sip"
    PyObject *iter = PyObject_GetIter(sipPy);

    if (!sipIsErr)
    {
        Py_XDECREF(iter);

        return (iter
#if PY_MAJOR_VERSION < 3
                && !PyString_Check(sipPy)
#endif
                && !PyUnicode_Check(sipPy));
    }

    if (!iter)
    {
        *sipIsErr = 1;

        return 0;
    }

    QList<QJSValue> *ql = new QList<QJSValue>;
 
    for (Py_ssize_t i = 0; ; ++i)
    {
        PyErr_Clear();
        PyObject *itm = PyIter_Next(iter);

        if (!itm)
        {
            if (PyErr_Occurred())
            {
                delete ql;
                Py_DECREF(iter);
                *sipIsErr = 1;

                return 0;
            }

            break;
        }

        int state;
        QJSValue *t = reinterpret_cast<QJSValue *>(
                sipForceConvertToType(itm, sipType_QJSValue, sipTransferObj,
                        SIP_NOT_NONE, &state, sipIsErr));

        if (*sipIsErr)
        {
            PyErr_Format(PyExc_TypeError,
                    "index %zd has type '%s' but 'QJSValue' is expected", i,
                    sipPyTypeName(Py_TYPE(itm)));

            Py_DECREF(itm);
            delete ql;
            Py_DECREF(iter);

            return 0;
        }

        ql->append(*t);

        sipReleaseType(t, sipType_QJSValue, state);
        Py_DECREF(itm);
    }
 
    Py_DECREF(iter);

    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 1900 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0100QJSValue(void *, PyObject *);}
static PyObject *convertFrom_QList_0100QJSValue(void *sipCppV, PyObject *sipTransferObj)
{
   QList< ::QJSValue> *sipCpp = reinterpret_cast<QList< ::QJSValue> *>(sipCppV);

#line 42 "sip/QtCore/qpycore_qlist.sip"
    PyObject *l = PyList_New(sipCpp->size());

    if (!l)
        return 0;

    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QJSValue *t = new QJSValue(sipCpp->at(i));
        PyObject *tobj = sipConvertFromNewType(t, sipType_QJSValue,
                sipTransferObj);

        if (!tobj)
        {
            delete t;
            Py_DECREF(l);

            return 0;
        }

        PyList_SetItem(l, i, tobj);
    }

    return l;
#line 1933 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtQml_QList_0100QJSValue = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_1885,     /* QList<QJSValue> */
        {0},
        0
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QJSValue,
    array_QList_0100QJSValue,
    copy_QList_0100QJSValue,
    release_QList_0100QJSValue,
    convertTo_QList_0100QJSValue,
    convertFrom_QList_0100QJSValue
};

#line 24 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qpyqmllistproperty.sip"
#include "qpyqmllistpropertywrapper.h"
#line 1965 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 1969 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


extern "C" {static void assign_QQmlListProperty_0100QObject(void *, SIP_SSIZE_T, const void *);}
static void assign_QQmlListProperty_0100QObject(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast< ::QQmlListProperty< ::QObject> *>(sipDst)[sipDstIdx] = *reinterpret_cast<const  ::QQmlListProperty< ::QObject> *>(sipSrc);
}


extern "C" {static void *array_QQmlListProperty_0100QObject(SIP_SSIZE_T);}
static void *array_QQmlListProperty_0100QObject(SIP_SSIZE_T sipNrElem)
{
    return new  ::QQmlListProperty< ::QObject>[sipNrElem];
}


extern "C" {static void *copy_QQmlListProperty_0100QObject(const void *, SIP_SSIZE_T);}
static void *copy_QQmlListProperty_0100QObject(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QQmlListProperty< ::QObject>(reinterpret_cast<const  ::QQmlListProperty< ::QObject> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QQmlListProperty_0100QObject(void *, int);}
static void release_QQmlListProperty_0100QObject(void *ptr, int)
{
    delete reinterpret_cast< ::QQmlListProperty< ::QObject> *>(ptr);
}



extern "C" {static int convertTo_QQmlListProperty_0100QObject(PyObject *, void **, int *, PyObject *);}
static int convertTo_QQmlListProperty_0100QObject(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *)
{
     ::QQmlListProperty< ::QObject> **sipCppPtr = reinterpret_cast< ::QQmlListProperty< ::QObject> **>(sipCppPtrV);

#line 32 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qpyqmllistproperty.sip"
    if (sipIsErr == NULL)
        return PyObject_IsInstance(sipPy, (PyObject *)qpyqml_QQmlListPropertyWrapper_TypeObject);

    *sipCppPtr = ((qpyqml_QQmlListPropertyWrapper *)sipPy)->qml_list_property;

    // It isn't a temporary copy.
    return 0;
#line 2015 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
}


extern "C" {static PyObject *convertFrom_QQmlListProperty_0100QObject(void *, PyObject *);}
static PyObject *convertFrom_QQmlListProperty_0100QObject(void *sipCppV, PyObject *)
{
    ::QQmlListProperty< ::QObject> *sipCpp = reinterpret_cast< ::QQmlListProperty< ::QObject> *>(sipCppV);

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qpyqmllistproperty.sip"
    return qpyqml_QQmlListPropertyWrapper_New(sipCpp, 0);
#line 2026 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtQml_QQmlListProperty_0100QObject = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_631,     /* QQmlListProperty<QObject> */
        {0},
        0
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QQmlListProperty_0100QObject,
    array_QQmlListProperty_0100QObject,
    copy_QQmlListProperty_0100QObject,
    release_QQmlListProperty_0100QObject,
    convertTo_QQmlListProperty_0100QObject,
    convertFrom_QQmlListProperty_0100QObject
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlscriptstring.sip"
#include <qqmlscriptstring.h>
#line 2058 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 2062 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


PyDoc_STRVAR(doc_QQmlScriptString_isEmpty, "isEmpty(self) -> bool");

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

    {
        const  ::QQmlScriptString *sipCpp;

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

            sipRes = sipCpp->isEmpty();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlScriptString, sipName_isEmpty, doc_QQmlScriptString_isEmpty);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlScriptString_isUndefinedLiteral, "isUndefinedLiteral(self) -> bool");

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

    {
        const  ::QQmlScriptString *sipCpp;

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

            sipRes = sipCpp->isUndefinedLiteral();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlScriptString, sipName_isUndefinedLiteral, doc_QQmlScriptString_isUndefinedLiteral);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlScriptString_isNullLiteral, "isNullLiteral(self) -> bool");

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

    {
        const  ::QQmlScriptString *sipCpp;

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

            sipRes = sipCpp->isNullLiteral();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlScriptString, sipName_isNullLiteral, doc_QQmlScriptString_isNullLiteral);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlScriptString_stringLiteral, "stringLiteral(self) -> str");

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

    {
        const  ::QQmlScriptString *sipCpp;

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

            sipRes = new  ::QString(sipCpp->stringLiteral());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlScriptString, sipName_stringLiteral, doc_QQmlScriptString_stringLiteral);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlScriptString_numberLiteral, "numberLiteral(self) -> Tuple[float, bool]");

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

    {
        bool a0;
        const  ::QQmlScriptString *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlScriptString, &sipCpp))
        {
             ::qreal sipRes;

            sipRes = sipCpp->numberLiteral(&a0);

            return sipBuildResult(0,"(db)",sipRes,a0);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlScriptString, sipName_numberLiteral, doc_QQmlScriptString_numberLiteral);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlScriptString_booleanLiteral, "booleanLiteral(self) -> Tuple[bool, bool]");

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

    {
        bool a0;
        const  ::QQmlScriptString *sipCpp;

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

            sipRes = sipCpp->booleanLiteral(&a0);

            return sipBuildResult(0,"(bb)",sipRes,a0);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlScriptString, sipName_booleanLiteral, doc_QQmlScriptString_booleanLiteral);

    return NULL;
}


extern "C" {static PyObject *slot_QQmlScriptString___ne__(PyObject *,PyObject *);}
static PyObject *slot_QQmlScriptString___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QQmlScriptString *sipCpp = reinterpret_cast< ::QQmlScriptString *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlScriptString));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QQmlScriptString* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QQmlScriptString, &a0))
        {
            bool sipRes;

            sipRes = sipCpp-> ::QQmlScriptString::operator!=(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, ne_slot, sipType_QQmlScriptString, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QQmlScriptString___eq__(PyObject *,PyObject *);}
static PyObject *slot_QQmlScriptString___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QQmlScriptString *sipCpp = reinterpret_cast< ::QQmlScriptString *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlScriptString));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QQmlScriptString* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QQmlScriptString, &a0))
        {
            bool sipRes;

            sipRes = sipCpp-> ::QQmlScriptString::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, eq_slot, sipType_QQmlScriptString, sipSelf, sipArg);
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlScriptString(void *, int);}
static void release_QQmlScriptString(void *sipCppV, int)
{
    delete reinterpret_cast< ::QQmlScriptString *>(sipCppV);
}


extern "C" {static void assign_QQmlScriptString(void *, SIP_SSIZE_T, const void *);}
static void assign_QQmlScriptString(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast< ::QQmlScriptString *>(sipDst)[sipDstIdx] = *reinterpret_cast<const  ::QQmlScriptString *>(sipSrc);
}


extern "C" {static void *array_QQmlScriptString(SIP_SSIZE_T);}
static void *array_QQmlScriptString(SIP_SSIZE_T sipNrElem)
{
    return new  ::QQmlScriptString[sipNrElem];
}


extern "C" {static void *copy_QQmlScriptString(const void *, SIP_SSIZE_T);}
static void *copy_QQmlScriptString(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QQmlScriptString(reinterpret_cast<const  ::QQmlScriptString *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QQmlScriptString(sipSimpleWrapper *);}
static void dealloc_QQmlScriptString(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlScriptString(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QQmlScriptString(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QQmlScriptString(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QQmlScriptString *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new  ::QQmlScriptString();

            return sipCpp;
        }
    }

    {
        const  ::QQmlScriptString* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QQmlScriptString, &a0))
        {
            sipCpp = new  ::QQmlScriptString(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QQmlScriptString[] = {
    {(void *)slot_QQmlScriptString___ne__, ne_slot},
    {(void *)slot_QQmlScriptString___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QQmlScriptString[] = {
    {SIP_MLNAME_CAST(sipName_booleanLiteral), meth_QQmlScriptString_booleanLiteral, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlScriptString_booleanLiteral)},
    {SIP_MLNAME_CAST(sipName_isEmpty), meth_QQmlScriptString_isEmpty, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlScriptString_isEmpty)},
    {SIP_MLNAME_CAST(sipName_isNullLiteral), meth_QQmlScriptString_isNullLiteral, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlScriptString_isNullLiteral)},
    {SIP_MLNAME_CAST(sipName_isUndefinedLiteral), meth_QQmlScriptString_isUndefinedLiteral, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlScriptString_isUndefinedLiteral)},
    {SIP_MLNAME_CAST(sipName_numberLiteral), meth_QQmlScriptString_numberLiteral, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlScriptString_numberLiteral)},
    {SIP_MLNAME_CAST(sipName_stringLiteral), meth_QQmlScriptString_stringLiteral, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlScriptString_stringLiteral)}
};

PyDoc_STRVAR(doc_QQmlScriptString, "\1QQmlScriptString()\n"
    "QQmlScriptString(QQmlScriptString)");


static pyqt5ClassPluginDef plugin_QQmlScriptString = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlScriptString = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlScriptString,
        {0},
        &plugin_QQmlScriptString
    },
    {
        sipNameNr_QQmlScriptString,
        {0, 0, 1},
        6, methods_QQmlScriptString,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlScriptString,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QQmlScriptString,
    init_type_QQmlScriptString,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlScriptString,
    assign_QQmlScriptString,
    array_QQmlScriptString,
    copy_QQmlScriptString,
    release_QQmlScriptString,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlpropertyvaluesource.sip"
#include <qqmlpropertyvaluesource.h>
#line 2448 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlproperty.sip"
#include <qqmlproperty.h>
#line 2452 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlPropertyValueSource : public  ::QQmlPropertyValueSource
{
public:
    sipQQmlPropertyValueSource();
    sipQQmlPropertyValueSource(const  ::QQmlPropertyValueSource&);
    virtual ~sipQQmlPropertyValueSource();

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void setTarget(const  ::QQmlProperty&);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[1];
};

sipQQmlPropertyValueSource::sipQQmlPropertyValueSource():  ::QQmlPropertyValueSource(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlPropertyValueSource::sipQQmlPropertyValueSource(const  ::QQmlPropertyValueSource& a0):  ::QQmlPropertyValueSource(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlPropertyValueSource::~sipQQmlPropertyValueSource()
{
    sipInstanceDestroyed(sipPySelf);
}

void sipQQmlPropertyValueSource::setTarget(const  ::QQmlProperty& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,sipName_QQmlPropertyValueSource,sipName_setTarget);

    if (!sipMeth)
        return;

    extern void sipVH_QtQml_18(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QQmlProperty&);

    sipVH_QtQml_18(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}


PyDoc_STRVAR(doc_QQmlPropertyValueSource_setTarget, "setTarget(self, QQmlProperty)");

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

    {
        const  ::QQmlProperty* a0;
         ::QQmlPropertyValueSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QQmlPropertyValueSource, &sipCpp, sipType_QQmlProperty, &a0))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QQmlPropertyValueSource, sipName_setTarget);
                return NULL;
            }

            sipCpp->setTarget(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlPropertyValueSource, sipName_setTarget, doc_QQmlPropertyValueSource_setTarget);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlPropertyValueSource(void *, int);}
static void release_QQmlPropertyValueSource(void *sipCppV, int sipState)
{
    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQQmlPropertyValueSource *>(sipCppV);
    else
        delete reinterpret_cast< ::QQmlPropertyValueSource *>(sipCppV);
}


extern "C" {static int mixin_QQmlPropertyValueSource(PyObject *, PyObject *, PyObject *);}
static int mixin_QQmlPropertyValueSource(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    return sipInitMixin(sipSelf, sipArgs, sipKwds, (sipClassTypeDef *)&sipTypeDef_QtQml_QQmlPropertyValueSource);
}


extern "C" {static void dealloc_QQmlPropertyValueSource(sipSimpleWrapper *);}
static void dealloc_QQmlPropertyValueSource(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlPropertyValueSource *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlPropertyValueSource(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


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

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new sipQQmlPropertyValueSource();

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QQmlPropertyValueSource* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QQmlPropertyValueSource, &a0))
        {
            sipCpp = new sipQQmlPropertyValueSource(*a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QQmlPropertyValueSource[] = {
    {SIP_MLNAME_CAST(sipName_setTarget), meth_QQmlPropertyValueSource_setTarget, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlPropertyValueSource_setTarget)}
};

PyDoc_STRVAR(doc_QQmlPropertyValueSource, "\1QQmlPropertyValueSource()\n"
    "QQmlPropertyValueSource(QQmlPropertyValueSource)");


static pyqt5ClassPluginDef plugin_QQmlPropertyValueSource = {
    0,
    0,
    0,
    "org.qt-project.Qt.QQmlPropertyValueSource"
};


sipClassTypeDef sipTypeDef_QtQml_QQmlPropertyValueSource = {
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlPropertyValueSource,
        {0},
        &plugin_QQmlPropertyValueSource
    },
    {
        sipNameNr_QQmlPropertyValueSource,
        {0, 0, 1},
        1, methods_QQmlPropertyValueSource,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlPropertyValueSource,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QQmlPropertyValueSource,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlPropertyValueSource,
    0,
    0,
    0,
    release_QQmlPropertyValueSource,
    0,
    0,
    0,
    0,
    0,
    0,
    mixin_QQmlPropertyValueSource
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlpropertymap.sip"
#include <qqmlpropertymap.h>
#line 2677 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 2681 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 2684 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 2687 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 36 "sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 2690 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 2693 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2696 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2699 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2702 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2705 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 2708 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2711 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 2714 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 2717 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 2720 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 2723 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 2726 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 2729 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlPropertyMap : public  ::QQmlPropertyMap
{
public:
    sipQQmlPropertyMap( ::QObject*);
    virtual ~sipQQmlPropertyMap();

    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;
     ::QVariant sipProtectVirt_updateValue(bool,const  ::QString&,const  ::QVariant&);

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

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[8];
};

sipQQmlPropertyMap::sipQQmlPropertyMap( ::QObject*a0):  ::QQmlPropertyMap(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlPropertyMap::~sipQQmlPropertyMap()
{
    sipInstanceDestroyed(sipPySelf);
}

const QMetaObject *sipQQmlPropertyMap::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtQml_qt_metaobject(sipPySelf,sipType_QQmlPropertyMap);

    return  ::QQmlPropertyMap::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtQml_qt_metacall(sipPySelf,sipType_QQmlPropertyMap,_c,_id,_a);

    return _id;
}

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

    return (sip_QtQml_qt_metacast(sipPySelf, sipType_QQmlPropertyMap, _clname, &sipCpp) ? sipCpp :  ::QQmlPropertyMap::qt_metacast(_clname));
}

 ::QVariant sipQQmlPropertyMap::updateValue(const  ::QString& a0,const  ::QVariant& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QQmlPropertyMap::updateValue(a0,a1);

    extern  ::QVariant sipVH_QtQml_17(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QString&,const  ::QVariant&);

    return sipVH_QtQml_17(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    extern bool sipVH_QtQml_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtQml_5(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern bool sipVH_QtQml_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtQml_4(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    extern void sipVH_QtQml_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtQml_3(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtQml_2(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtQml_1(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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

 ::QVariant sipQQmlPropertyMap::sipProtectVirt_updateValue(bool sipSelfWasArg,const  ::QString& a0,const  ::QVariant& a1)
{
    return (sipSelfWasArg ?  ::QQmlPropertyMap::updateValue(a0,a1) : updateValue(a0,a1));
}


PyDoc_STRVAR(doc_QQmlPropertyMap_sender, "sender(self) -> QObject");

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

    {
        const sipQQmlPropertyMap *sipCpp;

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

#line 560 "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");
                Q_ASSERT(qtcore_qobject_sender);
            }
        
            sipRes = qtcore_qobject_sender();
        }
#line 3045 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

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

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_receivers, "receivers(self, PYQT_SIGNAL) -> int");

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

    {
        PyObject * a0;
        const sipQQmlPropertyMap *sipCpp;

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

#line 591 "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");
            Q_ASSERT(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 3105 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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_QQmlPropertyMap, sipName_receivers, doc_QQmlPropertyMap_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_timerEvent, "timerEvent(self, QTimerEvent)");

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

    {
         ::QTimerEvent* a0;
        sipQQmlPropertyMap *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlPropertyMap, &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_QQmlPropertyMap, sipName_timerEvent, doc_QQmlPropertyMap_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_childEvent, "childEvent(self, QChildEvent)");

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

    {
         ::QChildEvent* a0;
        sipQQmlPropertyMap *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlPropertyMap, &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_QQmlPropertyMap, sipName_childEvent, doc_QQmlPropertyMap_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_customEvent, "customEvent(self, QEvent)");

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

    {
         ::QEvent* a0;
        sipQQmlPropertyMap *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlPropertyMap, &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_QQmlPropertyMap, sipName_customEvent, doc_QQmlPropertyMap_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_connectNotify, "connectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlPropertyMap *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlPropertyMap, &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_QQmlPropertyMap, sipName_connectNotify, doc_QQmlPropertyMap_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_disconnectNotify, "disconnectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlPropertyMap *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlPropertyMap, &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_QQmlPropertyMap, sipName_disconnectNotify, doc_QQmlPropertyMap_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_senderSignalIndex, "senderSignalIndex(self) -> int");

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

    {
        const sipQQmlPropertyMap *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_isSignalConnected, "isSignalConnected(self, QMetaMethod) -> bool");

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

    {
        const  ::QMetaMethod* a0;
        const sipQQmlPropertyMap *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlPropertyMap, &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_QQmlPropertyMap, sipName_isSignalConnected, doc_QQmlPropertyMap_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_value, "value(self, str) -> Any");

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

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QQmlPropertyMap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlPropertyMap, &sipCpp, sipType_QString,&a0, &a0State))
        {
             ::QVariant*sipRes;

            sipRes = new  ::QVariant(sipCpp->value(*a0));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlPropertyMap, sipName_value, doc_QQmlPropertyMap_value);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_insert, "insert(self, str, Any)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QVariant* a1;
        int a1State = 0;
         ::QQmlPropertyMap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_QQmlPropertyMap, &sipCpp, sipType_QString,&a0, &a0State, sipType_QVariant, &a1, &a1State))
        {
            sipCpp->insert(*a0,*a1);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QVariant *>(a1),sipType_QVariant,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlPropertyMap, sipName_insert, doc_QQmlPropertyMap_insert);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_clear, "clear(self, str)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QQmlPropertyMap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlPropertyMap, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->clear(*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_QQmlPropertyMap, sipName_clear, doc_QQmlPropertyMap_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_keys, "keys(self) -> List[str]");

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

    {
        const  ::QQmlPropertyMap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlPropertyMap, &sipCpp))
        {
             ::QStringList*sipRes;

            sipRes = new  ::QStringList(sipCpp->keys());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlPropertyMap, sipName_keys, doc_QQmlPropertyMap_keys);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_count, "count(self) -> int");

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

    {
        const  ::QQmlPropertyMap *sipCpp;

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

            sipRes = sipCpp->count();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlPropertyMap, sipName_count, doc_QQmlPropertyMap_count);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_size, "size(self) -> int");

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

    {
        const  ::QQmlPropertyMap *sipCpp;

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

            sipRes = sipCpp->size();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlPropertyMap, sipName_size, doc_QQmlPropertyMap_size);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_isEmpty, "isEmpty(self) -> bool");

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

    {
        const  ::QQmlPropertyMap *sipCpp;

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

            sipRes = sipCpp->isEmpty();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlPropertyMap, sipName_isEmpty, doc_QQmlPropertyMap_isEmpty);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_contains, "contains(self, str) -> bool");

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

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QQmlPropertyMap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlPropertyMap, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->contains(*a0);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlPropertyMap, sipName_contains, doc_QQmlPropertyMap_contains);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlPropertyMap_updateValue, "updateValue(self, str, Any) -> Any");

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

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QVariant* a1;
        int a1State = 0;
        sipQQmlPropertyMap *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J1", &sipSelf, sipType_QQmlPropertyMap, &sipCpp, sipType_QString,&a0, &a0State, sipType_QVariant, &a1, &a1State))
        {
             ::QVariant*sipRes;

            sipRes = new  ::QVariant(sipCpp->sipProtectVirt_updateValue(sipSelfWasArg,*a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QVariant *>(a1),sipType_QVariant,a1State);

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlPropertyMap, sipName_updateValue, doc_QQmlPropertyMap_updateValue);

    return NULL;
}


extern "C" {static PyObject *slot_QQmlPropertyMap___getitem__(PyObject *,PyObject *);}
static PyObject *slot_QQmlPropertyMap___getitem__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QQmlPropertyMap *sipCpp = reinterpret_cast< ::QQmlPropertyMap *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlPropertyMap));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QString,&a0, &a0State))
        {
             ::QVariant*sipRes;

            sipRes = new  ::QVariant((*sipCpp)[*a0]);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlPropertyMap, sipName___getitem__, NULL);

    return 0;
}


extern "C" {static SIP_SSIZE_T slot_QQmlPropertyMap___len__(PyObject *);}
static SIP_SSIZE_T slot_QQmlPropertyMap___len__(PyObject *sipSelf)
{
     ::QQmlPropertyMap *sipCpp = reinterpret_cast< ::QQmlPropertyMap *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlPropertyMap));

    if (!sipCpp)
        return 0;


    {
        {
            SIP_SSIZE_T sipRes = 0;

#line 1 "Auto-generated"
            sipRes = (SIP_SSIZE_T)sipCpp->size();
#line 3647 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QQmlPropertyMap(void *, const sipTypeDef *);}
static void *cast_QQmlPropertyMap(void *sipCppV, const sipTypeDef *targetType)
{
     ::QQmlPropertyMap *sipCpp = reinterpret_cast< ::QQmlPropertyMap *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


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

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


extern "C" {static void dealloc_QQmlPropertyMap(sipSimpleWrapper *);}
static void dealloc_QQmlPropertyMap(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlPropertyMap *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlPropertyMap(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QQmlPropertyMap(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QQmlPropertyMap(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQQmlPropertyMap *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 sipQQmlPropertyMap(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


/* Define this type's Python slots. */
static sipPySlotDef slots_QQmlPropertyMap[] = {
    {(void *)slot_QQmlPropertyMap___getitem__, getitem_slot},
    {(void *)slot_QQmlPropertyMap___len__, len_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QQmlPropertyMap[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QQmlPropertyMap_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_clear), meth_QQmlPropertyMap_clear, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlPropertyMap_clear)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QQmlPropertyMap_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_contains), meth_QQmlPropertyMap_contains, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlPropertyMap_contains)},
    {SIP_MLNAME_CAST(sipName_count), meth_QQmlPropertyMap_count, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlPropertyMap_count)},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QQmlPropertyMap_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QQmlPropertyMap_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_insert), meth_QQmlPropertyMap_insert, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlPropertyMap_insert)},
    {SIP_MLNAME_CAST(sipName_isEmpty), meth_QQmlPropertyMap_isEmpty, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlPropertyMap_isEmpty)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QQmlPropertyMap_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_keys), meth_QQmlPropertyMap_keys, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlPropertyMap_keys)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QQmlPropertyMap_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QQmlPropertyMap_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QQmlPropertyMap_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_size), meth_QQmlPropertyMap_size, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlPropertyMap_size)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QQmlPropertyMap_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_updateValue), (PyCFunction)meth_QQmlPropertyMap_updateValue, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QQmlPropertyMap_updateValue)},
    {SIP_MLNAME_CAST(sipName_value), meth_QQmlPropertyMap_value, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlPropertyMap_value)}
};

PyDoc_STRVAR(doc_QQmlPropertyMap, "\1QQmlPropertyMap(parent: QObject = None)");


/* Define this type's signals. */
static const pyqt5QtSignal signals_QQmlPropertyMap[] = {
    {"valueChanged(QString,QVariant)", "\1valueChanged(self, str, Any)", 0, 0},
    {0, 0, 0, 0}
};


static pyqt5ClassPluginDef plugin_QQmlPropertyMap = {
    & ::QQmlPropertyMap::staticMetaObject,
    0,
    signals_QQmlPropertyMap,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlPropertyMap = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlPropertyMap,
        {0},
        &plugin_QQmlPropertyMap
    },
    {
        sipNameNr_QQmlPropertyMap,
        {0, 0, 1},
        18, methods_QQmlPropertyMap,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlPropertyMap,
    -1,
    -1,
    supers_QQmlPropertyMap,
    slots_QQmlPropertyMap,
    init_type_QQmlPropertyMap,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlPropertyMap,
    0,
    0,
    0,
    release_QQmlPropertyMap,
    cast_QQmlPropertyMap,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlproperty.sip"
#include <qqmlproperty.h>
#line 3825 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 3829 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlcontext.sip"
#include <qqmlcontext.h>
#line 3832 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 3835 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 3838 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 3841 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 166 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 3844 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 3847 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


PyDoc_STRVAR(doc_QQmlProperty_type, "type(self) -> QQmlProperty.Type");

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

    {
        const  ::QQmlProperty *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlProperty, &sipCpp))
        {
             ::QQmlProperty::Type sipRes;

            sipRes = sipCpp->type();

            return sipConvertFromEnum(sipRes,sipType_QQmlProperty_Type);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_type, doc_QQmlProperty_type);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_isValid, "isValid(self) -> bool");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_isValid, doc_QQmlProperty_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_isProperty, "isProperty(self) -> bool");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = sipCpp->isProperty();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_isProperty, doc_QQmlProperty_isProperty);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_isSignalProperty, "isSignalProperty(self) -> bool");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = sipCpp->isSignalProperty();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_isSignalProperty, doc_QQmlProperty_isSignalProperty);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_propertyType, "propertyType(self) -> int");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = sipCpp->propertyType();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_propertyType, doc_QQmlProperty_propertyType);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_propertyTypeCategory, "propertyTypeCategory(self) -> QQmlProperty.PropertyTypeCategory");

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

    {
        const  ::QQmlProperty *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlProperty, &sipCpp))
        {
             ::QQmlProperty::PropertyTypeCategory sipRes;

            sipRes = sipCpp->propertyTypeCategory();

            return sipConvertFromEnum(sipRes,sipType_QQmlProperty_PropertyTypeCategory);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_propertyTypeCategory, doc_QQmlProperty_propertyTypeCategory);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_propertyTypeName, "propertyTypeName(self) -> str");

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

    {
        const  ::QQmlProperty *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlProperty, &sipCpp))
        {
            const char*sipRes;

            sipRes = sipCpp->propertyTypeName();

            if (sipRes == NULL)
            {
                Py_INCREF(Py_None);
                return Py_None;
            }

            return SIPBytes_FromString(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_propertyTypeName, doc_QQmlProperty_propertyTypeName);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_name, "name(self) -> str");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = new  ::QString(sipCpp->name());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_name, doc_QQmlProperty_name);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_read, "read(self) -> Any\n"
    "read(QObject, str) -> Any\n"
    "read(QObject, str, QQmlContext) -> Any\n"
    "read(QObject, str, QQmlEngine) -> Any");

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

    {
        const  ::QQmlProperty *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlProperty, &sipCpp))
        {
             ::QVariant*sipRes;

            sipRes = new  ::QVariant(sipCpp->read());

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

    {
        const  ::QObject* a0;
        const  ::QString* a1;
        int a1State = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8J1", sipType_QObject, &a0, sipType_QString,&a1, &a1State))
        {
             ::QVariant*sipRes;

            sipRes = new  ::QVariant( ::QQmlProperty::read(a0,*a1));
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

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

    {
        const  ::QObject* a0;
        const  ::QString* a1;
        int a1State = 0;
         ::QQmlContext* a2;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8J1J8", sipType_QObject, &a0, sipType_QString,&a1, &a1State, sipType_QQmlContext, &a2))
        {
             ::QVariant*sipRes;

            sipRes = new  ::QVariant( ::QQmlProperty::read(a0,*a1,a2));
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

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

    {
        const  ::QObject* a0;
        const  ::QString* a1;
        int a1State = 0;
         ::QQmlEngine* a2;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8J1J8", sipType_QObject, &a0, sipType_QString,&a1, &a1State, sipType_QQmlEngine, &a2))
        {
             ::QVariant*sipRes;

            sipRes = new  ::QVariant( ::QQmlProperty::read(a0,*a1,a2));
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_read, doc_QQmlProperty_read);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_write, "write(self, Any) -> bool\n"
    "write(QObject, str, Any) -> bool\n"
    "write(QObject, str, Any, QQmlContext) -> bool\n"
    "write(QObject, str, Any, QQmlEngine) -> bool");

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

    {
        const  ::QVariant* a0;
        int a0State = 0;
        const  ::QQmlProperty *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlProperty, &sipCpp, sipType_QVariant, &a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->write(*a0);
            sipReleaseType(const_cast< ::QVariant *>(a0),sipType_QVariant,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    {
         ::QObject* a0;
        const  ::QString* a1;
        int a1State = 0;
        const  ::QVariant* a2;
        int a2State = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8J1J1", sipType_QObject, &a0, sipType_QString,&a1, &a1State, sipType_QVariant, &a2, &a2State))
        {
            bool sipRes;

            sipRes =  ::QQmlProperty::write(a0,*a1,*a2);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);
            sipReleaseType(const_cast< ::QVariant *>(a2),sipType_QVariant,a2State);

            return PyBool_FromLong(sipRes);
        }
    }

    {
         ::QObject* a0;
        const  ::QString* a1;
        int a1State = 0;
        const  ::QVariant* a2;
        int a2State = 0;
         ::QQmlContext* a3;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8J1J1J8", sipType_QObject, &a0, sipType_QString,&a1, &a1State, sipType_QVariant, &a2, &a2State, sipType_QQmlContext, &a3))
        {
            bool sipRes;

            sipRes =  ::QQmlProperty::write(a0,*a1,*a2,a3);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);
            sipReleaseType(const_cast< ::QVariant *>(a2),sipType_QVariant,a2State);

            return PyBool_FromLong(sipRes);
        }
    }

    {
         ::QObject* a0;
        const  ::QString* a1;
        int a1State = 0;
        const  ::QVariant* a2;
        int a2State = 0;
         ::QQmlEngine* a3;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8J1J1J8", sipType_QObject, &a0, sipType_QString,&a1, &a1State, sipType_QVariant, &a2, &a2State, sipType_QQmlEngine, &a3))
        {
            bool sipRes;

            sipRes =  ::QQmlProperty::write(a0,*a1,*a2,a3);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);
            sipReleaseType(const_cast< ::QVariant *>(a2),sipType_QVariant,a2State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_write, doc_QQmlProperty_write);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_reset, "reset(self) -> bool");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = sipCpp->reset();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_reset, doc_QQmlProperty_reset);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_hasNotifySignal, "hasNotifySignal(self) -> bool");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = sipCpp->hasNotifySignal();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_hasNotifySignal, doc_QQmlProperty_hasNotifySignal);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_needsNotifySignal, "needsNotifySignal(self) -> bool");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = sipCpp->needsNotifySignal();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_needsNotifySignal, doc_QQmlProperty_needsNotifySignal);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_connectNotifySignal, "connectNotifySignal(self, PYQT_SLOT) -> bool\n"
    "connectNotifySignal(self, QObject, int) -> bool");

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

    {
        PyObject * a0;
        const  ::QQmlProperty *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BP0", &sipSelf, sipType_QQmlProperty, &sipCpp, &a0))
        {
            bool sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 81 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlproperty.sip"
        QObject *receiver;
        QByteArray slot;
        
        if ((sipError = pyqt5_qtqml_get_connection_parts(a0, 0, "()", false, &receiver, slot)) == sipErrorNone)
        {
            sipRes = sipCpp->connectNotifySignal(receiver, slot.constData());
        }
        else if (sipError == sipErrorContinue)
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 4375 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

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

            sipAddException(sipError, &sipParseErr);
        }
    }

    {
         ::QObject* a0;
        int a1;
        const  ::QQmlProperty *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8i", &sipSelf, sipType_QQmlProperty, &sipCpp, sipType_QObject, &a0, &a1))
        {
            bool sipRes;

            sipRes = sipCpp->connectNotifySignal(a0,a1);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_connectNotifySignal, doc_QQmlProperty_connectNotifySignal);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_isWritable, "isWritable(self) -> bool");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = sipCpp->isWritable();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_isWritable, doc_QQmlProperty_isWritable);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_isDesignable, "isDesignable(self) -> bool");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = sipCpp->isDesignable();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_isDesignable, doc_QQmlProperty_isDesignable);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_isResettable, "isResettable(self) -> bool");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = sipCpp->isResettable();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_isResettable, doc_QQmlProperty_isResettable);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_object, "object(self) -> QObject");

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

    {
        const  ::QQmlProperty *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlProperty, &sipCpp))
        {
             ::QObject*sipRes;

            sipRes = sipCpp->object();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_object, doc_QQmlProperty_object);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_index, "index(self) -> int");

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

    {
        const  ::QQmlProperty *sipCpp;

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

            sipRes = sipCpp->index();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_index, doc_QQmlProperty_index);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_property, "property(self) -> QMetaProperty");

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

    {
        const  ::QQmlProperty *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlProperty, &sipCpp))
        {
             ::QMetaProperty*sipRes;

            sipRes = new  ::QMetaProperty(sipCpp->property());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_property, doc_QQmlProperty_property);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlProperty_method, "method(self) -> QMetaMethod");

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

    {
        const  ::QQmlProperty *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlProperty, &sipCpp))
        {
             ::QMetaMethod*sipRes;

            sipRes = new  ::QMetaMethod(sipCpp->method());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlProperty, sipName_method, doc_QQmlProperty_method);

    return NULL;
}


extern "C" {static PyObject *slot_QQmlProperty___ne__(PyObject *,PyObject *);}
static PyObject *slot_QQmlProperty___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QQmlProperty *sipCpp = reinterpret_cast< ::QQmlProperty *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlProperty));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QQmlProperty* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QQmlProperty, &a0))
        {
            bool sipRes;

            sipRes = !sipCpp-> ::QQmlProperty::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, ne_slot, sipType_QQmlProperty, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QQmlProperty___eq__(PyObject *,PyObject *);}
static PyObject *slot_QQmlProperty___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QQmlProperty *sipCpp = reinterpret_cast< ::QQmlProperty *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlProperty));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QQmlProperty* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QQmlProperty, &a0))
        {
            bool sipRes;

            sipRes = sipCpp-> ::QQmlProperty::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, eq_slot, sipType_QQmlProperty, sipSelf, sipArg);
}


extern "C" {static long slot_QQmlProperty___hash__(PyObject *);}
static long slot_QQmlProperty___hash__(PyObject *sipSelf)
{
     ::QQmlProperty *sipCpp = reinterpret_cast< ::QQmlProperty *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlProperty));

    if (!sipCpp)
        return 0;


    {
        {
            long sipRes = 0;

#line 56 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlproperty.sip"
        sipRes = qHash(*sipCpp);
#line 4686 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlProperty(void *, int);}
static void release_QQmlProperty(void *sipCppV, int)
{
    delete reinterpret_cast< ::QQmlProperty *>(sipCppV);
}


extern "C" {static void assign_QQmlProperty(void *, SIP_SSIZE_T, const void *);}
static void assign_QQmlProperty(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast< ::QQmlProperty *>(sipDst)[sipDstIdx] = *reinterpret_cast<const  ::QQmlProperty *>(sipSrc);
}


extern "C" {static void *array_QQmlProperty(SIP_SSIZE_T);}
static void *array_QQmlProperty(SIP_SSIZE_T sipNrElem)
{
    return new  ::QQmlProperty[sipNrElem];
}


extern "C" {static void *copy_QQmlProperty(const void *, SIP_SSIZE_T);}
static void *copy_QQmlProperty(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QQmlProperty(reinterpret_cast<const  ::QQmlProperty *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QQmlProperty(sipSimpleWrapper *);}
static void dealloc_QQmlProperty(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlProperty(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QQmlProperty(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QQmlProperty(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QQmlProperty *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new  ::QQmlProperty();

            return sipCpp;
        }
    }

    {
         ::QObject* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J8", sipType_QObject, &a0))
        {
            sipCpp = new  ::QQmlProperty(a0);

            return sipCpp;
        }
    }

    {
         ::QObject* a0;
         ::QQmlContext* a1;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J8J8", sipType_QObject, &a0, sipType_QQmlContext, &a1))
        {
            sipCpp = new  ::QQmlProperty(a0,a1);

            return sipCpp;
        }
    }

    {
         ::QObject* a0;
         ::QQmlEngine* a1;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J8J8", sipType_QObject, &a0, sipType_QQmlEngine, &a1))
        {
            sipCpp = new  ::QQmlProperty(a0,a1);

            return sipCpp;
        }
    }

    {
         ::QObject* a0;
        const  ::QString* a1;
        int a1State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J8J1", sipType_QObject, &a0, sipType_QString,&a1, &a1State))
        {
            sipCpp = new  ::QQmlProperty(a0,*a1);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return sipCpp;
        }
    }

    {
         ::QObject* a0;
        const  ::QString* a1;
        int a1State = 0;
         ::QQmlContext* a2;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J8J1J8", sipType_QObject, &a0, sipType_QString,&a1, &a1State, sipType_QQmlContext, &a2))
        {
            sipCpp = new  ::QQmlProperty(a0,*a1,a2);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return sipCpp;
        }
    }

    {
         ::QObject* a0;
        const  ::QString* a1;
        int a1State = 0;
         ::QQmlEngine* a2;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J8J1J8", sipType_QObject, &a0, sipType_QString,&a1, &a1State, sipType_QQmlEngine, &a2))
        {
            sipCpp = new  ::QQmlProperty(a0,*a1,a2);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return sipCpp;
        }
    }

    {
        const  ::QQmlProperty* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QQmlProperty, &a0))
        {
            sipCpp = new  ::QQmlProperty(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QQmlProperty[] = {
    {(void *)slot_QQmlProperty___ne__, ne_slot},
    {(void *)slot_QQmlProperty___eq__, eq_slot},
    {(void *)slot_QQmlProperty___hash__, hash_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QQmlProperty[] = {
    {SIP_MLNAME_CAST(sipName_connectNotifySignal), meth_QQmlProperty_connectNotifySignal, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_connectNotifySignal)},
    {SIP_MLNAME_CAST(sipName_hasNotifySignal), meth_QQmlProperty_hasNotifySignal, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_hasNotifySignal)},
    {SIP_MLNAME_CAST(sipName_index), meth_QQmlProperty_index, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_index)},
    {SIP_MLNAME_CAST(sipName_isDesignable), meth_QQmlProperty_isDesignable, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_isDesignable)},
    {SIP_MLNAME_CAST(sipName_isProperty), meth_QQmlProperty_isProperty, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_isProperty)},
    {SIP_MLNAME_CAST(sipName_isResettable), meth_QQmlProperty_isResettable, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_isResettable)},
    {SIP_MLNAME_CAST(sipName_isSignalProperty), meth_QQmlProperty_isSignalProperty, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_isSignalProperty)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QQmlProperty_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_isValid)},
    {SIP_MLNAME_CAST(sipName_isWritable), meth_QQmlProperty_isWritable, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_isWritable)},
    {SIP_MLNAME_CAST(sipName_method), meth_QQmlProperty_method, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_method)},
    {SIP_MLNAME_CAST(sipName_name), meth_QQmlProperty_name, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_name)},
    {SIP_MLNAME_CAST(sipName_needsNotifySignal), meth_QQmlProperty_needsNotifySignal, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_needsNotifySignal)},
    {SIP_MLNAME_CAST(sipName_object), meth_QQmlProperty_object, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_object)},
    {SIP_MLNAME_CAST(sipName_property), meth_QQmlProperty_property, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_property)},
    {SIP_MLNAME_CAST(sipName_propertyType), meth_QQmlProperty_propertyType, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_propertyType)},
    {SIP_MLNAME_CAST(sipName_propertyTypeCategory), meth_QQmlProperty_propertyTypeCategory, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_propertyTypeCategory)},
    {SIP_MLNAME_CAST(sipName_propertyTypeName), meth_QQmlProperty_propertyTypeName, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_propertyTypeName)},
    {SIP_MLNAME_CAST(sipName_read), meth_QQmlProperty_read, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_read)},
    {SIP_MLNAME_CAST(sipName_reset), meth_QQmlProperty_reset, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_reset)},
    {SIP_MLNAME_CAST(sipName_type), meth_QQmlProperty_type, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_type)},
    {SIP_MLNAME_CAST(sipName_write), meth_QQmlProperty_write, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlProperty_write)}
};

static sipEnumMemberDef enummembers_QQmlProperty[] = {
    {sipName_Invalid, static_cast<int>( ::QQmlProperty::Invalid), 36},
    {sipName_InvalidCategory, static_cast<int>( ::QQmlProperty::InvalidCategory), 35},
    {sipName_List, static_cast<int>( ::QQmlProperty::List), 35},
    {sipName_Normal, static_cast<int>( ::QQmlProperty::Normal), 35},
    {sipName_Object, static_cast<int>( ::QQmlProperty::Object), 35},
    {sipName_Property, static_cast<int>( ::QQmlProperty::Property), 36},
    {sipName_SignalProperty, static_cast<int>( ::QQmlProperty::SignalProperty), 36},
};

PyDoc_STRVAR(doc_QQmlProperty, "\1QQmlProperty()\n"
    "QQmlProperty(QObject)\n"
    "QQmlProperty(QObject, QQmlContext)\n"
    "QQmlProperty(QObject, QQmlEngine)\n"
    "QQmlProperty(QObject, str)\n"
    "QQmlProperty(QObject, str, QQmlContext)\n"
    "QQmlProperty(QObject, str, QQmlEngine)\n"
    "QQmlProperty(QQmlProperty)");


static pyqt5ClassPluginDef plugin_QQmlProperty = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlProperty = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlProperty,
        {0},
        &plugin_QQmlProperty
    },
    {
        sipNameNr_QQmlProperty,
        {0, 0, 1},
        21, methods_QQmlProperty,
        7, enummembers_QQmlProperty,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlProperty,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QQmlProperty,
    init_type_QQmlProperty,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlProperty,
    assign_QQmlProperty,
    array_QQmlProperty,
    copy_QQmlProperty,
    release_QQmlProperty,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlparserstatus.sip"
#include <qqmlparserstatus.h>
#line 4956 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"



class sipQQmlParserStatus : public  ::QQmlParserStatus
{
public:
    sipQQmlParserStatus();
    sipQQmlParserStatus(const  ::QQmlParserStatus&);
    virtual ~sipQQmlParserStatus();

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void componentComplete();
    void classBegin();

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[2];
};

sipQQmlParserStatus::sipQQmlParserStatus():  ::QQmlParserStatus(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlParserStatus::sipQQmlParserStatus(const  ::QQmlParserStatus& a0):  ::QQmlParserStatus(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlParserStatus::~sipQQmlParserStatus()
{
    sipInstanceDestroyed(sipPySelf);
}

void sipQQmlParserStatus::componentComplete()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,sipName_QQmlParserStatus,sipName_componentComplete);

    if (!sipMeth)
        return;

    extern void sipVH_QtQml_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtQml_8(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

void sipQQmlParserStatus::classBegin()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,sipName_QQmlParserStatus,sipName_classBegin);

    if (!sipMeth)
        return;

    extern void sipVH_QtQml_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtQml_8(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}


PyDoc_STRVAR(doc_QQmlParserStatus_classBegin, "classBegin(self)");

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

    {
         ::QQmlParserStatus *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlParserStatus, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QQmlParserStatus, sipName_classBegin);
                return NULL;
            }

            sipCpp->classBegin();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlParserStatus, sipName_classBegin, doc_QQmlParserStatus_classBegin);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlParserStatus_componentComplete, "componentComplete(self)");

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

    {
         ::QQmlParserStatus *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlParserStatus, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QQmlParserStatus, sipName_componentComplete);
                return NULL;
            }

            sipCpp->componentComplete();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlParserStatus, sipName_componentComplete, doc_QQmlParserStatus_componentComplete);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlParserStatus(void *, int);}
static void release_QQmlParserStatus(void *sipCppV, int sipState)
{
    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQQmlParserStatus *>(sipCppV);
    else
        delete reinterpret_cast< ::QQmlParserStatus *>(sipCppV);
}


extern "C" {static int mixin_QQmlParserStatus(PyObject *, PyObject *, PyObject *);}
static int mixin_QQmlParserStatus(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    return sipInitMixin(sipSelf, sipArgs, sipKwds, (sipClassTypeDef *)&sipTypeDef_QtQml_QQmlParserStatus);
}


extern "C" {static void dealloc_QQmlParserStatus(sipSimpleWrapper *);}
static void dealloc_QQmlParserStatus(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlParserStatus *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlParserStatus(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


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

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new sipQQmlParserStatus();

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QQmlParserStatus* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QQmlParserStatus, &a0))
        {
            sipCpp = new sipQQmlParserStatus(*a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QQmlParserStatus[] = {
    {SIP_MLNAME_CAST(sipName_classBegin), meth_QQmlParserStatus_classBegin, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlParserStatus_classBegin)},
    {SIP_MLNAME_CAST(sipName_componentComplete), meth_QQmlParserStatus_componentComplete, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlParserStatus_componentComplete)}
};

PyDoc_STRVAR(doc_QQmlParserStatus, "\1QQmlParserStatus()\n"
    "QQmlParserStatus(QQmlParserStatus)");


static pyqt5ClassPluginDef plugin_QQmlParserStatus = {
    0,
    0,
    0,
    "org.qt-project.Qt.QQmlParserStatus"
};


sipClassTypeDef sipTypeDef_QtQml_QQmlParserStatus = {
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlParserStatus,
        {0},
        &plugin_QQmlParserStatus
    },
    {
        sipNameNr_QQmlParserStatus,
        {0, 0, 1},
        2, methods_QQmlParserStatus,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlParserStatus,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QQmlParserStatus,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlParserStatus,
    0,
    0,
    0,
    release_QQmlParserStatus,
    0,
    0,
    0,
    0,
    0,
    0,
    mixin_QQmlParserStatus
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlnetworkaccessmanagerfactory.sip"
#include <qqmlnetworkaccessmanagerfactory.h>
#line 5232 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 26 "sip/QtNetwork/qnetworkaccessmanager.sip"
#include <qnetworkaccessmanager.h>
#line 5236 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 5239 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlNetworkAccessManagerFactory : public  ::QQmlNetworkAccessManagerFactory
{
public:
    sipQQmlNetworkAccessManagerFactory();
    sipQQmlNetworkAccessManagerFactory(const  ::QQmlNetworkAccessManagerFactory&);
    virtual ~sipQQmlNetworkAccessManagerFactory();

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
     ::QNetworkAccessManager* create( ::QObject*);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[1];
};

sipQQmlNetworkAccessManagerFactory::sipQQmlNetworkAccessManagerFactory():  ::QQmlNetworkAccessManagerFactory(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlNetworkAccessManagerFactory::sipQQmlNetworkAccessManagerFactory(const  ::QQmlNetworkAccessManagerFactory& a0):  ::QQmlNetworkAccessManagerFactory(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlNetworkAccessManagerFactory::~sipQQmlNetworkAccessManagerFactory()
{
    sipInstanceDestroyed(sipPySelf);
}

 ::QNetworkAccessManager* sipQQmlNetworkAccessManagerFactory::create( ::QObject*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,sipName_QQmlNetworkAccessManagerFactory,sipName_create);

    if (!sipMeth)
        return 0;

    extern  ::QNetworkAccessManager* sipVH_QtQml_16(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*);

    return sipVH_QtQml_16(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}


PyDoc_STRVAR(doc_QQmlNetworkAccessManagerFactory_create, "create(self, QObject) -> QNetworkAccessManager");

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

    {
         ::QObject* a0;
         ::QQmlNetworkAccessManagerFactory *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QQmlNetworkAccessManagerFactory, &sipCpp, sipType_QObject, &a0))
        {
             ::QNetworkAccessManager*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QQmlNetworkAccessManagerFactory, sipName_create);
                return NULL;
            }

            sipRes = sipCpp->create(a0);

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

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

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlNetworkAccessManagerFactory(void *, int);}
static void release_QQmlNetworkAccessManagerFactory(void *sipCppV, int sipState)
{
    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQQmlNetworkAccessManagerFactory *>(sipCppV);
    else
        delete reinterpret_cast< ::QQmlNetworkAccessManagerFactory *>(sipCppV);
}


extern "C" {static void dealloc_QQmlNetworkAccessManagerFactory(sipSimpleWrapper *);}
static void dealloc_QQmlNetworkAccessManagerFactory(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlNetworkAccessManagerFactory *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlNetworkAccessManagerFactory(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


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

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new sipQQmlNetworkAccessManagerFactory();

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QQmlNetworkAccessManagerFactory* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QQmlNetworkAccessManagerFactory, &a0))
        {
            sipCpp = new sipQQmlNetworkAccessManagerFactory(*a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QQmlNetworkAccessManagerFactory[] = {
    {SIP_MLNAME_CAST(sipName_create), meth_QQmlNetworkAccessManagerFactory_create, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlNetworkAccessManagerFactory_create)}
};

PyDoc_STRVAR(doc_QQmlNetworkAccessManagerFactory, "\1QQmlNetworkAccessManagerFactory()\n"
    "QQmlNetworkAccessManagerFactory(QQmlNetworkAccessManagerFactory)");


static pyqt5ClassPluginDef plugin_QQmlNetworkAccessManagerFactory = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlNetworkAccessManagerFactory = {
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlNetworkAccessManagerFactory,
        {0},
        &plugin_QQmlNetworkAccessManagerFactory
    },
    {
        sipNameNr_QQmlNetworkAccessManagerFactory,
        {0, 0, 1},
        1, methods_QQmlNetworkAccessManagerFactory,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlNetworkAccessManagerFactory,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QQmlNetworkAccessManagerFactory,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlNetworkAccessManagerFactory,
    0,
    0,
    0,
    release_QQmlNetworkAccessManagerFactory,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmllist.sip"
#include <qqmllist.h>
#line 5458 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 5462 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 5465 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 5468 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


PyDoc_STRVAR(doc_QQmlListReference_isValid, "isValid(self) -> bool");

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

    {
        const  ::QQmlListReference *sipCpp;

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

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_isValid, doc_QQmlListReference_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_object, "object(self) -> QObject");

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

    {
        const  ::QQmlListReference *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlListReference, &sipCpp))
        {
             ::QObject*sipRes;

            sipRes = sipCpp->object();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_object, doc_QQmlListReference_object);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_listElementType, "listElementType(self) -> QMetaObject");

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

    {
        const  ::QQmlListReference *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlListReference, &sipCpp))
        {
            const  ::QMetaObject*sipRes;

            sipRes = sipCpp->listElementType();

            return sipConvertFromType(const_cast< ::QMetaObject *>(sipRes),sipType_QMetaObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_listElementType, doc_QQmlListReference_listElementType);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_canAppend, "canAppend(self) -> bool");

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

    {
        const  ::QQmlListReference *sipCpp;

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

            sipRes = sipCpp->canAppend();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_canAppend, doc_QQmlListReference_canAppend);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_canAt, "canAt(self) -> bool");

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

    {
        const  ::QQmlListReference *sipCpp;

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

            sipRes = sipCpp->canAt();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_canAt, doc_QQmlListReference_canAt);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_canClear, "canClear(self) -> bool");

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

    {
        const  ::QQmlListReference *sipCpp;

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

            sipRes = sipCpp->canClear();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_canClear, doc_QQmlListReference_canClear);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_canCount, "canCount(self) -> bool");

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

    {
        const  ::QQmlListReference *sipCpp;

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

            sipRes = sipCpp->canCount();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_canCount, doc_QQmlListReference_canCount);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_isManipulable, "isManipulable(self) -> bool");

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

    {
        const  ::QQmlListReference *sipCpp;

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

            sipRes = sipCpp->isManipulable();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_isManipulable, doc_QQmlListReference_isManipulable);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_isReadable, "isReadable(self) -> bool");

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

    {
        const  ::QQmlListReference *sipCpp;

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

            sipRes = sipCpp->isReadable();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_isReadable, doc_QQmlListReference_isReadable);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_append, "append(self, QObject) -> bool");

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

    {
         ::QObject* a0;
        const  ::QQmlListReference *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QQmlListReference, &sipCpp, sipType_QObject, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->append(a0);

            return PyBool_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_at, "at(self, int) -> QObject");

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

    {
        int a0;
        const  ::QQmlListReference *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QQmlListReference, &sipCpp, &a0))
        {
             ::QObject*sipRes;

            sipRes = sipCpp->at(a0);

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_at, doc_QQmlListReference_at);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_clear, "clear(self) -> bool");

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

    {
        const  ::QQmlListReference *sipCpp;

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

            sipRes = sipCpp->clear();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_clear, doc_QQmlListReference_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlListReference_count, "count(self) -> int");

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

    {
        const  ::QQmlListReference *sipCpp;

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

            sipRes = sipCpp->count();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlListReference, sipName_count, doc_QQmlListReference_count);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlListReference(void *, int);}
static void release_QQmlListReference(void *sipCppV, int)
{
    delete reinterpret_cast< ::QQmlListReference *>(sipCppV);
}


extern "C" {static void assign_QQmlListReference(void *, SIP_SSIZE_T, const void *);}
static void assign_QQmlListReference(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast< ::QQmlListReference *>(sipDst)[sipDstIdx] = *reinterpret_cast<const  ::QQmlListReference *>(sipSrc);
}


extern "C" {static void *array_QQmlListReference(SIP_SSIZE_T);}
static void *array_QQmlListReference(SIP_SSIZE_T sipNrElem)
{
    return new  ::QQmlListReference[sipNrElem];
}


extern "C" {static void *copy_QQmlListReference(const void *, SIP_SSIZE_T);}
static void *copy_QQmlListReference(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QQmlListReference(reinterpret_cast<const  ::QQmlListReference *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QQmlListReference(sipSimpleWrapper *);}
static void dealloc_QQmlListReference(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlListReference(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QQmlListReference(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QQmlListReference(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QQmlListReference *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new  ::QQmlListReference();

            return sipCpp;
        }
    }

    {
         ::QObject* a0;
        const char* a1;
         ::QQmlEngine* a2 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J8s|J8", sipType_QObject, &a0, &a1, sipType_QQmlEngine, &a2))
        {
            sipCpp = new  ::QQmlListReference(a0,a1,a2);

            return sipCpp;
        }
    }

    {
        const  ::QQmlListReference* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QQmlListReference, &a0))
        {
            sipCpp = new  ::QQmlListReference(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QQmlListReference[] = {
    {SIP_MLNAME_CAST(sipName_append), meth_QQmlListReference_append, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_append)},
    {SIP_MLNAME_CAST(sipName_at), meth_QQmlListReference_at, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_at)},
    {SIP_MLNAME_CAST(sipName_canAppend), meth_QQmlListReference_canAppend, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_canAppend)},
    {SIP_MLNAME_CAST(sipName_canAt), meth_QQmlListReference_canAt, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_canAt)},
    {SIP_MLNAME_CAST(sipName_canClear), meth_QQmlListReference_canClear, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_canClear)},
    {SIP_MLNAME_CAST(sipName_canCount), meth_QQmlListReference_canCount, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_canCount)},
    {SIP_MLNAME_CAST(sipName_clear), meth_QQmlListReference_clear, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_clear)},
    {SIP_MLNAME_CAST(sipName_count), meth_QQmlListReference_count, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_count)},
    {SIP_MLNAME_CAST(sipName_isManipulable), meth_QQmlListReference_isManipulable, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_isManipulable)},
    {SIP_MLNAME_CAST(sipName_isReadable), meth_QQmlListReference_isReadable, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_isReadable)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QQmlListReference_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_isValid)},
    {SIP_MLNAME_CAST(sipName_listElementType), meth_QQmlListReference_listElementType, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_listElementType)},
    {SIP_MLNAME_CAST(sipName_object), meth_QQmlListReference_object, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlListReference_object)}
};

PyDoc_STRVAR(doc_QQmlListReference, "\1QQmlListReference()\n"
    "QQmlListReference(QObject, str, engine: QQmlEngine = None)\n"
    "QQmlListReference(QQmlListReference)");


static pyqt5ClassPluginDef plugin_QQmlListReference = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlListReference = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlListReference,
        {0},
        &plugin_QQmlListReference
    },
    {
        sipNameNr_QQmlListReference,
        {0, 0, 1},
        13, methods_QQmlListReference,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlListReference,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QQmlListReference,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlListReference,
    assign_QQmlListReference,
    array_QQmlListReference,
    copy_QQmlListReference,
    release_QQmlListReference,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 69 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlincubator.sip"
#include <qqmlincubator.h>
#line 6005 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 6009 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlIncubationController : public  ::QQmlIncubationController
{
public:
    sipQQmlIncubationController();
    virtual ~sipQQmlIncubationController();

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    void sipProtectVirt_incubatingObjectCountChanged(bool,int);

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void incubatingObjectCountChanged(int);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[1];
};

sipQQmlIncubationController::sipQQmlIncubationController():  ::QQmlIncubationController(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlIncubationController::~sipQQmlIncubationController()
{
    sipInstanceDestroyed(sipPySelf);
}

void sipQQmlIncubationController::incubatingObjectCountChanged(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::QQmlIncubationController::incubatingObjectCountChanged(a0);
        return;
    }

    extern void sipVH_QtQml_15(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    sipVH_QtQml_15(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

void sipQQmlIncubationController::sipProtectVirt_incubatingObjectCountChanged(bool sipSelfWasArg,int a0)
{
    (sipSelfWasArg ?  ::QQmlIncubationController::incubatingObjectCountChanged(a0) : incubatingObjectCountChanged(a0));
}


PyDoc_STRVAR(doc_QQmlIncubationController_engine, "engine(self) -> QQmlEngine");

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

    {
        const  ::QQmlIncubationController *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlIncubationController, &sipCpp))
        {
             ::QQmlEngine*sipRes;

            sipRes = sipCpp->engine();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubationController, sipName_engine, doc_QQmlIncubationController_engine);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubationController_incubatingObjectCount, "incubatingObjectCount(self) -> int");

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

    {
        const  ::QQmlIncubationController *sipCpp;

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

            sipRes = sipCpp->incubatingObjectCount();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubationController, sipName_incubatingObjectCount, doc_QQmlIncubationController_incubatingObjectCount);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubationController_incubateFor, "incubateFor(self, int)");

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

    {
        int a0;
         ::QQmlIncubationController *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QQmlIncubationController, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->incubateFor(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubationController, sipName_incubateFor, doc_QQmlIncubationController_incubateFor);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubationController_incubatingObjectCountChanged, "incubatingObjectCountChanged(self, int)");

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

    {
        int a0;
        sipQQmlIncubationController *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bi", &sipSelf, sipType_QQmlIncubationController, &sipCpp, &a0))
        {
            sipCpp->sipProtectVirt_incubatingObjectCountChanged(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubationController, sipName_incubatingObjectCountChanged, doc_QQmlIncubationController_incubatingObjectCountChanged);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlIncubationController(void *, int);}
static void release_QQmlIncubationController(void *sipCppV, int sipState)
{
    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQQmlIncubationController *>(sipCppV);
    else
        delete reinterpret_cast< ::QQmlIncubationController *>(sipCppV);
}


extern "C" {static void dealloc_QQmlIncubationController(sipSimpleWrapper *);}
static void dealloc_QQmlIncubationController(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlIncubationController *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlIncubationController(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


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

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new sipQQmlIncubationController();

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QQmlIncubationController[] = {
    {SIP_MLNAME_CAST(sipName_engine), meth_QQmlIncubationController_engine, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubationController_engine)},
    {SIP_MLNAME_CAST(sipName_incubateFor), meth_QQmlIncubationController_incubateFor, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubationController_incubateFor)},
    {SIP_MLNAME_CAST(sipName_incubatingObjectCount), meth_QQmlIncubationController_incubatingObjectCount, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubationController_incubatingObjectCount)},
    {SIP_MLNAME_CAST(sipName_incubatingObjectCountChanged), (PyCFunction)meth_QQmlIncubationController_incubatingObjectCountChanged, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QQmlIncubationController_incubatingObjectCountChanged)}
};

PyDoc_STRVAR(doc_QQmlIncubationController, "\1QQmlIncubationController()");


static pyqt5ClassPluginDef plugin_QQmlIncubationController = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlIncubationController = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlIncubationController,
        {0},
        &plugin_QQmlIncubationController
    },
    {
        sipNameNr_QQmlIncubationController,
        {0, 0, 1},
        4, methods_QQmlIncubationController,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlIncubationController,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QQmlIncubationController,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlIncubationController,
    0,
    0,
    0,
    release_QQmlIncubationController,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlincubator.sip"
#include <qqmlincubator.h>
#line 6304 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 6308 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 6311 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlerror.sip"
#include <qqmlerror.h>
#line 6314 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlIncubator : public  ::QQmlIncubator
{
public:
    sipQQmlIncubator( ::QQmlIncubator::IncubationMode);
    virtual ~sipQQmlIncubator();

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    void sipProtectVirt_statusChanged(bool, ::QQmlIncubator::Status);
    void sipProtectVirt_setInitialState(bool, ::QObject*);

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void setInitialState( ::QObject*);
    void statusChanged( ::QQmlIncubator::Status);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[2];
};

sipQQmlIncubator::sipQQmlIncubator( ::QQmlIncubator::IncubationMode a0):  ::QQmlIncubator(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlIncubator::~sipQQmlIncubator()
{
    sipInstanceDestroyed(sipPySelf);
}

void sipQQmlIncubator::setInitialState( ::QObject*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::QQmlIncubator::setInitialState(a0);
        return;
    }

    extern void sipVH_QtQml_14(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*);

    sipVH_QtQml_14(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

void sipQQmlIncubator::statusChanged( ::QQmlIncubator::Status a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::QQmlIncubator::statusChanged(a0);
        return;
    }

    extern void sipVH_QtQml_13(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QQmlIncubator::Status);

    sipVH_QtQml_13(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

void sipQQmlIncubator::sipProtectVirt_statusChanged(bool sipSelfWasArg, ::QQmlIncubator::Status a0)
{
    (sipSelfWasArg ?  ::QQmlIncubator::statusChanged(a0) : statusChanged(a0));
}

void sipQQmlIncubator::sipProtectVirt_setInitialState(bool sipSelfWasArg, ::QObject*a0)
{
    (sipSelfWasArg ?  ::QQmlIncubator::setInitialState(a0) : setInitialState(a0));
}


PyDoc_STRVAR(doc_QQmlIncubator_clear, "clear(self)");

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

    {
         ::QQmlIncubator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlIncubator, &sipCpp))
        {
            sipCpp->clear();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubator, sipName_clear, doc_QQmlIncubator_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubator_forceCompletion, "forceCompletion(self)");

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

    {
         ::QQmlIncubator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlIncubator, &sipCpp))
        {
            sipCpp->forceCompletion();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubator, sipName_forceCompletion, doc_QQmlIncubator_forceCompletion);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubator_isNull, "isNull(self) -> bool");

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

    {
        const  ::QQmlIncubator *sipCpp;

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

            sipRes = sipCpp->isNull();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubator, sipName_isNull, doc_QQmlIncubator_isNull);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubator_isReady, "isReady(self) -> bool");

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

    {
        const  ::QQmlIncubator *sipCpp;

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

            sipRes = sipCpp->isReady();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubator, sipName_isReady, doc_QQmlIncubator_isReady);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubator_isError, "isError(self) -> bool");

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

    {
        const  ::QQmlIncubator *sipCpp;

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

            sipRes = sipCpp->isError();

            return PyBool_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubator_isLoading, "isLoading(self) -> bool");

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

    {
        const  ::QQmlIncubator *sipCpp;

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

            sipRes = sipCpp->isLoading();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubator, sipName_isLoading, doc_QQmlIncubator_isLoading);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubator_errors, "errors(self) -> List[QQmlError]");

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

    {
        const  ::QQmlIncubator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlIncubator, &sipCpp))
        {
            QList< ::QQmlError>*sipRes;

            sipRes = new QList< ::QQmlError>(sipCpp->errors());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubator, sipName_errors, doc_QQmlIncubator_errors);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubator_incubationMode, "incubationMode(self) -> QQmlIncubator.IncubationMode");

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

    {
        const  ::QQmlIncubator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlIncubator, &sipCpp))
        {
             ::QQmlIncubator::IncubationMode sipRes;

            sipRes = sipCpp->incubationMode();

            return sipConvertFromEnum(sipRes,sipType_QQmlIncubator_IncubationMode);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubator, sipName_incubationMode, doc_QQmlIncubator_incubationMode);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubator_status, "status(self) -> QQmlIncubator.Status");

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

    {
        const  ::QQmlIncubator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlIncubator, &sipCpp))
        {
             ::QQmlIncubator::Status sipRes;

            sipRes = sipCpp->status();

            return sipConvertFromEnum(sipRes,sipType_QQmlIncubator_Status);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubator, sipName_status, doc_QQmlIncubator_status);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubator_object, "object(self) -> QObject");

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

    {
        const  ::QQmlIncubator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlIncubator, &sipCpp))
        {
             ::QObject*sipRes;

            sipRes = sipCpp->object();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubator, sipName_object, doc_QQmlIncubator_object);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubator_statusChanged, "statusChanged(self, QQmlIncubator.Status)");

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

    {
         ::QQmlIncubator::Status a0;
        sipQQmlIncubator *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BE", &sipSelf, sipType_QQmlIncubator, &sipCpp, sipType_QQmlIncubator_Status, &a0))
        {
            sipCpp->sipProtectVirt_statusChanged(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubator, sipName_statusChanged, doc_QQmlIncubator_statusChanged);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlIncubator_setInitialState, "setInitialState(self, QObject)");

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

    {
         ::QObject* a0;
        sipQQmlIncubator *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlIncubator, &sipCpp, sipType_QObject, &a0))
        {
            sipCpp->sipProtectVirt_setInitialState(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlIncubator, sipName_setInitialState, doc_QQmlIncubator_setInitialState);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlIncubator(void *, int);}
static void release_QQmlIncubator(void *sipCppV, int sipState)
{
    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQQmlIncubator *>(sipCppV);
    else
        delete reinterpret_cast< ::QQmlIncubator *>(sipCppV);
}


extern "C" {static void dealloc_QQmlIncubator(sipSimpleWrapper *);}
static void dealloc_QQmlIncubator(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlIncubator *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlIncubator(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


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

    {
         ::QQmlIncubator::IncubationMode a0 = QQmlIncubator::Asynchronous;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|E", sipType_QQmlIncubator_IncubationMode, &a0))
        {
            sipCpp = new sipQQmlIncubator(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QQmlIncubator[] = {
    {SIP_MLNAME_CAST(sipName_clear), meth_QQmlIncubator_clear, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubator_clear)},
    {SIP_MLNAME_CAST(sipName_errors), meth_QQmlIncubator_errors, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubator_errors)},
    {SIP_MLNAME_CAST(sipName_forceCompletion), meth_QQmlIncubator_forceCompletion, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubator_forceCompletion)},
    {SIP_MLNAME_CAST(sipName_incubationMode), meth_QQmlIncubator_incubationMode, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubator_incubationMode)},
    {SIP_MLNAME_CAST(sipName_isError), meth_QQmlIncubator_isError, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubator_isError)},
    {SIP_MLNAME_CAST(sipName_isLoading), meth_QQmlIncubator_isLoading, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubator_isLoading)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QQmlIncubator_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubator_isNull)},
    {SIP_MLNAME_CAST(sipName_isReady), meth_QQmlIncubator_isReady, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubator_isReady)},
    {SIP_MLNAME_CAST(sipName_object), meth_QQmlIncubator_object, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubator_object)},
    {SIP_MLNAME_CAST(sipName_setInitialState), (PyCFunction)meth_QQmlIncubator_setInitialState, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QQmlIncubator_setInitialState)},
    {SIP_MLNAME_CAST(sipName_status), meth_QQmlIncubator_status, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlIncubator_status)},
    {SIP_MLNAME_CAST(sipName_statusChanged), (PyCFunction)meth_QQmlIncubator_statusChanged, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QQmlIncubator_statusChanged)}
};

static sipEnumMemberDef enummembers_QQmlIncubator[] = {
    {sipName_Asynchronous, static_cast<int>( ::QQmlIncubator::Asynchronous), 28},
    {sipName_AsynchronousIfNested, static_cast<int>( ::QQmlIncubator::AsynchronousIfNested), 28},
    {sipName_Error, static_cast<int>( ::QQmlIncubator::Error), 29},
    {sipName_Loading, static_cast<int>( ::QQmlIncubator::Loading), 29},
    {sipName_Null, static_cast<int>( ::QQmlIncubator::Null), 29},
    {sipName_Ready, static_cast<int>( ::QQmlIncubator::Ready), 29},
    {sipName_Synchronous, static_cast<int>( ::QQmlIncubator::Synchronous), 28},
};

PyDoc_STRVAR(doc_QQmlIncubator, "\1QQmlIncubator(mode: QQmlIncubator.IncubationMode = QQmlIncubator.Asynchronous)");


static pyqt5ClassPluginDef plugin_QQmlIncubator = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlIncubator = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlIncubator,
        {0},
        &plugin_QQmlIncubator
    },
    {
        sipNameNr_QQmlIncubator,
        {0, 0, 1},
        12, methods_QQmlIncubator,
        7, enummembers_QQmlIncubator,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlIncubator,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QQmlIncubator,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlIncubator,
    0,
    0,
    0,
    release_QQmlIncubator,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlfileselector.sip"
#include <qqmlfileselector.h>
#line 6879 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 6883 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 6886 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "sip/QtCore/qfileselector.sip"
#include <qfileselector.h>
#line 6889 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 36 "sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 6892 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 6895 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 6898 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 6901 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 6904 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 6907 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 6910 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 6913 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 6916 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 6919 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 6922 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 6925 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 6928 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 6931 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 6934 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 6937 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlFileSelector : public  ::QQmlFileSelector
{
public:
    sipQQmlFileSelector( ::QQmlEngine*, ::QObject*);
    virtual ~sipQQmlFileSelector();

    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:
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const  ::QMetaMethod&);
    void disconnectNotify(const  ::QMetaMethod&);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[7];
};

sipQQmlFileSelector::sipQQmlFileSelector( ::QQmlEngine*a0, ::QObject*a1):  ::QQmlFileSelector(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlFileSelector::~sipQQmlFileSelector()
{
    sipInstanceDestroyed(sipPySelf);
}

const QMetaObject *sipQQmlFileSelector::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtQml_qt_metaobject(sipPySelf,sipType_QQmlFileSelector);

    return  ::QQmlFileSelector::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtQml_qt_metacall(sipPySelf,sipType_QQmlFileSelector,_c,_id,_a);

    return _id;
}

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

    return (sip_QtQml_qt_metacast(sipPySelf, sipType_QQmlFileSelector, _clname, &sipCpp) ? sipCpp :  ::QQmlFileSelector::qt_metacast(_clname));
}

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

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

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

    extern bool sipVH_QtQml_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtQml_5(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern bool sipVH_QtQml_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtQml_4(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    extern void sipVH_QtQml_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtQml_3(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtQml_2(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtQml_1(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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


PyDoc_STRVAR(doc_QQmlFileSelector_sender, "sender(self) -> QObject");

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

    {
        const sipQQmlFileSelector *sipCpp;

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

#line 560 "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");
                Q_ASSERT(qtcore_qobject_sender);
            }
        
            sipRes = qtcore_qobject_sender();
        }
#line 7231 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

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

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_receivers, "receivers(self, PYQT_SIGNAL) -> int");

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

    {
        PyObject * a0;
        const sipQQmlFileSelector *sipCpp;

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

#line 591 "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");
            Q_ASSERT(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 7291 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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_QQmlFileSelector, sipName_receivers, doc_QQmlFileSelector_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_timerEvent, "timerEvent(self, QTimerEvent)");

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

    {
         ::QTimerEvent* a0;
        sipQQmlFileSelector *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlFileSelector, &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_QQmlFileSelector, sipName_timerEvent, doc_QQmlFileSelector_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_childEvent, "childEvent(self, QChildEvent)");

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

    {
         ::QChildEvent* a0;
        sipQQmlFileSelector *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlFileSelector, &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_QQmlFileSelector, sipName_childEvent, doc_QQmlFileSelector_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_customEvent, "customEvent(self, QEvent)");

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

    {
         ::QEvent* a0;
        sipQQmlFileSelector *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlFileSelector, &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_QQmlFileSelector, sipName_customEvent, doc_QQmlFileSelector_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_connectNotify, "connectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlFileSelector *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlFileSelector, &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_QQmlFileSelector, sipName_connectNotify, doc_QQmlFileSelector_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_disconnectNotify, "disconnectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlFileSelector *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlFileSelector, &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_QQmlFileSelector, sipName_disconnectNotify, doc_QQmlFileSelector_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_senderSignalIndex, "senderSignalIndex(self) -> int");

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

    {
        const sipQQmlFileSelector *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_isSignalConnected, "isSignalConnected(self, QMetaMethod) -> bool");

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

    {
        const  ::QMetaMethod* a0;
        const sipQQmlFileSelector *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlFileSelector, &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_QQmlFileSelector, sipName_isSignalConnected, doc_QQmlFileSelector_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_setSelector, "setSelector(self, QFileSelector)");

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

    {
         ::QFileSelector* a0;
         ::QQmlFileSelector *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QQmlFileSelector, &sipCpp, sipType_QFileSelector, &a0))
        {
            sipCpp->setSelector(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlFileSelector, sipName_setSelector, doc_QQmlFileSelector_setSelector);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_setExtraSelectors, "setExtraSelectors(self, Iterable[str])");

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

    {
        const  ::QStringList* a0;
        int a0State = 0;
         ::QQmlFileSelector *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlFileSelector, &sipCpp, sipType_QStringList,&a0, &a0State))
        {
            sipCpp->setExtraSelectors(*a0);
            sipReleaseType(const_cast< ::QStringList *>(a0),sipType_QStringList,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlFileSelector, sipName_setExtraSelectors, doc_QQmlFileSelector_setExtraSelectors);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_get, "get(QQmlEngine) -> QQmlFileSelector");

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

    {
         ::QQmlEngine* a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8", sipType_QQmlEngine, &a0))
        {
             ::QQmlFileSelector*sipRes;

            sipRes =  ::QQmlFileSelector::get(a0);

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlFileSelector, sipName_get, doc_QQmlFileSelector_get);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlFileSelector_selector, "selector(self) -> QFileSelector");

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

    {
        const  ::QQmlFileSelector *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlFileSelector, &sipCpp))
        {
             ::QFileSelector*sipRes;

            sipRes = sipCpp->selector();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlFileSelector, sipName_selector, doc_QQmlFileSelector_selector);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QQmlFileSelector(void *, const sipTypeDef *);}
static void *cast_QQmlFileSelector(void *sipCppV, const sipTypeDef *targetType)
{
     ::QQmlFileSelector *sipCpp = reinterpret_cast< ::QQmlFileSelector *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


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

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


extern "C" {static void dealloc_QQmlFileSelector(sipSimpleWrapper *);}
static void dealloc_QQmlFileSelector(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlFileSelector *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlFileSelector(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


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

    {
         ::QQmlEngine* a0;
         ::QObject* a1 = 0;

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

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

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QQmlFileSelector[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QQmlFileSelector_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QQmlFileSelector_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QQmlFileSelector_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QQmlFileSelector_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_get), meth_QQmlFileSelector_get, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlFileSelector_get)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QQmlFileSelector_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QQmlFileSelector_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_selector), meth_QQmlFileSelector_selector, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlFileSelector_selector)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QQmlFileSelector_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QQmlFileSelector_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setExtraSelectors), meth_QQmlFileSelector_setExtraSelectors, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlFileSelector_setExtraSelectors)},
    {SIP_MLNAME_CAST(sipName_setSelector), meth_QQmlFileSelector_setSelector, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlFileSelector_setSelector)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QQmlFileSelector_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QQmlFileSelector, "\1QQmlFileSelector(QQmlEngine, parent: QObject = None)");


static pyqt5ClassPluginDef plugin_QQmlFileSelector = {
    & ::QQmlFileSelector::staticMetaObject,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlFileSelector = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlFileSelector,
        {0},
        &plugin_QQmlFileSelector
    },
    {
        sipNameNr_QQmlFileSelector,
        {0, 0, 1},
        13, methods_QQmlFileSelector,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlFileSelector,
    -1,
    -1,
    supers_QQmlFileSelector,
    0,
    init_type_QQmlFileSelector,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlFileSelector,
    0,
    0,
    0,
    release_QQmlFileSelector,
    cast_QQmlFileSelector,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlextensionplugin.sip"
#include <qqmlextensionplugin.h>
#line 7778 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 7782 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 96 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 7785 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 7788 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 7791 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 7794 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 7797 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 7800 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 7803 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 7806 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 7809 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 7812 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 7815 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 7818 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 7821 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 7824 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 7827 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 7830 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 7833 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlExtensionPlugin : public  ::QQmlExtensionPlugin
{
public:
    sipQQmlExtensionPlugin( ::QObject*);
    virtual ~sipQQmlExtensionPlugin();

    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 initializeEngine( ::QQmlEngine*,const char*);
    void registerTypes(const char*);
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const  ::QMetaMethod&);
    void disconnectNotify(const  ::QMetaMethod&);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[9];
};

sipQQmlExtensionPlugin::sipQQmlExtensionPlugin( ::QObject*a0):  ::QQmlExtensionPlugin(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlExtensionPlugin::~sipQQmlExtensionPlugin()
{
    sipInstanceDestroyed(sipPySelf);
}

const QMetaObject *sipQQmlExtensionPlugin::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtQml_qt_metaobject(sipPySelf,sipType_QQmlExtensionPlugin);

    return  ::QQmlExtensionPlugin::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtQml_qt_metacall(sipPySelf,sipType_QQmlExtensionPlugin,_c,_id,_a);

    return _id;
}

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

    return (sip_QtQml_qt_metacast(sipPySelf, sipType_QQmlExtensionPlugin, _clname, &sipCpp) ? sipCpp :  ::QQmlExtensionPlugin::qt_metacast(_clname));
}

void sipQQmlExtensionPlugin::initializeEngine( ::QQmlEngine*a0,const char*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::QQmlExtensionPlugin::initializeEngine(a0,a1);
        return;
    }

    extern void sipVH_QtQml_12(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QQmlEngine*,const char*);

    sipVH_QtQml_12(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

void sipQQmlExtensionPlugin::registerTypes(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,sipName_QQmlExtensionPlugin,sipName_registerTypes);

    if (!sipMeth)
        return;

    extern void sipVH_QtQml_11(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtQml_11(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern bool sipVH_QtQml_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtQml_5(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern bool sipVH_QtQml_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtQml_4(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    extern void sipVH_QtQml_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtQml_3(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtQml_2(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtQml_1(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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


PyDoc_STRVAR(doc_QQmlExtensionPlugin_sender, "sender(self) -> QObject");

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

    {
        const sipQQmlExtensionPlugin *sipCpp;

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

#line 560 "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");
                Q_ASSERT(qtcore_qobject_sender);
            }
        
            sipRes = qtcore_qobject_sender();
        }
#line 8162 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

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

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExtensionPlugin_receivers, "receivers(self, PYQT_SIGNAL) -> int");

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

    {
        PyObject * a0;
        const sipQQmlExtensionPlugin *sipCpp;

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

#line 591 "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");
            Q_ASSERT(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 8222 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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_QQmlExtensionPlugin, sipName_receivers, doc_QQmlExtensionPlugin_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExtensionPlugin_timerEvent, "timerEvent(self, QTimerEvent)");

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

    {
         ::QTimerEvent* a0;
        sipQQmlExtensionPlugin *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlExtensionPlugin, &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_QQmlExtensionPlugin, sipName_timerEvent, doc_QQmlExtensionPlugin_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExtensionPlugin_childEvent, "childEvent(self, QChildEvent)");

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

    {
         ::QChildEvent* a0;
        sipQQmlExtensionPlugin *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlExtensionPlugin, &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_QQmlExtensionPlugin, sipName_childEvent, doc_QQmlExtensionPlugin_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExtensionPlugin_customEvent, "customEvent(self, QEvent)");

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

    {
         ::QEvent* a0;
        sipQQmlExtensionPlugin *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlExtensionPlugin, &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_QQmlExtensionPlugin, sipName_customEvent, doc_QQmlExtensionPlugin_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExtensionPlugin_connectNotify, "connectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlExtensionPlugin *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlExtensionPlugin, &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_QQmlExtensionPlugin, sipName_connectNotify, doc_QQmlExtensionPlugin_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExtensionPlugin_disconnectNotify, "disconnectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlExtensionPlugin *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlExtensionPlugin, &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_QQmlExtensionPlugin, sipName_disconnectNotify, doc_QQmlExtensionPlugin_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExtensionPlugin_senderSignalIndex, "senderSignalIndex(self) -> int");

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

    {
        const sipQQmlExtensionPlugin *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExtensionPlugin_isSignalConnected, "isSignalConnected(self, QMetaMethod) -> bool");

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

    {
        const  ::QMetaMethod* a0;
        const sipQQmlExtensionPlugin *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlExtensionPlugin, &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_QQmlExtensionPlugin, sipName_isSignalConnected, doc_QQmlExtensionPlugin_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExtensionPlugin_registerTypes, "registerTypes(self, str)");

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

    {
        const char* a0;
         ::QQmlExtensionPlugin *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bs", &sipSelf, sipType_QQmlExtensionPlugin, &sipCpp, &a0))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QQmlExtensionPlugin, sipName_registerTypes);
                return NULL;
            }

            sipCpp->registerTypes(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExtensionPlugin, sipName_registerTypes, doc_QQmlExtensionPlugin_registerTypes);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExtensionPlugin_initializeEngine, "initializeEngine(self, QQmlEngine, str)");

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

    {
         ::QQmlEngine* a0;
        const char* a1;
         ::QQmlExtensionPlugin *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8s", &sipSelf, sipType_QQmlExtensionPlugin, &sipCpp, sipType_QQmlEngine, &a0, &a1))
        {
            (sipSelfWasArg ? sipCpp-> ::QQmlExtensionPlugin::initializeEngine(a0,a1) : sipCpp->initializeEngine(a0,a1));

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExtensionPlugin, sipName_initializeEngine, doc_QQmlExtensionPlugin_initializeEngine);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExtensionPlugin_baseUrl, "baseUrl(self) -> QUrl");

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

    {
        const  ::QQmlExtensionPlugin *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlExtensionPlugin, &sipCpp))
        {
             ::QUrl*sipRes;

            sipRes = new  ::QUrl(sipCpp->baseUrl());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExtensionPlugin, sipName_baseUrl, doc_QQmlExtensionPlugin_baseUrl);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QQmlExtensionPlugin(void *, const sipTypeDef *);}
static void *cast_QQmlExtensionPlugin(void *sipCppV, const sipTypeDef *targetType)
{
     ::QQmlExtensionPlugin *sipCpp = reinterpret_cast< ::QQmlExtensionPlugin *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


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

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


extern "C" {static void dealloc_QQmlExtensionPlugin(sipSimpleWrapper *);}
static void dealloc_QQmlExtensionPlugin(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlExtensionPlugin *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlExtensionPlugin(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QQmlExtensionPlugin(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QQmlExtensionPlugin(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQQmlExtensionPlugin *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 sipQQmlExtensionPlugin(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QQmlExtensionPlugin[] = {
    {SIP_MLNAME_CAST(sipName_baseUrl), meth_QQmlExtensionPlugin_baseUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExtensionPlugin_baseUrl)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QQmlExtensionPlugin_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QQmlExtensionPlugin_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QQmlExtensionPlugin_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QQmlExtensionPlugin_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_initializeEngine), meth_QQmlExtensionPlugin_initializeEngine, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExtensionPlugin_initializeEngine)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QQmlExtensionPlugin_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QQmlExtensionPlugin_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_registerTypes), meth_QQmlExtensionPlugin_registerTypes, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExtensionPlugin_registerTypes)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QQmlExtensionPlugin_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QQmlExtensionPlugin_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QQmlExtensionPlugin_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QQmlExtensionPlugin, "\1QQmlExtensionPlugin(parent: QObject = None)");


static pyqt5ClassPluginDef plugin_QQmlExtensionPlugin = {
    & ::QQmlExtensionPlugin::staticMetaObject,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlExtensionPlugin = {
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlExtensionPlugin,
        {0},
        &plugin_QQmlExtensionPlugin
    },
    {
        sipNameNr_QQmlExtensionPlugin,
        {0, 0, 1},
        12, methods_QQmlExtensionPlugin,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlExtensionPlugin,
    -1,
    -1,
    supers_QQmlExtensionPlugin,
    0,
    init_type_QQmlExtensionPlugin,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlExtensionPlugin,
    0,
    0,
    0,
    release_QQmlExtensionPlugin,
    cast_QQmlExtensionPlugin,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlexpression.sip"
#include <qqmlexpression.h>
#line 8685 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlcontext.sip"
#include <qqmlcontext.h>
#line 8689 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 8692 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 8695 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlscriptstring.sip"
#include <qqmlscriptstring.h>
#line 8698 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 8701 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlerror.sip"
#include <qqmlerror.h>
#line 8704 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 8707 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 8710 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 8713 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 8716 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 8719 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 8722 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 8725 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 8728 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 8731 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 8734 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 8737 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 8740 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 8743 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 8746 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlExpression : public  ::QQmlExpression
{
public:
    sipQQmlExpression();
    sipQQmlExpression( ::QQmlContext*, ::QObject*,const  ::QString&, ::QObject*);
    sipQQmlExpression(const  ::QQmlScriptString&, ::QQmlContext*, ::QObject*, ::QObject*);
    virtual ~sipQQmlExpression();

    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:
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const  ::QMetaMethod&);
    void disconnectNotify(const  ::QMetaMethod&);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[7];
};

sipQQmlExpression::sipQQmlExpression():  ::QQmlExpression(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlExpression::sipQQmlExpression( ::QQmlContext*a0, ::QObject*a1,const  ::QString& a2, ::QObject*a3):  ::QQmlExpression(a0,a1,a2,a3), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlExpression::sipQQmlExpression(const  ::QQmlScriptString& a0, ::QQmlContext*a1, ::QObject*a2, ::QObject*a3):  ::QQmlExpression(a0,a1,a2,a3), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlExpression::~sipQQmlExpression()
{
    sipInstanceDestroyed(sipPySelf);
}

const QMetaObject *sipQQmlExpression::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtQml_qt_metaobject(sipPySelf,sipType_QQmlExpression);

    return  ::QQmlExpression::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtQml_qt_metacall(sipPySelf,sipType_QQmlExpression,_c,_id,_a);

    return _id;
}

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

    return (sip_QtQml_qt_metacast(sipPySelf, sipType_QQmlExpression, _clname, &sipCpp) ? sipCpp :  ::QQmlExpression::qt_metacast(_clname));
}

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

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

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

    extern bool sipVH_QtQml_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtQml_5(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern bool sipVH_QtQml_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtQml_4(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    extern void sipVH_QtQml_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtQml_3(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtQml_2(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtQml_1(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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


PyDoc_STRVAR(doc_QQmlExpression_sender, "sender(self) -> QObject");

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

    {
        const sipQQmlExpression *sipCpp;

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

#line 560 "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");
                Q_ASSERT(qtcore_qobject_sender);
            }
        
            sipRes = qtcore_qobject_sender();
        }
#line 9052 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

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

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_receivers, "receivers(self, PYQT_SIGNAL) -> int");

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

    {
        PyObject * a0;
        const sipQQmlExpression *sipCpp;

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

#line 591 "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");
            Q_ASSERT(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 9112 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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_QQmlExpression, sipName_receivers, doc_QQmlExpression_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_timerEvent, "timerEvent(self, QTimerEvent)");

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

    {
         ::QTimerEvent* a0;
        sipQQmlExpression *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlExpression, &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_QQmlExpression, sipName_timerEvent, doc_QQmlExpression_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_childEvent, "childEvent(self, QChildEvent)");

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

    {
         ::QChildEvent* a0;
        sipQQmlExpression *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlExpression, &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_QQmlExpression, sipName_childEvent, doc_QQmlExpression_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_customEvent, "customEvent(self, QEvent)");

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

    {
         ::QEvent* a0;
        sipQQmlExpression *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlExpression, &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_QQmlExpression, sipName_customEvent, doc_QQmlExpression_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_connectNotify, "connectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlExpression *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlExpression, &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_QQmlExpression, sipName_connectNotify, doc_QQmlExpression_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_disconnectNotify, "disconnectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlExpression *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlExpression, &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_QQmlExpression, sipName_disconnectNotify, doc_QQmlExpression_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_senderSignalIndex, "senderSignalIndex(self) -> int");

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

    {
        const sipQQmlExpression *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_isSignalConnected, "isSignalConnected(self, QMetaMethod) -> bool");

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

    {
        const  ::QMetaMethod* a0;
        const sipQQmlExpression *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlExpression, &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_QQmlExpression, sipName_isSignalConnected, doc_QQmlExpression_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_engine, "engine(self) -> QQmlEngine");

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

    {
        const  ::QQmlExpression *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlExpression, &sipCpp))
        {
             ::QQmlEngine*sipRes;

            sipRes = sipCpp->engine();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_engine, doc_QQmlExpression_engine);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_context, "context(self) -> QQmlContext");

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

    {
        const  ::QQmlExpression *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlExpression, &sipCpp))
        {
             ::QQmlContext*sipRes;

            sipRes = sipCpp->context();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_context, doc_QQmlExpression_context);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_expression, "expression(self) -> str");

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

    {
        const  ::QQmlExpression *sipCpp;

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

            sipRes = new  ::QString(sipCpp->expression());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_expression, doc_QQmlExpression_expression);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_setExpression, "setExpression(self, str)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QQmlExpression *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlExpression, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setExpression(*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_QQmlExpression, sipName_setExpression, doc_QQmlExpression_setExpression);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_notifyOnValueChanged, "notifyOnValueChanged(self) -> bool");

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

    {
        const  ::QQmlExpression *sipCpp;

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

            sipRes = sipCpp->notifyOnValueChanged();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_notifyOnValueChanged, doc_QQmlExpression_notifyOnValueChanged);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_setNotifyOnValueChanged, "setNotifyOnValueChanged(self, bool)");

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

    {
        bool a0;
         ::QQmlExpression *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QQmlExpression, &sipCpp, &a0))
        {
            sipCpp->setNotifyOnValueChanged(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_setNotifyOnValueChanged, doc_QQmlExpression_setNotifyOnValueChanged);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_sourceFile, "sourceFile(self) -> str");

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

    {
        const  ::QQmlExpression *sipCpp;

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

            sipRes = new  ::QString(sipCpp->sourceFile());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_sourceFile, doc_QQmlExpression_sourceFile);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_lineNumber, "lineNumber(self) -> int");

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

    {
        const  ::QQmlExpression *sipCpp;

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

            sipRes = sipCpp->lineNumber();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_lineNumber, doc_QQmlExpression_lineNumber);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_columnNumber, "columnNumber(self) -> int");

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

    {
        const  ::QQmlExpression *sipCpp;

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

            sipRes = sipCpp->columnNumber();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_columnNumber, doc_QQmlExpression_columnNumber);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_setSourceLocation, "setSourceLocation(self, str, int, column: int = 0)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
        int a1;
        int a2 = 0;
         ::QQmlExpression *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1i|i", &sipSelf, sipType_QQmlExpression, &sipCpp, sipType_QString,&a0, &a0State, &a1, &a2))
        {
            sipCpp->setSourceLocation(*a0,a1,a2);
            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_QQmlExpression, sipName_setSourceLocation, doc_QQmlExpression_setSourceLocation);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_scopeObject, "scopeObject(self) -> QObject");

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

    {
        const  ::QQmlExpression *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlExpression, &sipCpp))
        {
             ::QObject*sipRes;

            sipRes = sipCpp->scopeObject();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_scopeObject, doc_QQmlExpression_scopeObject);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_hasError, "hasError(self) -> bool");

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

    {
        const  ::QQmlExpression *sipCpp;

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

            sipRes = sipCpp->hasError();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_hasError, doc_QQmlExpression_hasError);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_clearError, "clearError(self)");

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

    {
         ::QQmlExpression *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlExpression, &sipCpp))
        {
            sipCpp->clearError();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_clearError, doc_QQmlExpression_clearError);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_error, "error(self) -> QQmlError");

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

    {
        const  ::QQmlExpression *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlExpression, &sipCpp))
        {
             ::QQmlError*sipRes;

            sipRes = new  ::QQmlError(sipCpp->error());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_error, doc_QQmlExpression_error);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlExpression_evaluate, "evaluate(self) -> Tuple[Any, bool]");

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

    {
        bool a0;
         ::QQmlExpression *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QQmlExpression, &sipCpp))
        {
             ::QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QVariant(sipCpp->evaluate(&a0));
            Py_END_ALLOW_THREADS

            PyObject *sipResObj = sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
            return sipBuildResult(0,"(Rb)",sipResObj,a0);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlExpression, sipName_evaluate, doc_QQmlExpression_evaluate);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QQmlExpression(void *, const sipTypeDef *);}
static void *cast_QQmlExpression(void *sipCppV, const sipTypeDef *targetType)
{
     ::QQmlExpression *sipCpp = reinterpret_cast< ::QQmlExpression *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


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

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


extern "C" {static void dealloc_QQmlExpression(sipSimpleWrapper *);}
static void dealloc_QQmlExpression(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlExpression *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlExpression(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


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

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new sipQQmlExpression();

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
         ::QQmlContext* a0;
         ::QObject* a1;
        const  ::QString* a2;
        int a2State = 0;
         ::QObject* a3 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J8J8J1|JH", sipType_QQmlContext, &a0, sipType_QObject, &a1, sipType_QString,&a2, &a2State, sipType_QObject, &a3, sipOwner))
        {
            sipCpp = new sipQQmlExpression(a0,a1,*a2,a3);
            sipReleaseType(const_cast< ::QString *>(a2),sipType_QString,a2State);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QQmlScriptString* a0;
         ::QQmlContext* a1 = 0;
         ::QObject* a2 = 0;
         ::QObject* a3 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9|J8J8JH", sipType_QQmlScriptString, &a0, sipType_QQmlContext, &a1, sipType_QObject, &a2, sipType_QObject, &a3, sipOwner))
        {
            sipCpp = new sipQQmlExpression(*a0,a1,a2,a3);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QQmlExpression[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QQmlExpression_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_clearError), meth_QQmlExpression_clearError, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_clearError)},
    {SIP_MLNAME_CAST(sipName_columnNumber), meth_QQmlExpression_columnNumber, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_columnNumber)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QQmlExpression_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_context), meth_QQmlExpression_context, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_context)},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QQmlExpression_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QQmlExpression_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_engine), meth_QQmlExpression_engine, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_engine)},
    {SIP_MLNAME_CAST(sipName_error), meth_QQmlExpression_error, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_error)},
    {SIP_MLNAME_CAST(sipName_evaluate), (PyCFunction)meth_QQmlExpression_evaluate, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QQmlExpression_evaluate)},
    {SIP_MLNAME_CAST(sipName_expression), meth_QQmlExpression_expression, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_expression)},
    {SIP_MLNAME_CAST(sipName_hasError), meth_QQmlExpression_hasError, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_hasError)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QQmlExpression_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_lineNumber), meth_QQmlExpression_lineNumber, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_lineNumber)},
    {SIP_MLNAME_CAST(sipName_notifyOnValueChanged), meth_QQmlExpression_notifyOnValueChanged, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_notifyOnValueChanged)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QQmlExpression_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_scopeObject), meth_QQmlExpression_scopeObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_scopeObject)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QQmlExpression_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QQmlExpression_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setExpression), meth_QQmlExpression_setExpression, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_setExpression)},
    {SIP_MLNAME_CAST(sipName_setNotifyOnValueChanged), meth_QQmlExpression_setNotifyOnValueChanged, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_setNotifyOnValueChanged)},
    {SIP_MLNAME_CAST(sipName_setSourceLocation), (PyCFunction)meth_QQmlExpression_setSourceLocation, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QQmlExpression_setSourceLocation)},
    {SIP_MLNAME_CAST(sipName_sourceFile), meth_QQmlExpression_sourceFile, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlExpression_sourceFile)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QQmlExpression_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QQmlExpression, "\1QQmlExpression()\n"
    "QQmlExpression(QQmlContext, QObject, str, parent: QObject = None)\n"
    "QQmlExpression(QQmlScriptString, context: QQmlContext = None, scope: QObject = None, parent: QObject = None)");


/* Define this type's signals. */
static const pyqt5QtSignal signals_QQmlExpression[] = {
    {"valueChanged()", "\1valueChanged(self)", 0, 0},
    {0, 0, 0, 0}
};


static pyqt5ClassPluginDef plugin_QQmlExpression = {
    & ::QQmlExpression::staticMetaObject,
    0,
    signals_QQmlExpression,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlExpression = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlExpression,
        {0},
        &plugin_QQmlExpression
    },
    {
        sipNameNr_QQmlExpression,
        {0, 0, 1},
        24, methods_QQmlExpression,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlExpression,
    -1,
    -1,
    supers_QQmlExpression,
    0,
    init_type_QQmlExpression,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlExpression,
    0,
    0,
    0,
    release_QQmlExpression,
    cast_QQmlExpression,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlerror.sip"
#include <qqmlerror.h>
#line 9980 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 9984 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 9987 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 96 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 9990 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


PyDoc_STRVAR(doc_QQmlError_isValid, "isValid(self) -> bool");

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

    {
        const  ::QQmlError *sipCpp;

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

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_isValid, doc_QQmlError_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_url, "url(self) -> QUrl");

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

    {
        const  ::QQmlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlError, &sipCpp))
        {
             ::QUrl*sipRes;

            sipRes = new  ::QUrl(sipCpp->url());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_url, doc_QQmlError_url);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_setUrl, "setUrl(self, QUrl)");

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

    {
        const  ::QUrl* a0;
         ::QQmlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QQmlError, &sipCpp, sipType_QUrl, &a0))
        {
            sipCpp->setUrl(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_setUrl, doc_QQmlError_setUrl);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_description, "description(self) -> str");

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

    {
        const  ::QQmlError *sipCpp;

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

            sipRes = new  ::QString(sipCpp->description());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_description, doc_QQmlError_description);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_setDescription, "setDescription(self, str)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QQmlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlError, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setDescription(*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_QQmlError, sipName_setDescription, doc_QQmlError_setDescription);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_line, "line(self) -> int");

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

    {
        const  ::QQmlError *sipCpp;

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

            sipRes = sipCpp->line();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_line, doc_QQmlError_line);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_setLine, "setLine(self, int)");

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

    {
        int a0;
         ::QQmlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QQmlError, &sipCpp, &a0))
        {
            sipCpp->setLine(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_setLine, doc_QQmlError_setLine);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_column, "column(self) -> int");

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

    {
        const  ::QQmlError *sipCpp;

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

            sipRes = sipCpp->column();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_column, doc_QQmlError_column);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_setColumn, "setColumn(self, int)");

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

    {
        int a0;
         ::QQmlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QQmlError, &sipCpp, &a0))
        {
            sipCpp->setColumn(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_setColumn, doc_QQmlError_setColumn);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_toString, "toString(self) -> str");

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

    {
        const  ::QQmlError *sipCpp;

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

            sipRes = new  ::QString(sipCpp->toString());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_toString, doc_QQmlError_toString);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_object, "object(self) -> QObject");

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

    {
        const  ::QQmlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlError, &sipCpp))
        {
             ::QObject*sipRes;

            sipRes = sipCpp->object();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_object, doc_QQmlError_object);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_setObject, "setObject(self, QObject)");

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

    {
         ::QObject* a0;
         ::QQmlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QQmlError, &sipCpp, sipType_QObject, &a0))
        {
            sipCpp->setObject(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_setObject, doc_QQmlError_setObject);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_messageType, "messageType(self) -> QtMsgType");

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

    {
        const  ::QQmlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlError, &sipCpp))
        {
             ::QtMsgType sipRes;

            sipRes = sipCpp->messageType();

            return sipConvertFromEnum(sipRes,sipType_QtMsgType);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_messageType, doc_QQmlError_messageType);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlError_setMessageType, "setMessageType(self, QtMsgType)");

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

    {
         ::QtMsgType a0;
         ::QQmlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QQmlError, &sipCpp, sipType_QtMsgType, &a0))
        {
            sipCpp->setMessageType(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlError, sipName_setMessageType, doc_QQmlError_setMessageType);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlError(void *, int);}
static void release_QQmlError(void *sipCppV, int)
{
    delete reinterpret_cast< ::QQmlError *>(sipCppV);
}


extern "C" {static void assign_QQmlError(void *, SIP_SSIZE_T, const void *);}
static void assign_QQmlError(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast< ::QQmlError *>(sipDst)[sipDstIdx] = *reinterpret_cast<const  ::QQmlError *>(sipSrc);
}


extern "C" {static void *array_QQmlError(SIP_SSIZE_T);}
static void *array_QQmlError(SIP_SSIZE_T sipNrElem)
{
    return new  ::QQmlError[sipNrElem];
}


extern "C" {static void *copy_QQmlError(const void *, SIP_SSIZE_T);}
static void *copy_QQmlError(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QQmlError(reinterpret_cast<const  ::QQmlError *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QQmlError(sipSimpleWrapper *);}
static void dealloc_QQmlError(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlError(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QQmlError(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QQmlError(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QQmlError *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new  ::QQmlError();

            return sipCpp;
        }
    }

    {
        const  ::QQmlError* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QQmlError, &a0))
        {
            sipCpp = new  ::QQmlError(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QQmlError[] = {
    {SIP_MLNAME_CAST(sipName_column), meth_QQmlError_column, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_column)},
    {SIP_MLNAME_CAST(sipName_description), meth_QQmlError_description, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_description)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QQmlError_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_isValid)},
    {SIP_MLNAME_CAST(sipName_line), meth_QQmlError_line, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_line)},
    {SIP_MLNAME_CAST(sipName_messageType), meth_QQmlError_messageType, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_messageType)},
    {SIP_MLNAME_CAST(sipName_object), meth_QQmlError_object, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_object)},
    {SIP_MLNAME_CAST(sipName_setColumn), meth_QQmlError_setColumn, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_setColumn)},
    {SIP_MLNAME_CAST(sipName_setDescription), meth_QQmlError_setDescription, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_setDescription)},
    {SIP_MLNAME_CAST(sipName_setLine), meth_QQmlError_setLine, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_setLine)},
    {SIP_MLNAME_CAST(sipName_setMessageType), meth_QQmlError_setMessageType, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_setMessageType)},
    {SIP_MLNAME_CAST(sipName_setObject), meth_QQmlError_setObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_setObject)},
    {SIP_MLNAME_CAST(sipName_setUrl), meth_QQmlError_setUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_setUrl)},
    {SIP_MLNAME_CAST(sipName_toString), meth_QQmlError_toString, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_toString)},
    {SIP_MLNAME_CAST(sipName_url), meth_QQmlError_url, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlError_url)}
};

PyDoc_STRVAR(doc_QQmlError, "\1QQmlError()\n"
    "QQmlError(QQmlError)");


static pyqt5ClassPluginDef plugin_QQmlError = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlError = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlError,
        {0},
        &plugin_QQmlError
    },
    {
        sipNameNr_QQmlError,
        {0, 0, 1},
        14, methods_QQmlError,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlError,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QQmlError,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlError,
    assign_QQmlError,
    array_QQmlError,
    copy_QQmlError,
    release_QQmlError,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 10536 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 10540 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


extern "C" {static long slot_QQmlImageProviderBase_Flags___hash__(PyObject *);}
static long slot_QQmlImageProviderBase_Flags___hash__(PyObject *sipSelf)
{
     ::QQmlImageProviderBase::Flags *sipCpp = reinterpret_cast< ::QQmlImageProviderBase::Flags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlImageProviderBase_Flags));

    if (!sipCpp)
        return 0;


    {
        {
            long sipRes = 0;

#line 116 "sip/QtCore/qglobal.sip"
        sipRes = sipCpp->operator QQmlImageProviderBase::Flags::Int();
#line 10558 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static int slot_QQmlImageProviderBase_Flags___bool__(PyObject *);}
static int slot_QQmlImageProviderBase_Flags___bool__(PyObject *sipSelf)
{
     ::QQmlImageProviderBase::Flags *sipCpp = reinterpret_cast< ::QQmlImageProviderBase::Flags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlImageProviderBase_Flags));

    if (!sipCpp)
        return -1;


    {
        {
            int sipRes = 0;

#line 111 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QQmlImageProviderBase::Flags::Int() != 0);
#line 10583 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QQmlImageProviderBase_Flags___ne__(PyObject *,PyObject *);}
static PyObject *slot_QQmlImageProviderBase_Flags___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QQmlImageProviderBase::Flags *sipCpp = reinterpret_cast< ::QQmlImageProviderBase::Flags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlImageProviderBase_Flags));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QQmlImageProviderBase::Flags* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QQmlImageProviderBase_Flags, &a0, &a0State))
        {
            bool sipRes = 0;

#line 106 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QQmlImageProviderBase::Flags::Int() != a0->operator QQmlImageProviderBase::Flags::Int());
#line 10613 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
            sipReleaseType(const_cast< ::QQmlImageProviderBase::Flags *>(a0),sipType_QQmlImageProviderBase_Flags,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, ne_slot, sipType_QQmlImageProviderBase_Flags, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QQmlImageProviderBase_Flags___eq__(PyObject *,PyObject *);}
static PyObject *slot_QQmlImageProviderBase_Flags___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QQmlImageProviderBase::Flags *sipCpp = reinterpret_cast< ::QQmlImageProviderBase::Flags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlImageProviderBase_Flags));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QQmlImageProviderBase::Flags* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QQmlImageProviderBase_Flags, &a0, &a0State))
        {
            bool sipRes = 0;

#line 101 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QQmlImageProviderBase::Flags::Int() == a0->operator QQmlImageProviderBase::Flags::Int());
#line 10649 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
            sipReleaseType(const_cast< ::QQmlImageProviderBase::Flags *>(a0),sipType_QQmlImageProviderBase_Flags,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, eq_slot, sipType_QQmlImageProviderBase_Flags, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QQmlImageProviderBase_Flags___ixor__(PyObject *,PyObject *);}
static PyObject *slot_QQmlImageProviderBase_Flags___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QQmlImageProviderBase_Flags)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QQmlImageProviderBase::Flags *sipCpp = reinterpret_cast< ::QQmlImageProviderBase::Flags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlImageProviderBase_Flags));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 95 "sip/QtCore/qglobal.sip"
        *sipCpp = QQmlImageProviderBase::Flags(*sipCpp ^ a0);
#line 10688 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QQmlImageProviderBase_Flags___xor__(PyObject *,PyObject *);}
static PyObject *slot_QQmlImageProviderBase_Flags___xor__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QQmlImageProviderBase::Flags* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QQmlImageProviderBase_Flags, &a0, &a0State, &a1))
        {
             ::QQmlImageProviderBase::Flags*sipRes;

            sipRes = new  ::QQmlImageProviderBase::Flags((*a0 ^ a1));
            sipReleaseType(a0,sipType_QQmlImageProviderBase_Flags,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, xor_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QQmlImageProviderBase_Flags___ior__(PyObject *,PyObject *);}
static PyObject *slot_QQmlImageProviderBase_Flags___ior__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QQmlImageProviderBase_Flags)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QQmlImageProviderBase::Flags *sipCpp = reinterpret_cast< ::QQmlImageProviderBase::Flags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlImageProviderBase_Flags));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 89 "sip/QtCore/qglobal.sip"
        *sipCpp = QQmlImageProviderBase::Flags(*sipCpp | a0);
#line 10760 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QQmlImageProviderBase_Flags___or__(PyObject *,PyObject *);}
static PyObject *slot_QQmlImageProviderBase_Flags___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QQmlImageProviderBase::Flags* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QQmlImageProviderBase_Flags, &a0, &a0State, &a1))
        {
             ::QQmlImageProviderBase::Flags*sipRes;

            sipRes = new  ::QQmlImageProviderBase::Flags((*a0 | a1));
            sipReleaseType(a0,sipType_QQmlImageProviderBase_Flags,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, or_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QQmlImageProviderBase_Flags___iand__(PyObject *,PyObject *);}
static PyObject *slot_QQmlImageProviderBase_Flags___iand__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QQmlImageProviderBase_Flags)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QQmlImageProviderBase::Flags *sipCpp = reinterpret_cast< ::QQmlImageProviderBase::Flags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlImageProviderBase_Flags));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            sipCpp-> ::QQmlImageProviderBase::Flags::operator&=(a0);

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QQmlImageProviderBase_Flags___and__(PyObject *,PyObject *);}
static PyObject *slot_QQmlImageProviderBase_Flags___and__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QQmlImageProviderBase::Flags* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QQmlImageProviderBase_Flags, &a0, &a0State, &a1))
        {
             ::QQmlImageProviderBase::Flags*sipRes;

            sipRes = new  ::QQmlImageProviderBase::Flags((*a0 & a1));
            sipReleaseType(a0,sipType_QQmlImageProviderBase_Flags,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, and_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QQmlImageProviderBase_Flags___invert__(PyObject *);}
static PyObject *slot_QQmlImageProviderBase_Flags___invert__(PyObject *sipSelf)
{
     ::QQmlImageProviderBase::Flags *sipCpp = reinterpret_cast< ::QQmlImageProviderBase::Flags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlImageProviderBase_Flags));

    if (!sipCpp)
        return 0;


    {
        {
             ::QQmlImageProviderBase::Flags*sipRes;

            sipRes = new  ::QQmlImageProviderBase::Flags(~(*sipCpp));

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

    return 0;
}


extern "C" {static PyObject *slot_QQmlImageProviderBase_Flags___int__(PyObject *);}
static PyObject *slot_QQmlImageProviderBase_Flags___int__(PyObject *sipSelf)
{
     ::QQmlImageProviderBase::Flags *sipCpp = reinterpret_cast< ::QQmlImageProviderBase::Flags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QQmlImageProviderBase_Flags));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes;

            sipRes = *sipCpp;

            return SIPLong_FromLong(sipRes);
        }
    }

    return 0;
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlImageProviderBase_Flags(void *, int);}
static void release_QQmlImageProviderBase_Flags(void *sipCppV, int)
{
    delete reinterpret_cast< ::QQmlImageProviderBase::Flags *>(sipCppV);
}


extern "C" {static void assign_QQmlImageProviderBase_Flags(void *, SIP_SSIZE_T, const void *);}
static void assign_QQmlImageProviderBase_Flags(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast< ::QQmlImageProviderBase::Flags *>(sipDst)[sipDstIdx] = *reinterpret_cast<const  ::QQmlImageProviderBase::Flags *>(sipSrc);
}


extern "C" {static void *array_QQmlImageProviderBase_Flags(SIP_SSIZE_T);}
static void *array_QQmlImageProviderBase_Flags(SIP_SSIZE_T sipNrElem)
{
    return new  ::QQmlImageProviderBase::Flags[sipNrElem];
}


extern "C" {static void *copy_QQmlImageProviderBase_Flags(const void *, SIP_SSIZE_T);}
static void *copy_QQmlImageProviderBase_Flags(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QQmlImageProviderBase::Flags(reinterpret_cast<const  ::QQmlImageProviderBase::Flags *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QQmlImageProviderBase_Flags(sipSimpleWrapper *);}
static void dealloc_QQmlImageProviderBase_Flags(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlImageProviderBase_Flags(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QQmlImageProviderBase_Flags(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QQmlImageProviderBase_Flags(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QQmlImageProviderBase::Flags *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new  ::QQmlImageProviderBase::Flags();

            return sipCpp;
        }
    }

    {
        int a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "i", &a0))
        {
            sipCpp = new  ::QQmlImageProviderBase::Flags(a0);

            return sipCpp;
        }
    }

    {
        const  ::QQmlImageProviderBase::Flags* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QQmlImageProviderBase_Flags, &a0, &a0State))
        {
            sipCpp = new  ::QQmlImageProviderBase::Flags(*a0);
            sipReleaseType(const_cast< ::QQmlImageProviderBase::Flags *>(a0),sipType_QQmlImageProviderBase_Flags,a0State);

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QQmlImageProviderBase_Flags(PyObject *, void **, int *, PyObject *);}
static int convertTo_QQmlImageProviderBase_Flags(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QQmlImageProviderBase::Flags **sipCppPtr = reinterpret_cast< ::QQmlImageProviderBase::Flags **>(sipCppPtrV);

#line 121 "sip/QtCore/qglobal.sip"
// Allow an instance of the base enum whenever a QQmlImageProviderBase::Flags is expected.

if (sipIsErr == NULL)
    return (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QQmlImageProviderBase_Flag)) ||
            sipCanConvertToType(sipPy, sipType_QQmlImageProviderBase_Flags, SIP_NO_CONVERTORS));

if (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QQmlImageProviderBase_Flag)))
{
    *sipCppPtr = new QQmlImageProviderBase::Flags(int(SIPLong_AsLong(sipPy)));

    return sipGetState(sipTransferObj);
}

*sipCppPtr = reinterpret_cast<QQmlImageProviderBase::Flags *>(sipConvertToType(sipPy, sipType_QQmlImageProviderBase_Flags, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr));

return 0;
#line 11028 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QQmlImageProviderBase_Flags[] = {
    {(void *)slot_QQmlImageProviderBase_Flags___hash__, hash_slot},
    {(void *)slot_QQmlImageProviderBase_Flags___bool__, bool_slot},
    {(void *)slot_QQmlImageProviderBase_Flags___ne__, ne_slot},
    {(void *)slot_QQmlImageProviderBase_Flags___eq__, eq_slot},
    {(void *)slot_QQmlImageProviderBase_Flags___ixor__, ixor_slot},
    {(void *)slot_QQmlImageProviderBase_Flags___xor__, xor_slot},
    {(void *)slot_QQmlImageProviderBase_Flags___ior__, ior_slot},
    {(void *)slot_QQmlImageProviderBase_Flags___or__, or_slot},
    {(void *)slot_QQmlImageProviderBase_Flags___iand__, iand_slot},
    {(void *)slot_QQmlImageProviderBase_Flags___and__, and_slot},
    {(void *)slot_QQmlImageProviderBase_Flags___invert__, invert_slot},
    {(void *)slot_QQmlImageProviderBase_Flags___int__, int_slot},
    {0, (sipPySlotType)0}
};

PyDoc_STRVAR(doc_QQmlImageProviderBase_Flags, "\1QQmlImageProviderBase.Flags()\n"
    "QQmlImageProviderBase.Flags(Union[QQmlImageProviderBase.Flags, QQmlImageProviderBase.Flag])\n"
    "QQmlImageProviderBase.Flags(QQmlImageProviderBase.Flags)");


static pyqt5ClassPluginDef plugin_QQmlImageProviderBase_Flags = {
    0,
    1,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlImageProviderBase_Flags = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlImageProviderBase__Flags,
        {0},
        &plugin_QQmlImageProviderBase_Flags
    },
    {
        sipNameNr_Flags,
        {22, 255, 0},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlImageProviderBase_Flags,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QQmlImageProviderBase_Flags,
    init_type_QQmlImageProviderBase_Flags,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlImageProviderBase_Flags,
    assign_QQmlImageProviderBase_Flags,
    array_QQmlImageProviderBase_Flags,
    copy_QQmlImageProviderBase_Flags,
    release_QQmlImageProviderBase_Flags,
    0,
    convertTo_QQmlImageProviderBase_Flags,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 11114 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 11118 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


PyDoc_STRVAR(doc_QQmlImageProviderBase_imageType, "imageType(self) -> QQmlImageProviderBase.ImageType");

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

    {
        const  ::QQmlImageProviderBase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlImageProviderBase, &sipCpp))
        {
             ::QQmlImageProviderBase::ImageType sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QQmlImageProviderBase, sipName_imageType);
                return NULL;
            }

            sipRes = sipCpp->imageType();

            return sipConvertFromEnum(sipRes,sipType_QQmlImageProviderBase_ImageType);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlImageProviderBase, sipName_imageType, doc_QQmlImageProviderBase_imageType);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlImageProviderBase_flags, "flags(self) -> QQmlImageProviderBase.Flags");

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

    {
        const  ::QQmlImageProviderBase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlImageProviderBase, &sipCpp))
        {
             ::QQmlImageProviderBase::Flags*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QQmlImageProviderBase, sipName_flags);
                return NULL;
            }

            sipRes = new  ::QQmlImageProviderBase::Flags(sipCpp->flags());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlImageProviderBase, sipName_flags, doc_QQmlImageProviderBase_flags);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlImageProviderBase(void *, int);}
static void release_QQmlImageProviderBase(void *sipCppV, int)
{
    delete reinterpret_cast< ::QQmlImageProviderBase *>(sipCppV);
}


extern "C" {static void dealloc_QQmlImageProviderBase(sipSimpleWrapper *);}
static void dealloc_QQmlImageProviderBase(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlImageProviderBase(sipGetAddress(sipSelf), 0);
    }
}


static PyMethodDef methods_QQmlImageProviderBase[] = {
    {SIP_MLNAME_CAST(sipName_flags), meth_QQmlImageProviderBase_flags, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlImageProviderBase_flags)},
    {SIP_MLNAME_CAST(sipName_imageType), meth_QQmlImageProviderBase_imageType, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlImageProviderBase_imageType)}
};

static sipEnumMemberDef enummembers_QQmlImageProviderBase[] = {
    {sipName_ForceAsynchronousImageLoading, static_cast<int>( ::QQmlImageProviderBase::ForceAsynchronousImageLoading), 23},
    {sipName_Image, static_cast<int>( ::QQmlImageProviderBase::Image), 25},
    {sipName_ImageResponse, static_cast<int>( ::QQmlImageProviderBase::ImageResponse), 25},
    {sipName_Pixmap, static_cast<int>( ::QQmlImageProviderBase::Pixmap), 25},
    {sipName_Texture, static_cast<int>( ::QQmlImageProviderBase::Texture), 25},
};


static pyqt5ClassPluginDef plugin_QQmlImageProviderBase = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlImageProviderBase = {
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlImageProviderBase,
        {0},
        &plugin_QQmlImageProviderBase
    },
    {
        sipNameNr_QQmlImageProviderBase,
        {0, 0, 1},
        2, methods_QQmlImageProviderBase,
        5, enummembers_QQmlImageProviderBase,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    -1,
    -1,
    0,
    0,
    0,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlImageProviderBase,
    0,
    0,
    0,
    release_QQmlImageProviderBase,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlcontext.sip"
#include <qqmlcontext.h>
#line 11282 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 11286 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 11289 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 96 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 11292 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 11295 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 11298 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 11301 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 11304 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 11307 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 11310 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 11313 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 11316 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 11319 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 11322 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 11325 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 11328 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 11331 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 11334 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 11337 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlContext : public  ::QQmlContext
{
public:
    sipQQmlContext( ::QQmlEngine*, ::QObject*);
    sipQQmlContext( ::QQmlContext*, ::QObject*);
    virtual ~sipQQmlContext();

    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:
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const  ::QMetaMethod&);
    void disconnectNotify(const  ::QMetaMethod&);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[7];
};

sipQQmlContext::sipQQmlContext( ::QQmlEngine*a0, ::QObject*a1):  ::QQmlContext(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlContext::sipQQmlContext( ::QQmlContext*a0, ::QObject*a1):  ::QQmlContext(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlContext::~sipQQmlContext()
{
    sipInstanceDestroyed(sipPySelf);
}

const QMetaObject *sipQQmlContext::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtQml_qt_metaobject(sipPySelf,sipType_QQmlContext);

    return  ::QQmlContext::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtQml_qt_metacall(sipPySelf,sipType_QQmlContext,_c,_id,_a);

    return _id;
}

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

    return (sip_QtQml_qt_metacast(sipPySelf, sipType_QQmlContext, _clname, &sipCpp) ? sipCpp :  ::QQmlContext::qt_metacast(_clname));
}

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

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

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

    extern bool sipVH_QtQml_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtQml_5(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern bool sipVH_QtQml_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtQml_4(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    extern void sipVH_QtQml_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtQml_3(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtQml_2(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtQml_1(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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


PyDoc_STRVAR(doc_QQmlContext_sender, "sender(self) -> QObject");

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

    {
        const sipQQmlContext *sipCpp;

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

#line 560 "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");
                Q_ASSERT(qtcore_qobject_sender);
            }
        
            sipRes = qtcore_qobject_sender();
        }
#line 11637 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

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

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_receivers, "receivers(self, PYQT_SIGNAL) -> int");

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

    {
        PyObject * a0;
        const sipQQmlContext *sipCpp;

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

#line 591 "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");
            Q_ASSERT(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 11697 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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_QQmlContext, sipName_receivers, doc_QQmlContext_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_timerEvent, "timerEvent(self, QTimerEvent)");

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

    {
         ::QTimerEvent* a0;
        sipQQmlContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlContext, &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_QQmlContext, sipName_timerEvent, doc_QQmlContext_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_childEvent, "childEvent(self, QChildEvent)");

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

    {
         ::QChildEvent* a0;
        sipQQmlContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlContext, &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_QQmlContext, sipName_childEvent, doc_QQmlContext_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_customEvent, "customEvent(self, QEvent)");

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

    {
         ::QEvent* a0;
        sipQQmlContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlContext, &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_QQmlContext, sipName_customEvent, doc_QQmlContext_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_connectNotify, "connectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlContext, &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_QQmlContext, sipName_connectNotify, doc_QQmlContext_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_disconnectNotify, "disconnectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlContext, &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_QQmlContext, sipName_disconnectNotify, doc_QQmlContext_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_senderSignalIndex, "senderSignalIndex(self) -> int");

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

    {
        const sipQQmlContext *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_isSignalConnected, "isSignalConnected(self, QMetaMethod) -> bool");

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

    {
        const  ::QMetaMethod* a0;
        const sipQQmlContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlContext, &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_QQmlContext, sipName_isSignalConnected, doc_QQmlContext_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_isValid, "isValid(self) -> bool");

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

    {
        const  ::QQmlContext *sipCpp;

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

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlContext, sipName_isValid, doc_QQmlContext_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_engine, "engine(self) -> QQmlEngine");

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

    {
        const  ::QQmlContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlContext, &sipCpp))
        {
             ::QQmlEngine*sipRes;

            sipRes = sipCpp->engine();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlContext, sipName_engine, doc_QQmlContext_engine);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_parentContext, "parentContext(self) -> QQmlContext");

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

    {
        const  ::QQmlContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlContext, &sipCpp))
        {
             ::QQmlContext*sipRes;

            sipRes = sipCpp->parentContext();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlContext, sipName_parentContext, doc_QQmlContext_parentContext);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_contextObject, "contextObject(self) -> QObject");

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

    {
        const  ::QQmlContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlContext, &sipCpp))
        {
             ::QObject*sipRes;

            sipRes = sipCpp->contextObject();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlContext, sipName_contextObject, doc_QQmlContext_contextObject);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_setContextObject, "setContextObject(self, QObject)");

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

    {
         ::QObject* a0;
         ::QQmlContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QQmlContext, &sipCpp, sipType_QObject, &a0))
        {
            sipCpp->setContextObject(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlContext, sipName_setContextObject, doc_QQmlContext_setContextObject);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_contextProperty, "contextProperty(self, str) -> Any");

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

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QQmlContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlContext, &sipCpp, sipType_QString,&a0, &a0State))
        {
             ::QVariant*sipRes;

            sipRes = new  ::QVariant(sipCpp->contextProperty(*a0));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlContext, sipName_contextProperty, doc_QQmlContext_contextProperty);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_setContextProperty, "setContextProperty(self, str, QObject)\n"
    "setContextProperty(self, str, Any)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QObject* a1;
         ::QQmlContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J8", &sipSelf, sipType_QQmlContext, &sipCpp, sipType_QString,&a0, &a0State, sipType_QObject, &a1))
        {
            sipCpp->setContextProperty(*a0,a1);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QVariant* a1;
        int a1State = 0;
         ::QQmlContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_QQmlContext, &sipCpp, sipType_QString,&a0, &a0State, sipType_QVariant, &a1, &a1State))
        {
            sipCpp->setContextProperty(*a0,*a1);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QVariant *>(a1),sipType_QVariant,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlContext, sipName_setContextProperty, doc_QQmlContext_setContextProperty);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_nameForObject, "nameForObject(self, QObject) -> str");

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

    {
         ::QObject* a0;
        const  ::QQmlContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QQmlContext, &sipCpp, sipType_QObject, &a0))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->nameForObject(a0));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlContext, sipName_nameForObject, doc_QQmlContext_nameForObject);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_resolvedUrl, "resolvedUrl(self, QUrl) -> QUrl");

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

    {
        const  ::QUrl* a0;
         ::QQmlContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QQmlContext, &sipCpp, sipType_QUrl, &a0))
        {
             ::QUrl*sipRes;

            sipRes = new  ::QUrl(sipCpp->resolvedUrl(*a0));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlContext, sipName_resolvedUrl, doc_QQmlContext_resolvedUrl);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_setBaseUrl, "setBaseUrl(self, QUrl)");

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

    {
        const  ::QUrl* a0;
         ::QQmlContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QQmlContext, &sipCpp, sipType_QUrl, &a0))
        {
            sipCpp->setBaseUrl(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlContext, sipName_setBaseUrl, doc_QQmlContext_setBaseUrl);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlContext_baseUrl, "baseUrl(self) -> QUrl");

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

    {
        const  ::QQmlContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlContext, &sipCpp))
        {
             ::QUrl*sipRes;

            sipRes = new  ::QUrl(sipCpp->baseUrl());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlContext, sipName_baseUrl, doc_QQmlContext_baseUrl);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QQmlContext(void *, const sipTypeDef *);}
static void *cast_QQmlContext(void *sipCppV, const sipTypeDef *targetType)
{
     ::QQmlContext *sipCpp = reinterpret_cast< ::QQmlContext *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


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

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


extern "C" {static void dealloc_QQmlContext(sipSimpleWrapper *);}
static void dealloc_QQmlContext(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlContext *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlContext(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


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

    {
         ::QQmlEngine* a0;
         ::QObject* a1 = 0;

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

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

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
         ::QQmlContext* a0;
         ::QObject* a1 = 0;

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

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

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QQmlContext[] = {
    {SIP_MLNAME_CAST(sipName_baseUrl), meth_QQmlContext_baseUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlContext_baseUrl)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QQmlContext_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QQmlContext_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_contextObject), meth_QQmlContext_contextObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlContext_contextObject)},
    {SIP_MLNAME_CAST(sipName_contextProperty), meth_QQmlContext_contextProperty, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlContext_contextProperty)},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QQmlContext_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QQmlContext_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_engine), meth_QQmlContext_engine, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlContext_engine)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QQmlContext_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QQmlContext_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlContext_isValid)},
    {SIP_MLNAME_CAST(sipName_nameForObject), meth_QQmlContext_nameForObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlContext_nameForObject)},
    {SIP_MLNAME_CAST(sipName_parentContext), meth_QQmlContext_parentContext, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlContext_parentContext)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QQmlContext_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_resolvedUrl), meth_QQmlContext_resolvedUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlContext_resolvedUrl)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QQmlContext_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QQmlContext_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setBaseUrl), meth_QQmlContext_setBaseUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlContext_setBaseUrl)},
    {SIP_MLNAME_CAST(sipName_setContextObject), meth_QQmlContext_setContextObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlContext_setContextObject)},
    {SIP_MLNAME_CAST(sipName_setContextProperty), meth_QQmlContext_setContextProperty, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlContext_setContextProperty)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QQmlContext_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QQmlContext, "\1QQmlContext(QQmlEngine, parent: QObject = None)\n"
    "QQmlContext(QQmlContext, parent: QObject = None)");


static pyqt5ClassPluginDef plugin_QQmlContext = {
    & ::QQmlContext::staticMetaObject,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlContext = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlContext,
        {0},
        &plugin_QQmlContext
    },
    {
        sipNameNr_QQmlContext,
        {0, 0, 1},
        20, methods_QQmlContext,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlContext,
    -1,
    -1,
    supers_QQmlContext,
    0,
    init_type_QQmlContext,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlContext,
    0,
    0,
    0,
    release_QQmlContext,
    cast_QQmlContext,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlcomponent.sip"
#include <qqmlcomponent.h>
#line 12433 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 12437 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 12440 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 12443 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 96 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 12446 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 12449 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlcontext.sip"
#include <qqmlcontext.h>
#line 12452 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlincubator.sip"
#include <qqmlincubator.h>
#line 12455 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 12458 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlerror.sip"
#include <qqmlerror.h>
#line 12461 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 12464 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 12467 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 12470 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 12473 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 12476 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 12479 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 12482 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 12485 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 12488 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 12491 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 12494 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 12497 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 12500 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlComponent : public  ::QQmlComponent
{
public:
    sipQQmlComponent( ::QQmlEngine*, ::QObject*);
    sipQQmlComponent( ::QQmlEngine*,const  ::QString&, ::QObject*);
    sipQQmlComponent( ::QQmlEngine*,const  ::QString&, ::QQmlComponent::CompilationMode, ::QObject*);
    sipQQmlComponent( ::QQmlEngine*,const  ::QUrl&, ::QObject*);
    sipQQmlComponent( ::QQmlEngine*,const  ::QUrl&, ::QQmlComponent::CompilationMode, ::QObject*);
    sipQQmlComponent( ::QObject*);
    virtual ~sipQQmlComponent();

    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 completeCreate();
     ::QObject* beginCreate( ::QQmlContext*);
     ::QObject* create( ::QQmlContext*);
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const  ::QMetaMethod&);
    void disconnectNotify(const  ::QMetaMethod&);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[10];
};

sipQQmlComponent::sipQQmlComponent( ::QQmlEngine*a0, ::QObject*a1):  ::QQmlComponent(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlComponent::sipQQmlComponent( ::QQmlEngine*a0,const  ::QString& a1, ::QObject*a2):  ::QQmlComponent(a0,a1,a2), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlComponent::sipQQmlComponent( ::QQmlEngine*a0,const  ::QString& a1, ::QQmlComponent::CompilationMode a2, ::QObject*a3):  ::QQmlComponent(a0,a1,a2,a3), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlComponent::sipQQmlComponent( ::QQmlEngine*a0,const  ::QUrl& a1, ::QObject*a2):  ::QQmlComponent(a0,a1,a2), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlComponent::sipQQmlComponent( ::QQmlEngine*a0,const  ::QUrl& a1, ::QQmlComponent::CompilationMode a2, ::QObject*a3):  ::QQmlComponent(a0,a1,a2,a3), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlComponent::sipQQmlComponent( ::QObject*a0):  ::QQmlComponent(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlComponent::~sipQQmlComponent()
{
    sipInstanceDestroyed(sipPySelf);
}

const QMetaObject *sipQQmlComponent::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtQml_qt_metaobject(sipPySelf,sipType_QQmlComponent);

    return  ::QQmlComponent::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtQml_qt_metacall(sipPySelf,sipType_QQmlComponent,_c,_id,_a);

    return _id;
}

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

    return (sip_QtQml_qt_metacast(sipPySelf, sipType_QQmlComponent, _clname, &sipCpp) ? sipCpp :  ::QQmlComponent::qt_metacast(_clname));
}

void sipQQmlComponent::completeCreate()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::QQmlComponent::completeCreate();
        return;
    }

    extern void sipVH_QtQml_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtQml_8(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

 ::QObject* sipQQmlComponent::beginCreate( ::QQmlContext*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QQmlComponent::beginCreate(a0);

    extern  ::QObject* sipVH_QtQml_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QQmlContext*);

    return sipVH_QtQml_7(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

 ::QObject* sipQQmlComponent::create( ::QQmlContext*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QQmlComponent::create(a0);

    extern  ::QObject* sipVH_QtQml_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QQmlContext*);

    return sipVH_QtQml_7(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern bool sipVH_QtQml_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtQml_5(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern bool sipVH_QtQml_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtQml_4(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    extern void sipVH_QtQml_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtQml_3(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtQml_2(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtQml_1(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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


PyDoc_STRVAR(doc_QQmlComponent_sender, "sender(self) -> QObject");

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

    {
        const sipQQmlComponent *sipCpp;

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

#line 560 "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");
                Q_ASSERT(qtcore_qobject_sender);
            }
        
            sipRes = qtcore_qobject_sender();
        }
#line 12875 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

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

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_receivers, "receivers(self, PYQT_SIGNAL) -> int");

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

    {
        PyObject * a0;
        const sipQQmlComponent *sipCpp;

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

#line 591 "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");
            Q_ASSERT(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 12935 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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_QQmlComponent, sipName_receivers, doc_QQmlComponent_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_timerEvent, "timerEvent(self, QTimerEvent)");

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

    {
         ::QTimerEvent* a0;
        sipQQmlComponent *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlComponent, &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_QQmlComponent, sipName_timerEvent, doc_QQmlComponent_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_childEvent, "childEvent(self, QChildEvent)");

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

    {
         ::QChildEvent* a0;
        sipQQmlComponent *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlComponent, &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_QQmlComponent, sipName_childEvent, doc_QQmlComponent_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_customEvent, "customEvent(self, QEvent)");

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

    {
         ::QEvent* a0;
        sipQQmlComponent *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlComponent, &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_QQmlComponent, sipName_customEvent, doc_QQmlComponent_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_connectNotify, "connectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlComponent *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlComponent, &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_QQmlComponent, sipName_connectNotify, doc_QQmlComponent_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_disconnectNotify, "disconnectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlComponent *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlComponent, &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_QQmlComponent, sipName_disconnectNotify, doc_QQmlComponent_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_senderSignalIndex, "senderSignalIndex(self) -> int");

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

    {
        const sipQQmlComponent *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_isSignalConnected, "isSignalConnected(self, QMetaMethod) -> bool");

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

    {
        const  ::QMetaMethod* a0;
        const sipQQmlComponent *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlComponent, &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_QQmlComponent, sipName_isSignalConnected, doc_QQmlComponent_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_status, "status(self) -> QQmlComponent.Status");

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

    {
        const  ::QQmlComponent *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlComponent, &sipCpp))
        {
             ::QQmlComponent::Status sipRes;

            sipRes = sipCpp->status();

            return sipConvertFromEnum(sipRes,sipType_QQmlComponent_Status);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlComponent, sipName_status, doc_QQmlComponent_status);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_isNull, "isNull(self) -> bool");

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

    {
        const  ::QQmlComponent *sipCpp;

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

            sipRes = sipCpp->isNull();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlComponent, sipName_isNull, doc_QQmlComponent_isNull);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_isReady, "isReady(self) -> bool");

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

    {
        const  ::QQmlComponent *sipCpp;

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

            sipRes = sipCpp->isReady();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlComponent, sipName_isReady, doc_QQmlComponent_isReady);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_isError, "isError(self) -> bool");

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

    {
        const  ::QQmlComponent *sipCpp;

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

            sipRes = sipCpp->isError();

            return PyBool_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_isLoading, "isLoading(self) -> bool");

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

    {
        const  ::QQmlComponent *sipCpp;

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

            sipRes = sipCpp->isLoading();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlComponent, sipName_isLoading, doc_QQmlComponent_isLoading);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_errors, "errors(self) -> List[QQmlError]");

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

    {
        const  ::QQmlComponent *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlComponent, &sipCpp))
        {
            QList< ::QQmlError>*sipRes;

            sipRes = new QList< ::QQmlError>(sipCpp->errors());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlComponent, sipName_errors, doc_QQmlComponent_errors);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_progress, "progress(self) -> float");

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

    {
        const  ::QQmlComponent *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlComponent, &sipCpp))
        {
             ::qreal sipRes;

            sipRes = sipCpp->progress();

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlComponent, sipName_progress, doc_QQmlComponent_progress);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_url, "url(self) -> QUrl");

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

    {
        const  ::QQmlComponent *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlComponent, &sipCpp))
        {
             ::QUrl*sipRes;

            sipRes = new  ::QUrl(sipCpp->url());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlComponent, sipName_url, doc_QQmlComponent_url);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_create, "create(self, context: QQmlContext = None) -> QObject\n"
    "create(self, QQmlIncubator, context: QQmlContext = None, forContext: QQmlContext = None)");

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

    {
         ::QQmlContext* a0 = 0;
         ::QQmlComponent *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J8", &sipSelf, sipType_QQmlComponent, &sipCpp, sipType_QQmlContext, &a0))
        {
             ::QObject*sipRes;

            sipRes = (sipSelfWasArg ? sipCpp-> ::QQmlComponent::create(a0) : sipCpp->create(a0));

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

    {
         ::QQmlIncubator* a0;
         ::QQmlContext* a1 = 0;
         ::QQmlContext* a2 = 0;
         ::QQmlComponent *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|J8J8", &sipSelf, sipType_QQmlComponent, &sipCpp, sipType_QQmlIncubator, &a0, sipType_QQmlContext, &a1, sipType_QQmlContext, &a2))
        {
            sipCpp->create(*a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_beginCreate, "beginCreate(self, QQmlContext) -> QObject");

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

    {
         ::QQmlContext* a0;
         ::QQmlComponent *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QQmlComponent, &sipCpp, sipType_QQmlContext, &a0))
        {
             ::QObject*sipRes;

            sipRes = (sipSelfWasArg ? sipCpp-> ::QQmlComponent::beginCreate(a0) : sipCpp->beginCreate(a0));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlComponent, sipName_beginCreate, doc_QQmlComponent_beginCreate);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_completeCreate, "completeCreate(self)");

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

    {
         ::QQmlComponent *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlComponent, &sipCpp))
        {
            (sipSelfWasArg ? sipCpp-> ::QQmlComponent::completeCreate() : sipCpp->completeCreate());

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlComponent, sipName_completeCreate, doc_QQmlComponent_completeCreate);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_creationContext, "creationContext(self) -> QQmlContext");

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

    {
        const  ::QQmlComponent *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlComponent, &sipCpp))
        {
             ::QQmlContext*sipRes;

            sipRes = sipCpp->creationContext();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlComponent, sipName_creationContext, doc_QQmlComponent_creationContext);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_loadUrl, "loadUrl(self, QUrl)\n"
    "loadUrl(self, QUrl, QQmlComponent.CompilationMode)");

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

    {
        const  ::QUrl* a0;
         ::QQmlComponent *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QQmlComponent, &sipCpp, sipType_QUrl, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->loadUrl(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QUrl* a0;
         ::QQmlComponent::CompilationMode a1;
         ::QQmlComponent *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9E", &sipSelf, sipType_QQmlComponent, &sipCpp, sipType_QUrl, &a0, sipType_QQmlComponent_CompilationMode, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->loadUrl(*a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlComponent, sipName_loadUrl, doc_QQmlComponent_loadUrl);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlComponent_setData, "setData(self, Union[QByteArray, bytes, bytearray], QUrl)");

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

    {
        const  ::QByteArray* a0;
        int a0State = 0;
        const  ::QUrl* a1;
         ::QQmlComponent *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J9", &sipSelf, sipType_QQmlComponent, &sipCpp, sipType_QByteArray, &a0, &a0State, sipType_QUrl, &a1))
        {
            sipCpp->setData(*a0,*a1);
            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_QQmlComponent, sipName_setData, doc_QQmlComponent_setData);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QQmlComponent(void *, const sipTypeDef *);}
static void *cast_QQmlComponent(void *sipCppV, const sipTypeDef *targetType)
{
     ::QQmlComponent *sipCpp = reinterpret_cast< ::QQmlComponent *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


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

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


extern "C" {static void dealloc_QQmlComponent(sipSimpleWrapper *);}
static void dealloc_QQmlComponent(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlComponent *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlComponent(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


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

    {
         ::QQmlEngine* a0;
         ::QObject* a1 = 0;

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

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

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
         ::QQmlEngine* a0;
        const  ::QString* a1;
        int a1State = 0;
         ::QObject* a2 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J8J1|JH", sipType_QQmlEngine, &a0, sipType_QString,&a1, &a1State, sipType_QObject, &a2, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQQmlComponent(a0,*a1,a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
         ::QQmlEngine* a0;
        const  ::QString* a1;
        int a1State = 0;
         ::QQmlComponent::CompilationMode a2;
         ::QObject* a3 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J8J1E|JH", sipType_QQmlEngine, &a0, sipType_QString,&a1, &a1State, sipType_QQmlComponent_CompilationMode, &a2, sipType_QObject, &a3, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQQmlComponent(a0,*a1,a2,a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
         ::QQmlEngine* a0;
        const  ::QUrl* a1;
         ::QObject* a2 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J8J9|JH", sipType_QQmlEngine, &a0, sipType_QUrl, &a1, sipType_QObject, &a2, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQQmlComponent(a0,*a1,a2);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
         ::QQmlEngine* a0;
        const  ::QUrl* a1;
         ::QQmlComponent::CompilationMode a2;
         ::QObject* a3 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J8J9E|JH", sipType_QQmlEngine, &a0, sipType_QUrl, &a1, sipType_QQmlComponent_CompilationMode, &a2, sipType_QObject, &a3, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQQmlComponent(a0,*a1,a2,a3);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
         ::QObject* a0 = 0;

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

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

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QQmlComponent[] = {
    {SIP_MLNAME_CAST(sipName_beginCreate), meth_QQmlComponent_beginCreate, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_beginCreate)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QQmlComponent_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_completeCreate), meth_QQmlComponent_completeCreate, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_completeCreate)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QQmlComponent_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_create), (PyCFunction)meth_QQmlComponent_create, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QQmlComponent_create)},
    {SIP_MLNAME_CAST(sipName_creationContext), meth_QQmlComponent_creationContext, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_creationContext)},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QQmlComponent_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QQmlComponent_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_errors), meth_QQmlComponent_errors, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_errors)},
    {SIP_MLNAME_CAST(sipName_isError), meth_QQmlComponent_isError, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_isError)},
    {SIP_MLNAME_CAST(sipName_isLoading), meth_QQmlComponent_isLoading, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_isLoading)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QQmlComponent_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_isNull)},
    {SIP_MLNAME_CAST(sipName_isReady), meth_QQmlComponent_isReady, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_isReady)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QQmlComponent_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_loadUrl), meth_QQmlComponent_loadUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_loadUrl)},
    {SIP_MLNAME_CAST(sipName_progress), meth_QQmlComponent_progress, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_progress)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QQmlComponent_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QQmlComponent_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QQmlComponent_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setData), meth_QQmlComponent_setData, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_setData)},
    {SIP_MLNAME_CAST(sipName_status), meth_QQmlComponent_status, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_status)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QQmlComponent_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_url), meth_QQmlComponent_url, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlComponent_url)}
};

static sipEnumMemberDef enummembers_QQmlComponent[] = {
    {sipName_Asynchronous, static_cast<int>( ::QQmlComponent::Asynchronous), 13},
    {sipName_Error, static_cast<int>( ::QQmlComponent::Error), 14},
    {sipName_Loading, static_cast<int>( ::QQmlComponent::Loading), 14},
    {sipName_Null, static_cast<int>( ::QQmlComponent::Null), 14},
    {sipName_PreferSynchronous, static_cast<int>( ::QQmlComponent::PreferSynchronous), 13},
    {sipName_Ready, static_cast<int>( ::QQmlComponent::Ready), 14},
};

PyDoc_STRVAR(doc_QQmlComponent, "\1QQmlComponent(QQmlEngine, parent: QObject = None)\n"
    "QQmlComponent(QQmlEngine, str, parent: QObject = None)\n"
    "QQmlComponent(QQmlEngine, str, QQmlComponent.CompilationMode, parent: QObject = None)\n"
    "QQmlComponent(QQmlEngine, QUrl, parent: QObject = None)\n"
    "QQmlComponent(QQmlEngine, QUrl, QQmlComponent.CompilationMode, parent: QObject = None)\n"
    "QQmlComponent(parent: QObject = None)");


/* Define this type's signals. */
static const pyqt5QtSignal signals_QQmlComponent[] = {
    {"progressChanged(qreal)", "\1progressChanged(self, float)", 0, 0},
    {"statusChanged(QQmlComponent::Status)", "\1statusChanged(self, QQmlComponent.Status)", 0, 0},
    {0, 0, 0, 0}
};


static pyqt5ClassPluginDef plugin_QQmlComponent = {
    & ::QQmlComponent::staticMetaObject,
    0,
    signals_QQmlComponent,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlComponent = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlComponent,
        {0},
        &plugin_QQmlComponent
    },
    {
        sipNameNr_QQmlComponent,
        {0, 0, 1},
        23, methods_QQmlComponent,
        6, enummembers_QQmlComponent,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlComponent,
    -1,
    -1,
    supers_QQmlComponent,
    0,
    init_type_QQmlComponent,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlComponent,
    0,
    0,
    0,
    release_QQmlComponent,
    cast_QQmlComponent,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlapplicationengine.sip"
#include <qqmlapplicationengine.h>
#line 13903 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 13907 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 96 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 13910 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 13913 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 13916 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 13919 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 13922 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlerror.sip"
#include <qqmlerror.h>
#line 13925 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 13928 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 13931 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlcontext.sip"
#include <qqmlcontext.h>
#line 13934 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 69 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlincubator.sip"
#include <qqmlincubator.h>
#line 13937 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 13940 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtNetwork/qnetworkaccessmanager.sip"
#include <qnetworkaccessmanager.h>
#line 13943 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlnetworkaccessmanagerfactory.sip"
#include <qqmlnetworkaccessmanagerfactory.h>
#line 13946 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 36 "sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 13949 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsvalue.sip"
#include <qjsvalue.h>
#line 13952 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 13955 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsengine.sip"
#include <qjsengine.h>
#line 13958 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 13961 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 13964 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 13967 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 13970 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 13973 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 13976 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 13979 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 13982 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 13985 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 13988 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlApplicationEngine : public  ::QQmlApplicationEngine
{
public:
    sipQQmlApplicationEngine( ::QObject*);
    sipQQmlApplicationEngine(const  ::QUrl&, ::QObject*);
    sipQQmlApplicationEngine(const  ::QString&, ::QObject*);
    virtual ~sipQQmlApplicationEngine();

    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;
    bool sipProtectVirt_event(bool, ::QEvent*);

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

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[7];
};

sipQQmlApplicationEngine::sipQQmlApplicationEngine( ::QObject*a0):  ::QQmlApplicationEngine(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlApplicationEngine::sipQQmlApplicationEngine(const  ::QUrl& a0, ::QObject*a1):  ::QQmlApplicationEngine(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlApplicationEngine::sipQQmlApplicationEngine(const  ::QString& a0, ::QObject*a1):  ::QQmlApplicationEngine(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlApplicationEngine::~sipQQmlApplicationEngine()
{
    sipInstanceDestroyed(sipPySelf);
}

const QMetaObject *sipQQmlApplicationEngine::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtQml_qt_metaobject(sipPySelf,sipType_QQmlApplicationEngine);

    return  ::QQmlApplicationEngine::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtQml_qt_metacall(sipPySelf,sipType_QQmlApplicationEngine,_c,_id,_a);

    return _id;
}

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

    return (sip_QtQml_qt_metacast(sipPySelf, sipType_QQmlApplicationEngine, _clname, &sipCpp) ? sipCpp :  ::QQmlApplicationEngine::qt_metacast(_clname));
}

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

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

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

    extern bool sipVH_QtQml_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtQml_5(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern bool sipVH_QtQml_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtQml_4(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    extern void sipVH_QtQml_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtQml_3(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtQml_2(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtQml_1(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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

bool sipQQmlApplicationEngine::sipProtectVirt_event(bool sipSelfWasArg, ::QEvent*a0)
{
    return (sipSelfWasArg ?  ::QQmlEngine::event(a0) : event(a0));
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_sender, "sender(self) -> QObject");

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

    {
        const sipQQmlApplicationEngine *sipCpp;

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

#line 560 "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");
                Q_ASSERT(qtcore_qobject_sender);
            }
        
            sipRes = qtcore_qobject_sender();
        }
#line 14300 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

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

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_receivers, "receivers(self, PYQT_SIGNAL) -> int");

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

    {
        PyObject * a0;
        const sipQQmlApplicationEngine *sipCpp;

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

#line 591 "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");
            Q_ASSERT(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 14360 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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_QQmlApplicationEngine, sipName_receivers, doc_QQmlApplicationEngine_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_timerEvent, "timerEvent(self, QTimerEvent)");

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

    {
         ::QTimerEvent* a0;
        sipQQmlApplicationEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlApplicationEngine, &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_QQmlApplicationEngine, sipName_timerEvent, doc_QQmlApplicationEngine_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_childEvent, "childEvent(self, QChildEvent)");

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

    {
         ::QChildEvent* a0;
        sipQQmlApplicationEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlApplicationEngine, &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_QQmlApplicationEngine, sipName_childEvent, doc_QQmlApplicationEngine_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_customEvent, "customEvent(self, QEvent)");

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

    {
         ::QEvent* a0;
        sipQQmlApplicationEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlApplicationEngine, &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_QQmlApplicationEngine, sipName_customEvent, doc_QQmlApplicationEngine_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_connectNotify, "connectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlApplicationEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlApplicationEngine, &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_QQmlApplicationEngine, sipName_connectNotify, doc_QQmlApplicationEngine_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_disconnectNotify, "disconnectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlApplicationEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlApplicationEngine, &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_QQmlApplicationEngine, sipName_disconnectNotify, doc_QQmlApplicationEngine_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_senderSignalIndex, "senderSignalIndex(self) -> int");

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

    {
        const sipQQmlApplicationEngine *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_isSignalConnected, "isSignalConnected(self, QMetaMethod) -> bool");

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

    {
        const  ::QMetaMethod* a0;
        const sipQQmlApplicationEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlApplicationEngine, &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_QQmlApplicationEngine, sipName_isSignalConnected, doc_QQmlApplicationEngine_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_event, "event(self, QEvent) -> bool");

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

    {
         ::QEvent* a0;
        sipQQmlApplicationEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlApplicationEngine, &sipCpp, sipType_QEvent, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtectVirt_event(sipSelfWasArg,a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlApplicationEngine, sipName_event, doc_QQmlApplicationEngine_event);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_rootObjects, "rootObjects(self) -> List[QObject]");

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

    {
        const  ::QQmlApplicationEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlApplicationEngine, &sipCpp))
        {
            QList< ::QObject*>*sipRes;

            sipRes = new QList< ::QObject*>(sipCpp->rootObjects());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlApplicationEngine, sipName_rootObjects, doc_QQmlApplicationEngine_rootObjects);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_load, "load(self, QUrl)\n"
    "load(self, str)");

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

    {
        const  ::QUrl* a0;
         ::QQmlApplicationEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QQmlApplicationEngine, &sipCpp, sipType_QUrl, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->load(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QQmlApplicationEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlApplicationEngine, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->load(*a0);
            Py_END_ALLOW_THREADS
            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_QQmlApplicationEngine, sipName_load, doc_QQmlApplicationEngine_load);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlApplicationEngine_loadData, "loadData(self, Union[QByteArray, bytes, bytearray], url: QUrl = QUrl())");

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

    {
        const  ::QByteArray* a0;
        int a0State = 0;
        const  ::QUrl& a1def = QUrl();
        const  ::QUrl* a1 = &a1def;
         ::QQmlApplicationEngine *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|J9", &sipSelf, sipType_QQmlApplicationEngine, &sipCpp, sipType_QByteArray, &a0, &a0State, sipType_QUrl, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->loadData(*a0,*a1);
            Py_END_ALLOW_THREADS
            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_QQmlApplicationEngine, sipName_loadData, doc_QQmlApplicationEngine_loadData);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QQmlApplicationEngine(void *, const sipTypeDef *);}
static void *cast_QQmlApplicationEngine(void *sipCppV, const sipTypeDef *targetType)
{
     ::QQmlApplicationEngine *sipCpp = reinterpret_cast< ::QQmlApplicationEngine *>(sipCppV);

    if (targetType == sipType_QQmlEngine)
        return static_cast< ::QQmlEngine *>(sipCpp);

    if (targetType == sipType_QJSEngine)
        return static_cast< ::QJSEngine *>(sipCpp);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


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

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


extern "C" {static void dealloc_QQmlApplicationEngine(sipSimpleWrapper *);}
static void dealloc_QQmlApplicationEngine(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlApplicationEngine *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlApplicationEngine(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QQmlApplicationEngine(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QQmlApplicationEngine(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQQmlApplicationEngine *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 sipQQmlApplicationEngine(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QUrl* a0;
         ::QObject* a1 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9|JH", sipType_QUrl, &a0, sipType_QObject, &a1, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQQmlApplicationEngine(*a0,a1);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QObject* a1 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J1|JH", sipType_QString,&a0, &a0State, sipType_QObject, &a1, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQQmlApplicationEngine(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QQmlApplicationEngine[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QQmlApplicationEngine_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QQmlApplicationEngine_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QQmlApplicationEngine_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QQmlApplicationEngine_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_event), (PyCFunction)meth_QQmlApplicationEngine_event, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QQmlApplicationEngine_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_load), meth_QQmlApplicationEngine_load, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlApplicationEngine_load)},
    {SIP_MLNAME_CAST(sipName_loadData), (PyCFunction)meth_QQmlApplicationEngine_loadData, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QQmlApplicationEngine_loadData)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QQmlApplicationEngine_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_rootObjects), meth_QQmlApplicationEngine_rootObjects, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlApplicationEngine_rootObjects)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QQmlApplicationEngine_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QQmlApplicationEngine_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QQmlApplicationEngine_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QQmlApplicationEngine, "\1QQmlApplicationEngine(parent: QObject = None)\n"
    "QQmlApplicationEngine(QUrl, parent: QObject = None)\n"
    "QQmlApplicationEngine(str, parent: QObject = None)");


/* Define this type's signals. */
static const pyqt5QtSignal signals_QQmlApplicationEngine[] = {
    {"objectCreated(QObject*,QUrl)", "\1objectCreated(self, QObject, QUrl)", 0, 0},
    {0, 0, 0, 0}
};


static pyqt5ClassPluginDef plugin_QQmlApplicationEngine = {
    & ::QQmlApplicationEngine::staticMetaObject,
    0,
    signals_QQmlApplicationEngine,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlApplicationEngine = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlApplicationEngine,
        {0},
        &plugin_QQmlApplicationEngine
    },
    {
        sipNameNr_QQmlApplicationEngine,
        {0, 0, 1},
        13, methods_QQmlApplicationEngine,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlApplicationEngine,
    -1,
    -1,
    supers_QQmlApplicationEngine,
    0,
    init_type_QQmlApplicationEngine,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlApplicationEngine,
    0,
    0,
    0,
    release_QQmlApplicationEngine,
    cast_QQmlApplicationEngine,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 14936 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 14940 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 14943 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 14946 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlerror.sip"
#include <qqmlerror.h>
#line 14949 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 14952 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlcontext.sip"
#include <qqmlcontext.h>
#line 14955 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 96 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 14958 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 69 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlincubator.sip"
#include <qqmlincubator.h>
#line 14961 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
#include <qqmlengine.h>
#line 14964 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtNetwork/qnetworkaccessmanager.sip"
#include <qnetworkaccessmanager.h>
#line 14967 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlnetworkaccessmanagerfactory.sip"
#include <qqmlnetworkaccessmanagerfactory.h>
#line 14970 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 36 "sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 14973 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsvalue.sip"
#include <qjsvalue.h>
#line 14976 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 14979 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsengine.sip"
#include <qjsengine.h>
#line 14982 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 14985 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 14988 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 14991 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 14994 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 14997 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 15000 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 15003 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 15006 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 15009 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 15012 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 15015 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 15018 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlEngine : public  ::QQmlEngine
{
public:
    sipQQmlEngine( ::QObject*);
    virtual ~sipQQmlEngine();

    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;
    bool sipProtectVirt_event(bool, ::QEvent*);

    /*
     * 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:
    sipQQmlEngine(const sipQQmlEngine &);
    sipQQmlEngine &operator = (const sipQQmlEngine &);

    char sipPyMethods[7];
};

sipQQmlEngine::sipQQmlEngine( ::QObject*a0):  ::QQmlEngine(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlEngine::~sipQQmlEngine()
{
    sipInstanceDestroyed(sipPySelf);
}

const QMetaObject *sipQQmlEngine::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtQml_qt_metaobject(sipPySelf,sipType_QQmlEngine);

    return  ::QQmlEngine::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtQml_qt_metacall(sipPySelf,sipType_QQmlEngine,_c,_id,_a);

    return _id;
}

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

    return (sip_QtQml_qt_metacast(sipPySelf, sipType_QQmlEngine, _clname, &sipCpp) ? sipCpp :  ::QQmlEngine::qt_metacast(_clname));
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtQml_1(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtQml_2(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtQml_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtQml_3(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern bool sipVH_QtQml_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtQml_4(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    extern bool sipVH_QtQml_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtQml_5(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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

bool sipQQmlEngine::sipProtectVirt_event(bool sipSelfWasArg, ::QEvent*a0)
{
    return (sipSelfWasArg ?  ::QQmlEngine::event(a0) : event(a0));
}


PyDoc_STRVAR(doc_QQmlEngine_sender, "sender(self) -> QObject");

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

    {
        const sipQQmlEngine *sipCpp;

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

#line 560 "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");
                Q_ASSERT(qtcore_qobject_sender);
            }
        
            sipRes = qtcore_qobject_sender();
        }
#line 15318 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

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

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_receivers, "receivers(self, PYQT_SIGNAL) -> int");

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

    {
        PyObject * a0;
        const sipQQmlEngine *sipCpp;

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

#line 591 "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");
            Q_ASSERT(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 15378 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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_QQmlEngine, sipName_receivers, doc_QQmlEngine_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_timerEvent, "timerEvent(self, QTimerEvent)");

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

    {
         ::QTimerEvent* a0;
        sipQQmlEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlEngine, &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_QQmlEngine, sipName_timerEvent, doc_QQmlEngine_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_childEvent, "childEvent(self, QChildEvent)");

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

    {
         ::QChildEvent* a0;
        sipQQmlEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlEngine, &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_QQmlEngine, sipName_childEvent, doc_QQmlEngine_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_customEvent, "customEvent(self, QEvent)");

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

    {
         ::QEvent* a0;
        sipQQmlEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlEngine, &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_QQmlEngine, sipName_customEvent, doc_QQmlEngine_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_connectNotify, "connectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlEngine, &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_QQmlEngine, sipName_connectNotify, doc_QQmlEngine_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_disconnectNotify, "disconnectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQQmlEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlEngine, &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_QQmlEngine, sipName_disconnectNotify, doc_QQmlEngine_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_senderSignalIndex, "senderSignalIndex(self) -> int");

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

    {
        const sipQQmlEngine *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_isSignalConnected, "isSignalConnected(self, QMetaMethod) -> bool");

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

    {
        const  ::QMetaMethod* a0;
        const sipQQmlEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QQmlEngine, &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_QQmlEngine, sipName_isSignalConnected, doc_QQmlEngine_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_rootContext, "rootContext(self) -> QQmlContext");

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

    {
        const  ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlEngine, &sipCpp))
        {
             ::QQmlContext*sipRes;

            sipRes = sipCpp->rootContext();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_rootContext, doc_QQmlEngine_rootContext);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_clearComponentCache, "clearComponentCache(self)");

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

    {
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlEngine, &sipCpp))
        {
            sipCpp->clearComponentCache();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_clearComponentCache, doc_QQmlEngine_clearComponentCache);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_trimComponentCache, "trimComponentCache(self)");

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

    {
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlEngine, &sipCpp))
        {
            sipCpp->trimComponentCache();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_trimComponentCache, doc_QQmlEngine_trimComponentCache);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_importPathList, "importPathList(self) -> List[str]");

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

    {
        const  ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlEngine, &sipCpp))
        {
             ::QStringList*sipRes;

            sipRes = new  ::QStringList(sipCpp->importPathList());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_importPathList, doc_QQmlEngine_importPathList);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_setImportPathList, "setImportPathList(self, Iterable[str])");

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

    {
        const  ::QStringList* a0;
        int a0State = 0;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QStringList,&a0, &a0State))
        {
            sipCpp->setImportPathList(*a0);
            sipReleaseType(const_cast< ::QStringList *>(a0),sipType_QStringList,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_setImportPathList, doc_QQmlEngine_setImportPathList);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_addImportPath, "addImportPath(self, str)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->addImportPath(*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_QQmlEngine, sipName_addImportPath, doc_QQmlEngine_addImportPath);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_pluginPathList, "pluginPathList(self) -> List[str]");

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

    {
        const  ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlEngine, &sipCpp))
        {
             ::QStringList*sipRes;

            sipRes = new  ::QStringList(sipCpp->pluginPathList());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_pluginPathList, doc_QQmlEngine_pluginPathList);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_setPluginPathList, "setPluginPathList(self, Iterable[str])");

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

    {
        const  ::QStringList* a0;
        int a0State = 0;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QStringList,&a0, &a0State))
        {
            sipCpp->setPluginPathList(*a0);
            sipReleaseType(const_cast< ::QStringList *>(a0),sipType_QStringList,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_setPluginPathList, doc_QQmlEngine_setPluginPathList);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_addPluginPath, "addPluginPath(self, str)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->addPluginPath(*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_QQmlEngine, sipName_addPluginPath, doc_QQmlEngine_addPluginPath);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_addNamedBundle, "addNamedBundle(self, str, str) -> bool");

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

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QString* a1;
        int a1State = 0;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State))
        {
            bool sipRes;

            sipRes = sipCpp->addNamedBundle(*a0,*a1);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_addNamedBundle, doc_QQmlEngine_addNamedBundle);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_importPlugin, "importPlugin(self, str, str, object) -> bool");

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

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QString* a1;
        int a1State = 0;
        QList< ::QQmlError>* a2;
        PyObject *a2Wrapper;
        int a2State = 0;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1@J0", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State, &a2Wrapper, sipType_QList_0100QQmlError,&a2, &a2State))
        {
            bool sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 82 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
        int orig_size = (a2 ? a2->size() : 0);
        
        sipRes = sipCpp->importPlugin(*a0, *a1, a2);
        
        if (a2)
        {
            for (int i = a2->size(); i > orig_size; --i)
            {
                QQmlError *new_error = new QQmlError(a2->at(i - orig_size - 1));
                PyObject *new_error_obj = sipConvertFromNewType(new_error, sipType_QQmlError, 0);
                
                if (!new_error_obj)
                {
                    delete new_error;
                    sipError = sipErrorFail;
                    break;
                }
                
                if (PyList_Insert(a2Wrapper, 0, new_error_obj) < 0)
                {
                    Py_DECREF(new_error_obj);
                    sipError = sipErrorFail;
                    break;
                }
                
                Py_DECREF(new_error_obj);
            }
        }
#line 15945 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);
            sipReleaseType(a2,sipType_QList_0100QQmlError,a2State);

            if (sipError == sipErrorFail)
                return 0;

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

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_importPlugin, doc_QQmlEngine_importPlugin);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_setNetworkAccessManagerFactory, "setNetworkAccessManagerFactory(self, QQmlNetworkAccessManagerFactory)");

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

    {
         ::QQmlNetworkAccessManagerFactory* a0;
        PyObject *a0Keep;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QQmlEngine, &sipCpp, &a0Keep, sipType_QQmlNetworkAccessManagerFactory, &a0))
        {
            sipCpp->setNetworkAccessManagerFactory(a0);

            sipKeepReference(sipSelf, -1, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_setNetworkAccessManagerFactory, doc_QQmlEngine_setNetworkAccessManagerFactory);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_networkAccessManagerFactory, "networkAccessManagerFactory(self) -> QQmlNetworkAccessManagerFactory");

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

    {
        const  ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlEngine, &sipCpp))
        {
             ::QQmlNetworkAccessManagerFactory*sipRes;

            sipRes = sipCpp->networkAccessManagerFactory();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_networkAccessManagerFactory, doc_QQmlEngine_networkAccessManagerFactory);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_networkAccessManager, "networkAccessManager(self) -> QNetworkAccessManager");

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

    {
        const  ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlEngine, &sipCpp))
        {
             ::QNetworkAccessManager*sipRes;

            sipRes = sipCpp->networkAccessManager();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_networkAccessManager, doc_QQmlEngine_networkAccessManager);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_addImageProvider, "addImageProvider(self, str, QQmlImageProviderBase)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QQmlImageProviderBase* a1;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J:", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QString,&a0, &a0State, sipType_QQmlImageProviderBase, &a1))
        {
            sipCpp->addImageProvider(*a0,a1);
            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_QQmlEngine, sipName_addImageProvider, doc_QQmlEngine_addImageProvider);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_imageProvider, "imageProvider(self, str) -> QQmlImageProviderBase");

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

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QString,&a0, &a0State))
        {
             ::QQmlImageProviderBase*sipRes;

            sipRes = sipCpp->imageProvider(*a0);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_imageProvider, doc_QQmlEngine_imageProvider);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_removeImageProvider, "removeImageProvider(self, str)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->removeImageProvider(*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_QQmlEngine, sipName_removeImageProvider, doc_QQmlEngine_removeImageProvider);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_setIncubationController, "setIncubationController(self, QQmlIncubationController)");

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

    {
         ::QQmlIncubationController* a0;
        PyObject *a0Keep;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QQmlEngine, &sipCpp, &a0Keep, sipType_QQmlIncubationController, &a0))
        {
            sipCpp->setIncubationController(a0);

            sipKeepReference(sipSelf, -2, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_setIncubationController, doc_QQmlEngine_setIncubationController);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_incubationController, "incubationController(self) -> QQmlIncubationController");

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

    {
        const  ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlEngine, &sipCpp))
        {
             ::QQmlIncubationController*sipRes;

            sipRes = sipCpp->incubationController();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_incubationController, doc_QQmlEngine_incubationController);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_setOfflineStoragePath, "setOfflineStoragePath(self, str)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setOfflineStoragePath(*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_QQmlEngine, sipName_setOfflineStoragePath, doc_QQmlEngine_setOfflineStoragePath);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_offlineStoragePath, "offlineStoragePath(self) -> str");

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

    {
        const  ::QQmlEngine *sipCpp;

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

            sipRes = new  ::QString(sipCpp->offlineStoragePath());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_offlineStoragePath, doc_QQmlEngine_offlineStoragePath);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_baseUrl, "baseUrl(self) -> QUrl");

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

    {
        const  ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QQmlEngine, &sipCpp))
        {
             ::QUrl*sipRes;

            sipRes = new  ::QUrl(sipCpp->baseUrl());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_baseUrl, doc_QQmlEngine_baseUrl);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_setBaseUrl, "setBaseUrl(self, QUrl)");

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

    {
        const  ::QUrl* a0;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QUrl, &a0))
        {
            sipCpp->setBaseUrl(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_setBaseUrl, doc_QQmlEngine_setBaseUrl);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_outputWarningsToStandardError, "outputWarningsToStandardError(self) -> bool");

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

    {
        const  ::QQmlEngine *sipCpp;

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

            sipRes = sipCpp->outputWarningsToStandardError();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_outputWarningsToStandardError, doc_QQmlEngine_outputWarningsToStandardError);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_setOutputWarningsToStandardError, "setOutputWarningsToStandardError(self, bool)");

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

    {
        bool a0;
         ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QQmlEngine, &sipCpp, &a0))
        {
            sipCpp->setOutputWarningsToStandardError(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_setOutputWarningsToStandardError, doc_QQmlEngine_setOutputWarningsToStandardError);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_contextForObject, "contextForObject(QObject) -> QQmlContext");

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

    {
        const  ::QObject* a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8", sipType_QObject, &a0))
        {
             ::QQmlContext*sipRes;

            sipRes =  ::QQmlEngine::contextForObject(a0);

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_contextForObject, doc_QQmlEngine_contextForObject);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_setContextForObject, "setContextForObject(QObject, QQmlContext)");

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

    {
         ::QObject* a0;
         ::QQmlContext* a1;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8J8", sipType_QObject, &a0, sipType_QQmlContext, &a1))
        {
             ::QQmlEngine::setContextForObject(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_setContextForObject, doc_QQmlEngine_setContextForObject);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_setObjectOwnership, "setObjectOwnership(QObject, QQmlEngine.ObjectOwnership)");

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

    {
         ::QObject* a0;
        PyObject *a0Wrapper;
         ::QQmlEngine::ObjectOwnership a1;

        if (sipParseArgs(&sipParseErr, sipArgs, "@J8E", &a0Wrapper, sipType_QObject, &a0, sipType_QQmlEngine_ObjectOwnership, &a1))
        {
#line 137 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlengine.sip"
        QQmlEngine::ObjectOwnership old = QQmlEngine::objectOwnership(a0);
        
        QQmlEngine::setObjectOwnership(a0, a1);
        
        if (old != a1 && !a0->parent())
        {
            if (old == QQmlEngine::CppOwnership)
                sipTransferTo(a0Wrapper, Py_None);
            else
                sipTransferBack(a0Wrapper);
        }
#line 16460 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_setObjectOwnership, doc_QQmlEngine_setObjectOwnership);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_objectOwnership, "objectOwnership(QObject) -> QQmlEngine.ObjectOwnership");

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

    {
         ::QObject* a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8", sipType_QObject, &a0))
        {
             ::QQmlEngine::ObjectOwnership sipRes;

            sipRes =  ::QQmlEngine::objectOwnership(a0);

            return sipConvertFromEnum(sipRes,sipType_QQmlEngine_ObjectOwnership);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_objectOwnership, doc_QQmlEngine_objectOwnership);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_event, "event(self, QEvent) -> bool");

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

    {
         ::QEvent* a0;
        sipQQmlEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QEvent, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtectVirt_event(sipSelfWasArg,a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_event, doc_QQmlEngine_event);

    return NULL;
}


PyDoc_STRVAR(doc_QQmlEngine_offlineStorageDatabaseFilePath, "offlineStorageDatabaseFilePath(self, str) -> str");

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

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QQmlEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QQmlEngine, &sipCpp, sipType_QString,&a0, &a0State))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->offlineStorageDatabaseFilePath(*a0));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlEngine, sipName_offlineStorageDatabaseFilePath, doc_QQmlEngine_offlineStorageDatabaseFilePath);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QQmlEngine(void *, const sipTypeDef *);}
static void *cast_QQmlEngine(void *sipCppV, const sipTypeDef *targetType)
{
     ::QQmlEngine *sipCpp = reinterpret_cast< ::QQmlEngine *>(sipCppV);

    if (targetType == sipType_QJSEngine)
        return static_cast< ::QJSEngine *>(sipCpp);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


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

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


extern "C" {static void dealloc_QQmlEngine(sipSimpleWrapper *);}
static void dealloc_QQmlEngine(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlEngine *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlEngine(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QQmlEngine(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QQmlEngine(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQQmlEngine *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 sipQQmlEngine(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QQmlEngine[] = {
    {SIP_MLNAME_CAST(sipName_addImageProvider), meth_QQmlEngine_addImageProvider, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_addImageProvider)},
    {SIP_MLNAME_CAST(sipName_addImportPath), meth_QQmlEngine_addImportPath, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_addImportPath)},
    {SIP_MLNAME_CAST(sipName_addNamedBundle), meth_QQmlEngine_addNamedBundle, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_addNamedBundle)},
    {SIP_MLNAME_CAST(sipName_addPluginPath), meth_QQmlEngine_addPluginPath, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_addPluginPath)},
    {SIP_MLNAME_CAST(sipName_baseUrl), meth_QQmlEngine_baseUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_baseUrl)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QQmlEngine_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_clearComponentCache), meth_QQmlEngine_clearComponentCache, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_clearComponentCache)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QQmlEngine_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_contextForObject), meth_QQmlEngine_contextForObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_contextForObject)},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QQmlEngine_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QQmlEngine_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_event), (PyCFunction)meth_QQmlEngine_event, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QQmlEngine_event)},
    {SIP_MLNAME_CAST(sipName_imageProvider), meth_QQmlEngine_imageProvider, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_imageProvider)},
    {SIP_MLNAME_CAST(sipName_importPathList), meth_QQmlEngine_importPathList, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_importPathList)},
    {SIP_MLNAME_CAST(sipName_importPlugin), meth_QQmlEngine_importPlugin, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_importPlugin)},
    {SIP_MLNAME_CAST(sipName_incubationController), meth_QQmlEngine_incubationController, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_incubationController)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QQmlEngine_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_networkAccessManager), meth_QQmlEngine_networkAccessManager, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_networkAccessManager)},
    {SIP_MLNAME_CAST(sipName_networkAccessManagerFactory), meth_QQmlEngine_networkAccessManagerFactory, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_networkAccessManagerFactory)},
    {SIP_MLNAME_CAST(sipName_objectOwnership), meth_QQmlEngine_objectOwnership, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_objectOwnership)},
    {SIP_MLNAME_CAST(sipName_offlineStorageDatabaseFilePath), meth_QQmlEngine_offlineStorageDatabaseFilePath, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_offlineStorageDatabaseFilePath)},
    {SIP_MLNAME_CAST(sipName_offlineStoragePath), meth_QQmlEngine_offlineStoragePath, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_offlineStoragePath)},
    {SIP_MLNAME_CAST(sipName_outputWarningsToStandardError), meth_QQmlEngine_outputWarningsToStandardError, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_outputWarningsToStandardError)},
    {SIP_MLNAME_CAST(sipName_pluginPathList), meth_QQmlEngine_pluginPathList, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_pluginPathList)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QQmlEngine_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_removeImageProvider), meth_QQmlEngine_removeImageProvider, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_removeImageProvider)},
    {SIP_MLNAME_CAST(sipName_rootContext), meth_QQmlEngine_rootContext, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_rootContext)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QQmlEngine_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QQmlEngine_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setBaseUrl), meth_QQmlEngine_setBaseUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_setBaseUrl)},
    {SIP_MLNAME_CAST(sipName_setContextForObject), meth_QQmlEngine_setContextForObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_setContextForObject)},
    {SIP_MLNAME_CAST(sipName_setImportPathList), meth_QQmlEngine_setImportPathList, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_setImportPathList)},
    {SIP_MLNAME_CAST(sipName_setIncubationController), meth_QQmlEngine_setIncubationController, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_setIncubationController)},
    {SIP_MLNAME_CAST(sipName_setNetworkAccessManagerFactory), meth_QQmlEngine_setNetworkAccessManagerFactory, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_setNetworkAccessManagerFactory)},
    {SIP_MLNAME_CAST(sipName_setObjectOwnership), meth_QQmlEngine_setObjectOwnership, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_setObjectOwnership)},
    {SIP_MLNAME_CAST(sipName_setOfflineStoragePath), meth_QQmlEngine_setOfflineStoragePath, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_setOfflineStoragePath)},
    {SIP_MLNAME_CAST(sipName_setOutputWarningsToStandardError), meth_QQmlEngine_setOutputWarningsToStandardError, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_setOutputWarningsToStandardError)},
    {SIP_MLNAME_CAST(sipName_setPluginPathList), meth_QQmlEngine_setPluginPathList, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_setPluginPathList)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QQmlEngine_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_trimComponentCache), meth_QQmlEngine_trimComponentCache, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlEngine_trimComponentCache)}
};

static sipEnumMemberDef enummembers_QQmlEngine[] = {
    {sipName_CppOwnership, static_cast<int>( ::QQmlEngine::CppOwnership), 17},
    {sipName_JavaScriptOwnership, static_cast<int>( ::QQmlEngine::JavaScriptOwnership), 17},
};

PyDoc_STRVAR(doc_QQmlEngine, "\1QQmlEngine(parent: QObject = None)");


/* Define this type's signals. */
static const pyqt5QtSignal signals_QQmlEngine[] = {
    {"exit(int)", "\1exit(self, int)", 0, 0},
    {"warnings(QList<QQmlError>)", "\1warnings(self, Iterable[QQmlError])", 0, 0},
    {"quit()", "\1quit(self)", 0, 0},
    {0, 0, 0, 0}
};


static pyqt5ClassPluginDef plugin_QQmlEngine = {
    & ::QQmlEngine::staticMetaObject,
    0,
    signals_QQmlEngine,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlEngine = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlEngine,
        {0},
        &plugin_QQmlEngine
    },
    {
        sipNameNr_QQmlEngine,
        {0, 0, 1},
        40, methods_QQmlEngine,
        2, enummembers_QQmlEngine,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlEngine,
    -1,
    -1,
    supers_QQmlEngine,
    0,
    init_type_QQmlEngine,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlEngine,
    0,
    0,
    0,
    release_QQmlEngine,
    cast_QQmlEngine,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qqmlabstracturlinterceptor.sip"
#include <qqmlabstracturlinterceptor.h>
#line 16755 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 96 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 16759 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQQmlAbstractUrlInterceptor : public  ::QQmlAbstractUrlInterceptor
{
public:
    sipQQmlAbstractUrlInterceptor();
    sipQQmlAbstractUrlInterceptor(const  ::QQmlAbstractUrlInterceptor&);
    virtual ~sipQQmlAbstractUrlInterceptor();

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
     ::QUrl intercept(const  ::QUrl&, ::QQmlAbstractUrlInterceptor::DataType);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[1];
};

sipQQmlAbstractUrlInterceptor::sipQQmlAbstractUrlInterceptor():  ::QQmlAbstractUrlInterceptor(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlAbstractUrlInterceptor::sipQQmlAbstractUrlInterceptor(const  ::QQmlAbstractUrlInterceptor& a0):  ::QQmlAbstractUrlInterceptor(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQQmlAbstractUrlInterceptor::~sipQQmlAbstractUrlInterceptor()
{
    sipInstanceDestroyed(sipPySelf);
}

 ::QUrl sipQQmlAbstractUrlInterceptor::intercept(const  ::QUrl& a0, ::QQmlAbstractUrlInterceptor::DataType a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,sipName_QQmlAbstractUrlInterceptor,sipName_intercept);

    if (!sipMeth)
        return  ::QUrl();

    extern  ::QUrl sipVH_QtQml_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QUrl&, ::QQmlAbstractUrlInterceptor::DataType);

    return sipVH_QtQml_6(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}


PyDoc_STRVAR(doc_QQmlAbstractUrlInterceptor_intercept, "intercept(self, QUrl, QQmlAbstractUrlInterceptor.DataType) -> QUrl");

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

    {
        const  ::QUrl* a0;
         ::QQmlAbstractUrlInterceptor::DataType a1;
         ::QQmlAbstractUrlInterceptor *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9E", &sipSelf, sipType_QQmlAbstractUrlInterceptor, &sipCpp, sipType_QUrl, &a0, sipType_QQmlAbstractUrlInterceptor_DataType, &a1))
        {
             ::QUrl*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QQmlAbstractUrlInterceptor, sipName_intercept);
                return NULL;
            }

            sipRes = new  ::QUrl(sipCpp->intercept(*a0,a1));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QQmlAbstractUrlInterceptor, sipName_intercept, doc_QQmlAbstractUrlInterceptor_intercept);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QQmlAbstractUrlInterceptor(void *, int);}
static void release_QQmlAbstractUrlInterceptor(void *sipCppV, int sipState)
{
    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQQmlAbstractUrlInterceptor *>(sipCppV);
    else
        delete reinterpret_cast< ::QQmlAbstractUrlInterceptor *>(sipCppV);
}


extern "C" {static void dealloc_QQmlAbstractUrlInterceptor(sipSimpleWrapper *);}
static void dealloc_QQmlAbstractUrlInterceptor(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQQmlAbstractUrlInterceptor *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QQmlAbstractUrlInterceptor(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


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

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new sipQQmlAbstractUrlInterceptor();

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QQmlAbstractUrlInterceptor* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QQmlAbstractUrlInterceptor, &a0))
        {
            sipCpp = new sipQQmlAbstractUrlInterceptor(*a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QQmlAbstractUrlInterceptor[] = {
    {SIP_MLNAME_CAST(sipName_intercept), meth_QQmlAbstractUrlInterceptor_intercept, METH_VARARGS, SIP_MLDOC_CAST(doc_QQmlAbstractUrlInterceptor_intercept)}
};

static sipEnumMemberDef enummembers_QQmlAbstractUrlInterceptor[] = {
    {sipName_JavaScriptFile, static_cast<int>( ::QQmlAbstractUrlInterceptor::JavaScriptFile), 10},
    {sipName_QmlFile, static_cast<int>( ::QQmlAbstractUrlInterceptor::QmlFile), 10},
    {sipName_QmldirFile, static_cast<int>( ::QQmlAbstractUrlInterceptor::QmldirFile), 10},
    {sipName_UrlString, static_cast<int>( ::QQmlAbstractUrlInterceptor::UrlString), 10},
};

PyDoc_STRVAR(doc_QQmlAbstractUrlInterceptor, "\1QQmlAbstractUrlInterceptor()\n"
    "QQmlAbstractUrlInterceptor(QQmlAbstractUrlInterceptor)");


static pyqt5ClassPluginDef plugin_QQmlAbstractUrlInterceptor = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QQmlAbstractUrlInterceptor = {
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QQmlAbstractUrlInterceptor,
        {0},
        &plugin_QQmlAbstractUrlInterceptor
    },
    {
        sipNameNr_QQmlAbstractUrlInterceptor,
        {0, 0, 1},
        1, methods_QQmlAbstractUrlInterceptor,
        4, enummembers_QQmlAbstractUrlInterceptor,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QQmlAbstractUrlInterceptor,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QQmlAbstractUrlInterceptor,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QQmlAbstractUrlInterceptor,
    0,
    0,
    0,
    release_QQmlAbstractUrlInterceptor,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsvalueiterator.sip"
#include <qjsvalueiterator.h>
#line 16986 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsvalue.sip"
#include <qjsvalue.h>
#line 16990 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 16993 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


PyDoc_STRVAR(doc_QJSValueIterator_hasNext, "hasNext(self) -> bool");

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

    {
        const  ::QJSValueIterator *sipCpp;

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

            sipRes = sipCpp->hasNext();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValueIterator, sipName_hasNext, doc_QJSValueIterator_hasNext);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValueIterator_next, "next(self) -> bool");

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

    {
         ::QJSValueIterator *sipCpp;

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

            sipRes = sipCpp->next();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValueIterator, sipName_next, doc_QJSValueIterator_next);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValueIterator_name, "name(self) -> str");

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

    {
        const  ::QJSValueIterator *sipCpp;

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

            sipRes = new  ::QString(sipCpp->name());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValueIterator, sipName_name, doc_QJSValueIterator_name);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValueIterator_value, "value(self) -> QJSValue");

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

    {
        const  ::QJSValueIterator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValueIterator, &sipCpp))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->value());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValueIterator, sipName_value, doc_QJSValueIterator_value);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QJSValueIterator(void *, int);}
static void release_QJSValueIterator(void *sipCppV, int)
{
    delete reinterpret_cast< ::QJSValueIterator *>(sipCppV);
}


extern "C" {static void dealloc_QJSValueIterator(sipSimpleWrapper *);}
static void dealloc_QJSValueIterator(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QJSValueIterator(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QJSValueIterator(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QJSValueIterator(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QJSValueIterator *sipCpp = 0;

    {
        const  ::QJSValue* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QJSValue, &a0, &a0State))
        {
            sipCpp = new  ::QJSValueIterator(*a0);
            sipReleaseType(const_cast< ::QJSValue *>(a0),sipType_QJSValue,a0State);

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QJSValueIterator[] = {
    {SIP_MLNAME_CAST(sipName_hasNext), meth_QJSValueIterator_hasNext, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValueIterator_hasNext)},
    {SIP_MLNAME_CAST(sipName_name), meth_QJSValueIterator_name, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValueIterator_name)},
    {SIP_MLNAME_CAST(sipName_next), meth_QJSValueIterator_next, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValueIterator_next)},
    {SIP_MLNAME_CAST(sipName_value), meth_QJSValueIterator_value, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValueIterator_value)}
};

PyDoc_STRVAR(doc_QJSValueIterator, "\1QJSValueIterator(Union[QJSValue, QJSValue.SpecialValue, bool, int, float, str])");


static pyqt5ClassPluginDef plugin_QJSValueIterator = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QJSValueIterator = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QJSValueIterator,
        {0},
        &plugin_QJSValueIterator
    },
    {
        sipNameNr_QJSValueIterator,
        {0, 0, 1},
        4, methods_QJSValueIterator,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QJSValueIterator,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QJSValueIterator,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QJSValueIterator,
    0,
    0,
    0,
    release_QJSValueIterator,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsvalue.sip"
#include <qjsvalue.h>
#line 17218 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 17222 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 17225 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 303 "sip/QtCore/qdatetime.sip"
#include <qdatetime.h>
#line 17228 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 17231 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 17234 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


PyDoc_STRVAR(doc_QJSValue_isBool, "isBool(self) -> bool");

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

    {
        const  ::QJSValue *sipCpp;

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

            sipRes = sipCpp->isBool();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isBool, doc_QJSValue_isBool);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isNumber, "isNumber(self) -> bool");

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

    {
        const  ::QJSValue *sipCpp;

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

            sipRes = sipCpp->isNumber();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isNumber, doc_QJSValue_isNumber);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isNull, "isNull(self) -> bool");

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

    {
        const  ::QJSValue *sipCpp;

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

            sipRes = sipCpp->isNull();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isNull, doc_QJSValue_isNull);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isString, "isString(self) -> bool");

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

    {
        const  ::QJSValue *sipCpp;

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

            sipRes = sipCpp->isString();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isString, doc_QJSValue_isString);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isUndefined, "isUndefined(self) -> bool");

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

    {
        const  ::QJSValue *sipCpp;

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

            sipRes = sipCpp->isUndefined();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isUndefined, doc_QJSValue_isUndefined);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isVariant, "isVariant(self) -> bool");

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

    {
        const  ::QJSValue *sipCpp;

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

            sipRes = sipCpp->isVariant();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isVariant, doc_QJSValue_isVariant);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isQObject, "isQObject(self) -> bool");

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

    {
        const  ::QJSValue *sipCpp;

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

            sipRes = sipCpp->isQObject();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isQObject, doc_QJSValue_isQObject);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isObject, "isObject(self) -> bool");

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

    {
        const  ::QJSValue *sipCpp;

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

            sipRes = sipCpp->isObject();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isObject, doc_QJSValue_isObject);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isDate, "isDate(self) -> bool");

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

    {
        const  ::QJSValue *sipCpp;

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

            sipRes = sipCpp->isDate();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isDate, doc_QJSValue_isDate);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isRegExp, "isRegExp(self) -> bool");

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

    {
        const  ::QJSValue *sipCpp;

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

            sipRes = sipCpp->isRegExp();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isRegExp, doc_QJSValue_isRegExp);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isArray, "isArray(self) -> bool");

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

    {
        const  ::QJSValue *sipCpp;

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

            sipRes = sipCpp->isArray();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isArray, doc_QJSValue_isArray);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isError, "isError(self) -> bool");

extern "C" {static PyObject *meth_QJSValue_isError(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_isError(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValue, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isError();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isError, doc_QJSValue_isError);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_toString, "toString(self) -> str");

extern "C" {static PyObject *meth_QJSValue_toString(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_toString(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValue, &sipCpp))
        {
             ::QString*sipRes;

            sipRes = new  ::QString(sipCpp->toString());

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_toString, doc_QJSValue_toString);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_toNumber, "toNumber(self) -> float");

extern "C" {static PyObject *meth_QJSValue_toNumber(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_toNumber(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValue, &sipCpp))
        {
            double sipRes;

            sipRes = sipCpp->toNumber();

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_toNumber, doc_QJSValue_toNumber);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_toInt, "toInt(self) -> int");

extern "C" {static PyObject *meth_QJSValue_toInt(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_toInt(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValue, &sipCpp))
        {
             ::qint32 sipRes;

            sipRes = sipCpp->toInt();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_toInt, doc_QJSValue_toInt);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_toUInt, "toUInt(self) -> int");

extern "C" {static PyObject *meth_QJSValue_toUInt(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_toUInt(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValue, &sipCpp))
        {
             ::quint32 sipRes;

            sipRes = sipCpp->toUInt();

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_toUInt, doc_QJSValue_toUInt);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_toBool, "toBool(self) -> bool");

extern "C" {static PyObject *meth_QJSValue_toBool(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_toBool(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValue, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->toBool();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_toBool, doc_QJSValue_toBool);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_toVariant, "toVariant(self) -> Any");

extern "C" {static PyObject *meth_QJSValue_toVariant(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_toVariant(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValue, &sipCpp))
        {
             ::QVariant*sipRes;

            sipRes = new  ::QVariant(sipCpp->toVariant());

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_toVariant, doc_QJSValue_toVariant);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_toQObject, "toQObject(self) -> QObject");

extern "C" {static PyObject *meth_QJSValue_toQObject(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_toQObject(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValue, &sipCpp))
        {
             ::QObject*sipRes;

            sipRes = sipCpp->toQObject();

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_toQObject, doc_QJSValue_toQObject);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_toDateTime, "toDateTime(self) -> QDateTime");

extern "C" {static PyObject *meth_QJSValue_toDateTime(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_toDateTime(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValue, &sipCpp))
        {
             ::QDateTime*sipRes;

            sipRes = new  ::QDateTime(sipCpp->toDateTime());

            return sipConvertFromNewType(sipRes,sipType_QDateTime,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_toDateTime, doc_QJSValue_toDateTime);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_equals, "equals(self, Union[QJSValue, QJSValue.SpecialValue, bool, int, float, str]) -> bool");

extern "C" {static PyObject *meth_QJSValue_equals(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_equals(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue* a0;
        int a0State = 0;
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QJSValue, &sipCpp, sipType_QJSValue, &a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->equals(*a0);
            sipReleaseType(const_cast< ::QJSValue *>(a0),sipType_QJSValue,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_equals, doc_QJSValue_equals);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_strictlyEquals, "strictlyEquals(self, Union[QJSValue, QJSValue.SpecialValue, bool, int, float, str]) -> bool");

extern "C" {static PyObject *meth_QJSValue_strictlyEquals(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_strictlyEquals(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue* a0;
        int a0State = 0;
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QJSValue, &sipCpp, sipType_QJSValue, &a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->strictlyEquals(*a0);
            sipReleaseType(const_cast< ::QJSValue *>(a0),sipType_QJSValue,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_strictlyEquals, doc_QJSValue_strictlyEquals);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_prototype, "prototype(self) -> QJSValue");

extern "C" {static PyObject *meth_QJSValue_prototype(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_prototype(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValue, &sipCpp))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->prototype());

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_prototype, doc_QJSValue_prototype);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_setPrototype, "setPrototype(self, Union[QJSValue, QJSValue.SpecialValue, bool, int, float, str])");

extern "C" {static PyObject *meth_QJSValue_setPrototype(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_setPrototype(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue* a0;
        int a0State = 0;
         ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QJSValue, &sipCpp, sipType_QJSValue, &a0, &a0State))
        {
            sipCpp->setPrototype(*a0);
            sipReleaseType(const_cast< ::QJSValue *>(a0),sipType_QJSValue,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_setPrototype, doc_QJSValue_setPrototype);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_property, "property(self, str) -> QJSValue\n"
    "property(self, int) -> QJSValue");

extern "C" {static PyObject *meth_QJSValue_property(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_property(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QJSValue, &sipCpp, sipType_QString,&a0, &a0State))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->property(*a0));
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    {
         ::quint32 a0;
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QJSValue, &sipCpp, &a0))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->property(a0));

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_property, doc_QJSValue_property);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_setProperty, "setProperty(self, str, Union[QJSValue, QJSValue.SpecialValue, bool, int, float, str])\n"
    "setProperty(self, int, Union[QJSValue, QJSValue.SpecialValue, bool, int, float, str])");

extern "C" {static PyObject *meth_QJSValue_setProperty(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_setProperty(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QJSValue* a1;
        int a1State = 0;
         ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_QJSValue, &sipCpp, sipType_QString,&a0, &a0State, sipType_QJSValue, &a1, &a1State))
        {
            sipCpp->setProperty(*a0,*a1);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QJSValue *>(a1),sipType_QJSValue,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::quint32 a0;
        const  ::QJSValue* a1;
        int a1State = 0;
         ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuJ1", &sipSelf, sipType_QJSValue, &sipCpp, &a0, sipType_QJSValue, &a1, &a1State))
        {
            sipCpp->setProperty(a0,*a1);
            sipReleaseType(const_cast< ::QJSValue *>(a1),sipType_QJSValue,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_setProperty, doc_QJSValue_setProperty);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_hasProperty, "hasProperty(self, str) -> bool");

extern "C" {static PyObject *meth_QJSValue_hasProperty(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_hasProperty(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QJSValue, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->hasProperty(*a0);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_hasProperty, doc_QJSValue_hasProperty);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_hasOwnProperty, "hasOwnProperty(self, str) -> bool");

extern "C" {static PyObject *meth_QJSValue_hasOwnProperty(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_hasOwnProperty(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QJSValue, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->hasOwnProperty(*a0);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_hasOwnProperty, doc_QJSValue_hasOwnProperty);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_deleteProperty, "deleteProperty(self, str) -> bool");

extern "C" {static PyObject *meth_QJSValue_deleteProperty(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_deleteProperty(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QJSValue, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->deleteProperty(*a0);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_deleteProperty, doc_QJSValue_deleteProperty);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_isCallable, "isCallable(self) -> bool");

extern "C" {static PyObject *meth_QJSValue_isCallable(PyObject *, PyObject *);}
static PyObject *meth_QJSValue_isCallable(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSValue, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isCallable();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_isCallable, doc_QJSValue_isCallable);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_call, "call(self, args: object = QJSValueList()) -> QJSValue");

extern "C" {static PyObject *meth_QJSValue_call(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSValue_call(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValueList& a0def = QJSValueList();
        const  ::QJSValueList* a0 = &a0def;
        int a0State = 0;
         ::QJSValue *sipCpp;

        static const char *sipKwdList[] = {
            sipName_args,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J1", &sipSelf, sipType_QJSValue, &sipCpp, sipType_QList_0100QJSValue,&a0, &a0State))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->call(*a0));
            sipReleaseType(const_cast< ::QJSValueList *>(a0),sipType_QList_0100QJSValue,a0State);

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_call, doc_QJSValue_call);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_callWithInstance, "callWithInstance(self, Union[QJSValue, QJSValue.SpecialValue, bool, int, float, str], args: object = QJSValueList()) -> QJSValue");

extern "C" {static PyObject *meth_QJSValue_callWithInstance(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSValue_callWithInstance(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue* a0;
        int a0State = 0;
        const  ::QJSValueList& a1def = QJSValueList();
        const  ::QJSValueList* a1 = &a1def;
        int a1State = 0;
         ::QJSValue *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_args,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|J1", &sipSelf, sipType_QJSValue, &sipCpp, sipType_QJSValue, &a0, &a0State, sipType_QList_0100QJSValue,&a1, &a1State))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->callWithInstance(*a0,*a1));
            sipReleaseType(const_cast< ::QJSValue *>(a0),sipType_QJSValue,a0State);
            sipReleaseType(const_cast< ::QJSValueList *>(a1),sipType_QList_0100QJSValue,a1State);

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_callWithInstance, doc_QJSValue_callWithInstance);

    return NULL;
}


PyDoc_STRVAR(doc_QJSValue_callAsConstructor, "callAsConstructor(self, args: object = QJSValueList()) -> QJSValue");

extern "C" {static PyObject *meth_QJSValue_callAsConstructor(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSValue_callAsConstructor(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValueList& a0def = QJSValueList();
        const  ::QJSValueList* a0 = &a0def;
        int a0State = 0;
         ::QJSValue *sipCpp;

        static const char *sipKwdList[] = {
            sipName_args,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J1", &sipSelf, sipType_QJSValue, &sipCpp, sipType_QList_0100QJSValue,&a0, &a0State))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->callAsConstructor(*a0));
            sipReleaseType(const_cast< ::QJSValueList *>(a0),sipType_QList_0100QJSValue,a0State);

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSValue, sipName_callAsConstructor, doc_QJSValue_callAsConstructor);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QJSValue(void *, int);}
static void release_QJSValue(void *sipCppV, int)
{
    delete reinterpret_cast< ::QJSValue *>(sipCppV);
}


extern "C" {static void assign_QJSValue(void *, SIP_SSIZE_T, const void *);}
static void assign_QJSValue(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast< ::QJSValue *>(sipDst)[sipDstIdx] = *reinterpret_cast<const  ::QJSValue *>(sipSrc);
}


extern "C" {static void *array_QJSValue(SIP_SSIZE_T);}
static void *array_QJSValue(SIP_SSIZE_T sipNrElem)
{
    return new  ::QJSValue[sipNrElem];
}


extern "C" {static void *copy_QJSValue(const void *, SIP_SSIZE_T);}
static void *copy_QJSValue(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QJSValue(reinterpret_cast<const  ::QJSValue *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QJSValue(sipSimpleWrapper *);}
static void dealloc_QJSValue(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QJSValue(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QJSValue(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QJSValue(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QJSValue *sipCpp = 0;

    {
         ::QJSValue::SpecialValue a0 = QJSValue::UndefinedValue;

        static const char *sipKwdList[] = {
            sipName_value,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|XE", sipType_QJSValue_SpecialValue, &a0))
        {
            sipCpp = new  ::QJSValue(a0);

            return sipCpp;
        }
    }

    {
        const  ::QJSValue* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QJSValue, &a0, &a0State))
        {
            sipCpp = new  ::QJSValue(*a0);
            sipReleaseType(const_cast< ::QJSValue *>(a0),sipType_QJSValue,a0State);

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QJSValue(PyObject *, void **, int *, PyObject *);}
static int convertTo_QJSValue(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QJSValue **sipCppPtr = reinterpret_cast< ::QJSValue **>(sipCppPtrV);

#line 32 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsvalue.sip"
if (!sipIsErr)
    return qpyqml_canConvertTo_QJSValue(sipPy);

return qpyqml_convertTo_QJSValue(sipPy, sipTransferObj, sipCppPtr, sipIsErr);
#line 18334 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
}


static PyMethodDef methods_QJSValue[] = {
    {SIP_MLNAME_CAST(sipName_call), (PyCFunction)meth_QJSValue_call, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QJSValue_call)},
    {SIP_MLNAME_CAST(sipName_callAsConstructor), (PyCFunction)meth_QJSValue_callAsConstructor, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QJSValue_callAsConstructor)},
    {SIP_MLNAME_CAST(sipName_callWithInstance), (PyCFunction)meth_QJSValue_callWithInstance, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QJSValue_callWithInstance)},
    {SIP_MLNAME_CAST(sipName_deleteProperty), meth_QJSValue_deleteProperty, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_deleteProperty)},
    {SIP_MLNAME_CAST(sipName_equals), meth_QJSValue_equals, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_equals)},
    {SIP_MLNAME_CAST(sipName_hasOwnProperty), meth_QJSValue_hasOwnProperty, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_hasOwnProperty)},
    {SIP_MLNAME_CAST(sipName_hasProperty), meth_QJSValue_hasProperty, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_hasProperty)},
    {SIP_MLNAME_CAST(sipName_isArray), meth_QJSValue_isArray, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isArray)},
    {SIP_MLNAME_CAST(sipName_isBool), meth_QJSValue_isBool, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isBool)},
    {SIP_MLNAME_CAST(sipName_isCallable), meth_QJSValue_isCallable, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isCallable)},
    {SIP_MLNAME_CAST(sipName_isDate), meth_QJSValue_isDate, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isDate)},
    {SIP_MLNAME_CAST(sipName_isError), meth_QJSValue_isError, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isError)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QJSValue_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isNull)},
    {SIP_MLNAME_CAST(sipName_isNumber), meth_QJSValue_isNumber, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isNumber)},
    {SIP_MLNAME_CAST(sipName_isObject), meth_QJSValue_isObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isObject)},
    {SIP_MLNAME_CAST(sipName_isQObject), meth_QJSValue_isQObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isQObject)},
    {SIP_MLNAME_CAST(sipName_isRegExp), meth_QJSValue_isRegExp, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isRegExp)},
    {SIP_MLNAME_CAST(sipName_isString), meth_QJSValue_isString, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isString)},
    {SIP_MLNAME_CAST(sipName_isUndefined), meth_QJSValue_isUndefined, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isUndefined)},
    {SIP_MLNAME_CAST(sipName_isVariant), meth_QJSValue_isVariant, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_isVariant)},
    {SIP_MLNAME_CAST(sipName_property), meth_QJSValue_property, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_property)},
    {SIP_MLNAME_CAST(sipName_prototype), meth_QJSValue_prototype, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_prototype)},
    {SIP_MLNAME_CAST(sipName_setProperty), meth_QJSValue_setProperty, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_setProperty)},
    {SIP_MLNAME_CAST(sipName_setPrototype), meth_QJSValue_setPrototype, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_setPrototype)},
    {SIP_MLNAME_CAST(sipName_strictlyEquals), meth_QJSValue_strictlyEquals, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_strictlyEquals)},
    {SIP_MLNAME_CAST(sipName_toBool), meth_QJSValue_toBool, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_toBool)},
    {SIP_MLNAME_CAST(sipName_toDateTime), meth_QJSValue_toDateTime, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_toDateTime)},
    {SIP_MLNAME_CAST(sipName_toInt), meth_QJSValue_toInt, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_toInt)},
    {SIP_MLNAME_CAST(sipName_toNumber), meth_QJSValue_toNumber, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_toNumber)},
    {SIP_MLNAME_CAST(sipName_toQObject), meth_QJSValue_toQObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_toQObject)},
    {SIP_MLNAME_CAST(sipName_toString), meth_QJSValue_toString, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_toString)},
    {SIP_MLNAME_CAST(sipName_toUInt), meth_QJSValue_toUInt, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_toUInt)},
    {SIP_MLNAME_CAST(sipName_toVariant), meth_QJSValue_toVariant, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSValue_toVariant)}
};

static sipEnumMemberDef enummembers_QJSValue[] = {
    {sipName_NullValue, static_cast<int>( ::QJSValue::NullValue), 4},
    {sipName_UndefinedValue, static_cast<int>( ::QJSValue::UndefinedValue), 4},
};

PyDoc_STRVAR(doc_QJSValue, "\1QJSValue(value: QJSValue.SpecialValue = QJSValue.UndefinedValue)\n"
    "QJSValue(Union[QJSValue, QJSValue.SpecialValue, bool, int, float, str])");


static pyqt5ClassPluginDef plugin_QJSValue = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QJSValue = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QJSValue,
        {0},
        &plugin_QJSValue
    },
    {
        sipNameNr_QJSValue,
        {0, 0, 1},
        33, methods_QJSValue,
        2, enummembers_QJSValue,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QJSValue,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QJSValue,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QJSValue,
    assign_QJSValue,
    array_QJSValue,
    copy_QJSValue,
    release_QJSValue,
    0,
    convertTo_QJSValue,
    0,
    0,
    0,
    0,
    0
};

#line 30 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsengine.sip"
#include <qjsengine.h>
#line 18443 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 30 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsengine.sip"
#include <qjsengine.h>
#line 18447 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


extern "C" {static long slot_QJSEngine_Extensions___hash__(PyObject *);}
static long slot_QJSEngine_Extensions___hash__(PyObject *sipSelf)
{
     ::QJSEngine::Extensions *sipCpp = reinterpret_cast< ::QJSEngine::Extensions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QJSEngine_Extensions));

    if (!sipCpp)
        return 0;


    {
        {
            long sipRes = 0;

#line 116 "sip/QtCore/qglobal.sip"
        sipRes = sipCpp->operator QJSEngine::Extensions::Int();
#line 18465 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static int slot_QJSEngine_Extensions___bool__(PyObject *);}
static int slot_QJSEngine_Extensions___bool__(PyObject *sipSelf)
{
     ::QJSEngine::Extensions *sipCpp = reinterpret_cast< ::QJSEngine::Extensions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QJSEngine_Extensions));

    if (!sipCpp)
        return -1;


    {
        {
            int sipRes = 0;

#line 111 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QJSEngine::Extensions::Int() != 0);
#line 18490 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QJSEngine_Extensions___ne__(PyObject *,PyObject *);}
static PyObject *slot_QJSEngine_Extensions___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QJSEngine::Extensions *sipCpp = reinterpret_cast< ::QJSEngine::Extensions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QJSEngine_Extensions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QJSEngine::Extensions* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QJSEngine_Extensions, &a0, &a0State))
        {
            bool sipRes = 0;

#line 106 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QJSEngine::Extensions::Int() != a0->operator QJSEngine::Extensions::Int());
#line 18520 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
            sipReleaseType(const_cast< ::QJSEngine::Extensions *>(a0),sipType_QJSEngine_Extensions,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, ne_slot, sipType_QJSEngine_Extensions, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QJSEngine_Extensions___eq__(PyObject *,PyObject *);}
static PyObject *slot_QJSEngine_Extensions___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QJSEngine::Extensions *sipCpp = reinterpret_cast< ::QJSEngine::Extensions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QJSEngine_Extensions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QJSEngine::Extensions* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QJSEngine_Extensions, &a0, &a0State))
        {
            bool sipRes = 0;

#line 101 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QJSEngine::Extensions::Int() == a0->operator QJSEngine::Extensions::Int());
#line 18556 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
            sipReleaseType(const_cast< ::QJSEngine::Extensions *>(a0),sipType_QJSEngine_Extensions,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, eq_slot, sipType_QJSEngine_Extensions, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QJSEngine_Extensions___ixor__(PyObject *,PyObject *);}
static PyObject *slot_QJSEngine_Extensions___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QJSEngine_Extensions)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QJSEngine::Extensions *sipCpp = reinterpret_cast< ::QJSEngine::Extensions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QJSEngine_Extensions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 95 "sip/QtCore/qglobal.sip"
        *sipCpp = QJSEngine::Extensions(*sipCpp ^ a0);
#line 18595 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QJSEngine_Extensions___xor__(PyObject *,PyObject *);}
static PyObject *slot_QJSEngine_Extensions___xor__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QJSEngine::Extensions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QJSEngine_Extensions, &a0, &a0State, &a1))
        {
             ::QJSEngine::Extensions*sipRes;

            sipRes = new  ::QJSEngine::Extensions((*a0 ^ a1));
            sipReleaseType(a0,sipType_QJSEngine_Extensions,a0State);

            return sipConvertFromNewType(sipRes,sipType_QJSEngine_Extensions,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, xor_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QJSEngine_Extensions___ior__(PyObject *,PyObject *);}
static PyObject *slot_QJSEngine_Extensions___ior__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QJSEngine_Extensions)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QJSEngine::Extensions *sipCpp = reinterpret_cast< ::QJSEngine::Extensions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QJSEngine_Extensions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 89 "sip/QtCore/qglobal.sip"
        *sipCpp = QJSEngine::Extensions(*sipCpp | a0);
#line 18667 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QJSEngine_Extensions___or__(PyObject *,PyObject *);}
static PyObject *slot_QJSEngine_Extensions___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QJSEngine::Extensions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QJSEngine_Extensions, &a0, &a0State, &a1))
        {
             ::QJSEngine::Extensions*sipRes;

            sipRes = new  ::QJSEngine::Extensions((*a0 | a1));
            sipReleaseType(a0,sipType_QJSEngine_Extensions,a0State);

            return sipConvertFromNewType(sipRes,sipType_QJSEngine_Extensions,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, or_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QJSEngine_Extensions___iand__(PyObject *,PyObject *);}
static PyObject *slot_QJSEngine_Extensions___iand__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QJSEngine_Extensions)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QJSEngine::Extensions *sipCpp = reinterpret_cast< ::QJSEngine::Extensions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QJSEngine_Extensions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            sipCpp-> ::QJSEngine::Extensions::operator&=(a0);

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QJSEngine_Extensions___and__(PyObject *,PyObject *);}
static PyObject *slot_QJSEngine_Extensions___and__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QJSEngine::Extensions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QJSEngine_Extensions, &a0, &a0State, &a1))
        {
             ::QJSEngine::Extensions*sipRes;

            sipRes = new  ::QJSEngine::Extensions((*a0 & a1));
            sipReleaseType(a0,sipType_QJSEngine_Extensions,a0State);

            return sipConvertFromNewType(sipRes,sipType_QJSEngine_Extensions,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtQml, and_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QJSEngine_Extensions___invert__(PyObject *);}
static PyObject *slot_QJSEngine_Extensions___invert__(PyObject *sipSelf)
{
     ::QJSEngine::Extensions *sipCpp = reinterpret_cast< ::QJSEngine::Extensions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QJSEngine_Extensions));

    if (!sipCpp)
        return 0;


    {
        {
             ::QJSEngine::Extensions*sipRes;

            sipRes = new  ::QJSEngine::Extensions(~(*sipCpp));

            return sipConvertFromNewType(sipRes,sipType_QJSEngine_Extensions,NULL);
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QJSEngine_Extensions___int__(PyObject *);}
static PyObject *slot_QJSEngine_Extensions___int__(PyObject *sipSelf)
{
     ::QJSEngine::Extensions *sipCpp = reinterpret_cast< ::QJSEngine::Extensions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QJSEngine_Extensions));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes;

            sipRes = *sipCpp;

            return SIPLong_FromLong(sipRes);
        }
    }

    return 0;
}


/* Call the instance's destructor. */
extern "C" {static void release_QJSEngine_Extensions(void *, int);}
static void release_QJSEngine_Extensions(void *sipCppV, int)
{
    delete reinterpret_cast< ::QJSEngine::Extensions *>(sipCppV);
}


extern "C" {static void assign_QJSEngine_Extensions(void *, SIP_SSIZE_T, const void *);}
static void assign_QJSEngine_Extensions(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast< ::QJSEngine::Extensions *>(sipDst)[sipDstIdx] = *reinterpret_cast<const  ::QJSEngine::Extensions *>(sipSrc);
}


extern "C" {static void *array_QJSEngine_Extensions(SIP_SSIZE_T);}
static void *array_QJSEngine_Extensions(SIP_SSIZE_T sipNrElem)
{
    return new  ::QJSEngine::Extensions[sipNrElem];
}


extern "C" {static void *copy_QJSEngine_Extensions(const void *, SIP_SSIZE_T);}
static void *copy_QJSEngine_Extensions(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QJSEngine::Extensions(reinterpret_cast<const  ::QJSEngine::Extensions *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QJSEngine_Extensions(sipSimpleWrapper *);}
static void dealloc_QJSEngine_Extensions(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QJSEngine_Extensions(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QJSEngine_Extensions(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QJSEngine_Extensions(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QJSEngine::Extensions *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new  ::QJSEngine::Extensions();

            return sipCpp;
        }
    }

    {
        int a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "i", &a0))
        {
            sipCpp = new  ::QJSEngine::Extensions(a0);

            return sipCpp;
        }
    }

    {
        const  ::QJSEngine::Extensions* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QJSEngine_Extensions, &a0, &a0State))
        {
            sipCpp = new  ::QJSEngine::Extensions(*a0);
            sipReleaseType(const_cast< ::QJSEngine::Extensions *>(a0),sipType_QJSEngine_Extensions,a0State);

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QJSEngine_Extensions(PyObject *, void **, int *, PyObject *);}
static int convertTo_QJSEngine_Extensions(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QJSEngine::Extensions **sipCppPtr = reinterpret_cast< ::QJSEngine::Extensions **>(sipCppPtrV);

#line 121 "sip/QtCore/qglobal.sip"
// Allow an instance of the base enum whenever a QJSEngine::Extensions is expected.

if (sipIsErr == NULL)
    return (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QJSEngine_Extension)) ||
            sipCanConvertToType(sipPy, sipType_QJSEngine_Extensions, SIP_NO_CONVERTORS));

if (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QJSEngine_Extension)))
{
    *sipCppPtr = new QJSEngine::Extensions(int(SIPLong_AsLong(sipPy)));

    return sipGetState(sipTransferObj);
}

*sipCppPtr = reinterpret_cast<QJSEngine::Extensions *>(sipConvertToType(sipPy, sipType_QJSEngine_Extensions, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr));

return 0;
#line 18935 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QJSEngine_Extensions[] = {
    {(void *)slot_QJSEngine_Extensions___hash__, hash_slot},
    {(void *)slot_QJSEngine_Extensions___bool__, bool_slot},
    {(void *)slot_QJSEngine_Extensions___ne__, ne_slot},
    {(void *)slot_QJSEngine_Extensions___eq__, eq_slot},
    {(void *)slot_QJSEngine_Extensions___ixor__, ixor_slot},
    {(void *)slot_QJSEngine_Extensions___xor__, xor_slot},
    {(void *)slot_QJSEngine_Extensions___ior__, ior_slot},
    {(void *)slot_QJSEngine_Extensions___or__, or_slot},
    {(void *)slot_QJSEngine_Extensions___iand__, iand_slot},
    {(void *)slot_QJSEngine_Extensions___and__, and_slot},
    {(void *)slot_QJSEngine_Extensions___invert__, invert_slot},
    {(void *)slot_QJSEngine_Extensions___int__, int_slot},
    {0, (sipPySlotType)0}
};

PyDoc_STRVAR(doc_QJSEngine_Extensions, "\1QJSEngine.Extensions()\n"
    "QJSEngine.Extensions(Union[QJSEngine.Extensions, QJSEngine.Extension])\n"
    "QJSEngine.Extensions(QJSEngine.Extensions)");


static pyqt5ClassPluginDef plugin_QJSEngine_Extensions = {
    0,
    1,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QJSEngine_Extensions = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QJSEngine__Extensions,
        {0},
        &plugin_QJSEngine_Extensions
    },
    {
        sipNameNr_Extensions,
        {0, 255, 0},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QJSEngine_Extensions,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QJSEngine_Extensions,
    init_type_QJSEngine_Extensions,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QJSEngine_Extensions,
    assign_QJSEngine_Extensions,
    array_QJSEngine_Extensions,
    copy_QJSEngine_Extensions,
    release_QJSEngine_Extensions,
    0,
    convertTo_QJSEngine_Extensions,
    0,
    0,
    0,
    0,
    0
};

#line 30 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsengine.sip"
#include <qjsengine.h>
#line 19021 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 19025 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsvalue.sip"
#include <qjsvalue.h>
#line 19028 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 19031 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/sip/QtQml/qjsengine.sip"
#include <qjsengine.h>
#line 19034 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 19037 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 19040 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 19043 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 19046 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 19049 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 19052 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 19055 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 19058 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 19061 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 19064 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 19067 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 19070 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 19073 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 19076 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"


class sipQJSEngine : public  ::QJSEngine
{
public:
    sipQJSEngine();
    sipQJSEngine( ::QObject*);
    virtual ~sipQJSEngine();

    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:
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const  ::QMetaMethod&);
    void disconnectNotify(const  ::QMetaMethod&);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQJSEngine(const sipQJSEngine &);
    sipQJSEngine &operator = (const sipQJSEngine &);

    char sipPyMethods[7];
};

sipQJSEngine::sipQJSEngine():  ::QJSEngine(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQJSEngine::sipQJSEngine( ::QObject*a0):  ::QJSEngine(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQJSEngine::~sipQJSEngine()
{
    sipInstanceDestroyed(sipPySelf);
}

const QMetaObject *sipQJSEngine::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtQml_qt_metaobject(sipPySelf,sipType_QJSEngine);

    return  ::QJSEngine::metaObject();
}

int sipQJSEngine::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id =  ::QJSEngine::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtQml_qt_metacall(sipPySelf,sipType_QJSEngine,_c,_id,_a);

    return _id;
}

void *sipQJSEngine::qt_metacast(const char *_clname)
{
    void *sipCpp;

    return (sip_QtQml_qt_metacast(sipPySelf, sipType_QJSEngine, _clname, &sipCpp) ? sipCpp :  ::QJSEngine::qt_metacast(_clname));
}

bool sipQJSEngine::event( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return  ::QJSEngine::event(a0);

    extern bool sipVH_QtQml_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtQml_5(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

bool sipQJSEngine::eventFilter( ::QObject*a0, ::QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return  ::QJSEngine::eventFilter(a0,a1);

    extern bool sipVH_QtQml_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtQml_4(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

void sipQJSEngine::timerEvent( ::QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
         ::QJSEngine::timerEvent(a0);
        return;
    }

    extern void sipVH_QtQml_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtQml_3(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

void sipQJSEngine::childEvent( ::QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
         ::QJSEngine::childEvent(a0);
        return;
    }

    extern void sipVH_QtQml_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtQml_2(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

void sipQJSEngine::customEvent( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
         ::QJSEngine::customEvent(a0);
        return;
    }

    extern void sipVH_QtQml_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtQml_1(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

void sipQJSEngine::connectNotify(const  ::QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
         ::QJSEngine::connectNotify(a0);
        return;
    }

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

void sipQJSEngine::disconnectNotify(const  ::QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
         ::QJSEngine::disconnectNotify(a0);
        return;
    }

    extern void sipVH_QtQml_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtQml_0(sipGILState, sipImportedVirtErrorHandlers_QtQml_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

 ::QObject* sipQJSEngine::sipProtect_sender() const
{
    return  ::QObject::sender();
}

int sipQJSEngine::sipProtect_receivers(const char*a0) const
{
    return  ::QObject::receivers(a0);
}

void sipQJSEngine::sipProtectVirt_timerEvent(bool sipSelfWasArg, ::QTimerEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQJSEngine::sipProtectVirt_childEvent(bool sipSelfWasArg, ::QChildEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::childEvent(a0) : childEvent(a0));
}

void sipQJSEngine::sipProtectVirt_customEvent(bool sipSelfWasArg, ::QEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::customEvent(a0) : customEvent(a0));
}

void sipQJSEngine::sipProtectVirt_connectNotify(bool sipSelfWasArg,const  ::QMetaMethod& a0)
{
    (sipSelfWasArg ?  ::QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQJSEngine::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const  ::QMetaMethod& a0)
{
    (sipSelfWasArg ?  ::QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQJSEngine::sipProtect_senderSignalIndex() const
{
    return  ::QObject::senderSignalIndex();
}

bool sipQJSEngine::sipProtect_isSignalConnected(const  ::QMetaMethod& a0) const
{
    return  ::QObject::isSignalConnected(a0);
}


PyDoc_STRVAR(doc_QJSEngine_sender, "sender(self) -> QObject");

extern "C" {static PyObject *meth_QJSEngine_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQJSEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QJSEngine, &sipCpp))
        {
             ::QObject*sipRes = 0;

#line 560 "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");
                Q_ASSERT(qtcore_qobject_sender);
            }
        
            sipRes = qtcore_qobject_sender();
        }
#line 19376 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSEngine, sipName_sender, doc_QJSEngine_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_receivers, "receivers(self, PYQT_SIGNAL) -> int");

extern "C" {static PyObject *meth_QJSEngine_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        const sipQJSEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QJSEngine, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 591 "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");
            Q_ASSERT(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 19436 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-2.i686/build/py2/QtQml/sipQtQmlpart0.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_QJSEngine, sipName_receivers, doc_QJSEngine_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_timerEvent, "timerEvent(self, QTimerEvent)");

extern "C" {static PyObject *meth_QJSEngine_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QTimerEvent* a0;
        sipQJSEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QJSEngine, &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_QJSEngine, sipName_timerEvent, doc_QJSEngine_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_childEvent, "childEvent(self, QChildEvent)");

extern "C" {static PyObject *meth_QJSEngine_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QChildEvent* a0;
        sipQJSEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QJSEngine, &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_QJSEngine, sipName_childEvent, doc_QJSEngine_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_customEvent, "customEvent(self, QEvent)");

extern "C" {static PyObject *meth_QJSEngine_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QEvent* a0;
        sipQJSEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QJSEngine, &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_QJSEngine, sipName_customEvent, doc_QJSEngine_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_connectNotify, "connectNotify(self, QMetaMethod)");

extern "C" {static PyObject *meth_QJSEngine_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QMetaMethod* a0;
        sipQJSEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QJSEngine, &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_QJSEngine, sipName_connectNotify, doc_QJSEngine_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_disconnectNotify, "disconnectNotify(self, QMetaMethod)");

extern "C" {static PyObject *meth_QJSEngine_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QMetaMethod* a0;
        sipQJSEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QJSEngine, &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_QJSEngine, sipName_disconnectNotify, doc_QJSEngine_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_senderSignalIndex, "senderSignalIndex(self) -> int");

extern "C" {static PyObject *meth_QJSEngine_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQJSEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QJSEngine, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSEngine, sipName_senderSignalIndex, doc_QJSEngine_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_isSignalConnected, "isSignalConnected(self, QMetaMethod) -> bool");

extern "C" {static PyObject *meth_QJSEngine_isSignalConnected(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_isSignalConnected(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QMetaMethod* a0;
        const sipQJSEngine *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QJSEngine, &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_QJSEngine, sipName_isSignalConnected, doc_QJSEngine_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_globalObject, "globalObject(self) -> QJSValue");

extern "C" {static PyObject *meth_QJSEngine_globalObject(PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_globalObject(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSEngine, &sipCpp))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->globalObject());

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSEngine, sipName_globalObject, doc_QJSEngine_globalObject);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_evaluate, "evaluate(self, str, fileName: str = '', lineNumber: int = 1) -> QJSValue");

extern "C" {static PyObject *meth_QJSEngine_evaluate(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_evaluate(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QString& a1def = QString();
        const  ::QString* a1 = &a1def;
        int a1State = 0;
        int a2 = 1;
         ::QJSEngine *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_fileName,
            sipName_lineNumber,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|J1i", &sipSelf, sipType_QJSEngine, &sipCpp, sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State, &a2))
        {
             ::QJSValue*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QJSValue(sipCpp->evaluate(*a0,*a1,a2));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSEngine, sipName_evaluate, doc_QJSEngine_evaluate);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_newObject, "newObject(self) -> QJSValue");

extern "C" {static PyObject *meth_QJSEngine_newObject(PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_newObject(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QJSEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSEngine, &sipCpp))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->newObject());

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSEngine, sipName_newObject, doc_QJSEngine_newObject);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_newArray, "newArray(self, length: int = 0) -> QJSValue");

extern "C" {static PyObject *meth_QJSEngine_newArray(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_newArray(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
         ::uint a0 = 0;
         ::QJSEngine *sipCpp;

        static const char *sipKwdList[] = {
            sipName_length,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|u", &sipSelf, sipType_QJSEngine, &sipCpp, &a0))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->newArray(a0));

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSEngine, sipName_newArray, doc_QJSEngine_newArray);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_newQObject, "newQObject(self, QObject) -> QJSValue");

extern "C" {static PyObject *meth_QJSEngine_newQObject(PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_newQObject(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QObject* a0;
         ::QJSEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ:", &sipSelf, sipType_QJSEngine, &sipCpp, sipType_QObject, &a0))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->newQObject(a0));

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSEngine, sipName_newQObject, doc_QJSEngine_newQObject);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_collectGarbage, "collectGarbage(self)");

extern "C" {static PyObject *meth_QJSEngine_collectGarbage(PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_collectGarbage(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QJSEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QJSEngine, &sipCpp))
        {
            sipCpp->collectGarbage();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSEngine, sipName_collectGarbage, doc_QJSEngine_collectGarbage);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_installTranslatorFunctions, "installTranslatorFunctions(self, object: Union[QJSValue, QJSValue.SpecialValue, bool, int, float, str] = QJSValue())");

extern "C" {static PyObject *meth_QJSEngine_installTranslatorFunctions(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_installTranslatorFunctions(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QJSValue& a0def = QJSValue();
        const  ::QJSValue* a0 = &a0def;
        int a0State = 0;
         ::QJSEngine *sipCpp;

        static const char *sipKwdList[] = {
            sipName_object,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J1", &sipSelf, sipType_QJSEngine, &sipCpp, sipType_QJSValue, &a0, &a0State))
        {
            sipCpp->installTranslatorFunctions(*a0);
            sipReleaseType(const_cast< ::QJSValue *>(a0),sipType_QJSValue,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSEngine, sipName_installTranslatorFunctions, doc_QJSEngine_installTranslatorFunctions);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_installExtensions, "installExtensions(self, Union[QJSEngine.Extensions, QJSEngine.Extension], object: Union[QJSValue, QJSValue.SpecialValue, bool, int, float, str] = QJSValue())");

extern "C" {static PyObject *meth_QJSEngine_installExtensions(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_installExtensions(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
         ::QJSEngine::Extensions* a0;
        int a0State = 0;
        const  ::QJSValue& a1def = QJSValue();
        const  ::QJSValue* a1 = &a1def;
        int a1State = 0;
         ::QJSEngine *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_object,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|J1", &sipSelf, sipType_QJSEngine, &sipCpp, sipType_QJSEngine_Extensions, &a0, &a0State, sipType_QJSValue, &a1, &a1State))
        {
            sipCpp->installExtensions(*a0,*a1);
            sipReleaseType(a0,sipType_QJSEngine_Extensions,a0State);
            sipReleaseType(const_cast< ::QJSValue *>(a1),sipType_QJSValue,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSEngine, sipName_installExtensions, doc_QJSEngine_installExtensions);

    return NULL;
}


PyDoc_STRVAR(doc_QJSEngine_newQMetaObject, "newQMetaObject(self, QMetaObject) -> QJSValue");

extern "C" {static PyObject *meth_QJSEngine_newQMetaObject(PyObject *, PyObject *);}
static PyObject *meth_QJSEngine_newQMetaObject(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QMetaObject* a0;
         ::QJSEngine *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QJSEngine, &sipCpp, sipType_QMetaObject, &a0))
        {
             ::QJSValue*sipRes;

            sipRes = new  ::QJSValue(sipCpp->newQMetaObject(a0));

            return sipConvertFromNewType(sipRes,sipType_QJSValue,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QJSEngine, sipName_newQMetaObject, doc_QJSEngine_newQMetaObject);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QJSEngine(void *, const sipTypeDef *);}
static void *cast_QJSEngine(void *sipCppV, const sipTypeDef *targetType)
{
     ::QJSEngine *sipCpp = reinterpret_cast< ::QJSEngine *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


/* Call the instance's destructor. */
extern "C" {static void release_QJSEngine(void *, int);}
static void release_QJSEngine(void *sipCppV, int)
{
     ::QJSEngine *sipCpp = reinterpret_cast< ::QJSEngine *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


extern "C" {static void dealloc_QJSEngine(sipSimpleWrapper *);}
static void dealloc_QJSEngine(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQJSEngine *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QJSEngine(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QJSEngine(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QJSEngine(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQJSEngine *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new sipQJSEngine();

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
         ::QObject* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "JH", sipType_QObject, &a0, sipOwner))
        {
            sipCpp = new sipQJSEngine(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QJSEngine[] = {{9, 0, 1}};


static PyMethodDef methods_QJSEngine[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QJSEngine_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_collectGarbage), meth_QJSEngine_collectGarbage, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSEngine_collectGarbage)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QJSEngine_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QJSEngine_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QJSEngine_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_evaluate), (PyCFunction)meth_QJSEngine_evaluate, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QJSEngine_evaluate)},
    {SIP_MLNAME_CAST(sipName_globalObject), meth_QJSEngine_globalObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSEngine_globalObject)},
    {SIP_MLNAME_CAST(sipName_installExtensions), (PyCFunction)meth_QJSEngine_installExtensions, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QJSEngine_installExtensions)},
    {SIP_MLNAME_CAST(sipName_installTranslatorFunctions), (PyCFunction)meth_QJSEngine_installTranslatorFunctions, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QJSEngine_installTranslatorFunctions)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QJSEngine_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_newArray), (PyCFunction)meth_QJSEngine_newArray, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QJSEngine_newArray)},
    {SIP_MLNAME_CAST(sipName_newObject), meth_QJSEngine_newObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSEngine_newObject)},
    {SIP_MLNAME_CAST(sipName_newQMetaObject), meth_QJSEngine_newQMetaObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSEngine_newQMetaObject)},
    {SIP_MLNAME_CAST(sipName_newQObject), meth_QJSEngine_newQObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QJSEngine_newQObject)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QJSEngine_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QJSEngine_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QJSEngine_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QJSEngine_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

static sipEnumMemberDef enummembers_QJSEngine[] = {
    {sipName_AllExtensions, static_cast<int>( ::QJSEngine::AllExtensions), 1},
    {sipName_ConsoleExtension, static_cast<int>( ::QJSEngine::ConsoleExtension), 1},
    {sipName_GarbageCollectionExtension, static_cast<int>( ::QJSEngine::GarbageCollectionExtension), 1},
    {sipName_TranslationExtension, static_cast<int>( ::QJSEngine::TranslationExtension), 1},
};

PyDoc_STRVAR(doc_QJSEngine, "\1QJSEngine()\n"
    "QJSEngine(QObject)");


static pyqt5ClassPluginDef plugin_QJSEngine = {
    & ::QJSEngine::staticMetaObject,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtQml_QJSEngine = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QJSEngine,
        {0},
        &plugin_QJSEngine
    },
    {
        sipNameNr_QJSEngine,
        {0, 0, 1},
        18, methods_QJSEngine,
        4, enummembers_QJSEngine,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QJSEngine,
    -1,
    -1,
    supers_QJSEngine,
    0,
    init_type_QJSEngine,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QJSEngine,
    0,
    0,
    0,
    release_QJSEngine,
    cast_QJSEngine,
    0,
    0,
    0,
    0,
    0,
    0
};
