/*
 * Interface wrapper code.
 *
 * Generated by SIP 6.6.2
 *
 * Copyright (c) 2022 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 "sipAPIQtMultimedia.h"

#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtMultimedia/qcameraexposure.sip"
#include <qcameraexposure.h>
#line 29 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"

#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtMultimedia/qcamera.sip"
#include <qcamera.h>
#line 33 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtMultimedia/qcameraexposure.sip"
#include <qcameraexposure.h>
#line 36 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 751 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 39 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 646 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 42 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 98 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qpoint.sip"
#include <qpoint.h>
#line 45 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 146 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 50 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 53 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 56 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 247 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 59 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 235 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 62 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 28 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 65 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 27 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 68 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 71 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 38 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 74 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 30 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 77 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 149 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 80 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 83 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 86 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 89 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 92 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 95 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 98 "/build/pyqt5/src/PyQt5-5.15.7/build/QtMultimedia/sipQtMultimediaQCameraExposure.cpp"


PyDoc_STRVAR(doc_QCameraExposure_isAvailable, "isAvailable(self) -> bool");

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

    {
        const  ::QCameraExposure *sipCpp;

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

            sipRes = sipCpp->isAvailable();

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_isAvailable, doc_QCameraExposure_isAvailable);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_flashMode, "flashMode(self) -> QCameraExposure.FlashModes");

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

    {
        const  ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QCameraExposure, &sipCpp))
        {
             ::QCameraExposure::FlashModes*sipRes;

            sipRes = new  ::QCameraExposure::FlashModes(sipCpp->flashMode());

            return sipConvertFromNewType(sipRes,sipType_QCameraExposure_FlashModes,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_flashMode, doc_QCameraExposure_flashMode);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_isFlashModeSupported, "isFlashModeSupported(self, Union[QCameraExposure.FlashModes, QCameraExposure.FlashMode]) -> bool");

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

    {
         ::QCameraExposure::FlashModes* a0;
        int a0State = 0;
        const  ::QCameraExposure *sipCpp;

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

            sipRes = sipCpp->isFlashModeSupported(*a0);
            sipReleaseType(a0, sipType_QCameraExposure_FlashModes, a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_isFlashModeSupported, doc_QCameraExposure_isFlashModeSupported);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_isFlashReady, "isFlashReady(self) -> bool");

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

    {
        const  ::QCameraExposure *sipCpp;

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

            sipRes = sipCpp->isFlashReady();

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_isFlashReady, doc_QCameraExposure_isFlashReady);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_exposureMode, "exposureMode(self) -> QCameraExposure.ExposureMode");

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

    {
        const  ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QCameraExposure, &sipCpp))
        {
             ::QCameraExposure::ExposureMode sipRes;

            sipRes = sipCpp->exposureMode();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QCameraExposure_ExposureMode);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_exposureMode, doc_QCameraExposure_exposureMode);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_isExposureModeSupported, "isExposureModeSupported(self, QCameraExposure.ExposureMode) -> bool");

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

    {
         ::QCameraExposure::ExposureMode a0;
        const  ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QCameraExposure, &sipCpp, sipType_QCameraExposure_ExposureMode, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->isExposureModeSupported(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_isExposureModeSupported, doc_QCameraExposure_isExposureModeSupported);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_exposureCompensation, "exposureCompensation(self) -> float");

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

    {
        const  ::QCameraExposure *sipCpp;

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

            sipRes = sipCpp->exposureCompensation();

            return PyFloat_FromDouble(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_exposureCompensation, doc_QCameraExposure_exposureCompensation);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_meteringMode, "meteringMode(self) -> QCameraExposure.MeteringMode");

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

    {
        const  ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QCameraExposure, &sipCpp))
        {
             ::QCameraExposure::MeteringMode sipRes;

            sipRes = sipCpp->meteringMode();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QCameraExposure_MeteringMode);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_meteringMode, doc_QCameraExposure_meteringMode);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_isMeteringModeSupported, "isMeteringModeSupported(self, QCameraExposure.MeteringMode) -> bool");

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

    {
         ::QCameraExposure::MeteringMode a0;
        const  ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QCameraExposure, &sipCpp, sipType_QCameraExposure_MeteringMode, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->isMeteringModeSupported(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_isMeteringModeSupported, doc_QCameraExposure_isMeteringModeSupported);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_spotMeteringPoint, "spotMeteringPoint(self) -> QPointF");

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

    {
        const  ::QCameraExposure *sipCpp;

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

            sipRes = new  ::QPointF(sipCpp->spotMeteringPoint());

            return sipConvertFromNewType(sipRes,sipType_QPointF,SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_spotMeteringPoint, doc_QCameraExposure_spotMeteringPoint);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_setSpotMeteringPoint, "setSpotMeteringPoint(self, Union[QPointF, QPoint])");

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

    {
        const  ::QPointF* a0;
        int a0State = 0;
         ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QCameraExposure, &sipCpp, sipType_QPointF, &a0, &a0State))
        {
            sipCpp->setSpotMeteringPoint(*a0);
            sipReleaseType(const_cast< ::QPointF *>(a0), sipType_QPointF, a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_setSpotMeteringPoint, doc_QCameraExposure_setSpotMeteringPoint);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_isoSensitivity, "isoSensitivity(self) -> int");

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

    {
        const  ::QCameraExposure *sipCpp;

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

            sipRes = sipCpp->isoSensitivity();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_isoSensitivity, doc_QCameraExposure_isoSensitivity);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_aperture, "aperture(self) -> float");

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

    {
        const  ::QCameraExposure *sipCpp;

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

            sipRes = sipCpp->aperture();

            return PyFloat_FromDouble(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_aperture, doc_QCameraExposure_aperture);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_shutterSpeed, "shutterSpeed(self) -> float");

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

    {
        const  ::QCameraExposure *sipCpp;

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

            sipRes = sipCpp->shutterSpeed();

            return PyFloat_FromDouble(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_shutterSpeed, doc_QCameraExposure_shutterSpeed);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_requestedIsoSensitivity, "requestedIsoSensitivity(self) -> int");

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

    {
        const  ::QCameraExposure *sipCpp;

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

            sipRes = sipCpp->requestedIsoSensitivity();

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_requestedIsoSensitivity, doc_QCameraExposure_requestedIsoSensitivity);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_requestedAperture, "requestedAperture(self) -> float");

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

    {
        const  ::QCameraExposure *sipCpp;

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

            sipRes = sipCpp->requestedAperture();

            return PyFloat_FromDouble(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_requestedAperture, doc_QCameraExposure_requestedAperture);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_requestedShutterSpeed, "requestedShutterSpeed(self) -> float");

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

    {
        const  ::QCameraExposure *sipCpp;

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

            sipRes = sipCpp->requestedShutterSpeed();

            return PyFloat_FromDouble(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_requestedShutterSpeed, doc_QCameraExposure_requestedShutterSpeed);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_supportedIsoSensitivities, "supportedIsoSensitivities(self) -> Tuple[List[int], bool]");

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

    {
        bool a0;
        const  ::QCameraExposure *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_QCameraExposure, &sipCpp))
        {
             ::QList<int>*sipRes;

            sipRes = new  ::QList<int>(sipCpp->supportedIsoSensitivities(&a0));

            PyObject *sipResObj = sipConvertFromNewType(sipRes,sipType_QList_1800,SIP_NULLPTR);
            return sipBuildResult(0,"(Rb)",sipResObj,a0);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_supportedIsoSensitivities, doc_QCameraExposure_supportedIsoSensitivities);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_supportedApertures, "supportedApertures(self) -> Tuple[List[float], bool]");

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

    {
        bool a0;
        const  ::QCameraExposure *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_QCameraExposure, &sipCpp))
        {
             ::QList< ::qreal>*sipRes;

            sipRes = new  ::QList< ::qreal>(sipCpp->supportedApertures(&a0));

            PyObject *sipResObj = sipConvertFromNewType(sipRes,sipType_QList_2400,SIP_NULLPTR);
            return sipBuildResult(0,"(Rb)",sipResObj,a0);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_supportedApertures, doc_QCameraExposure_supportedApertures);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_supportedShutterSpeeds, "supportedShutterSpeeds(self) -> Tuple[List[float], bool]");

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

    {
        bool a0;
        const  ::QCameraExposure *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_QCameraExposure, &sipCpp))
        {
             ::QList< ::qreal>*sipRes;

            sipRes = new  ::QList< ::qreal>(sipCpp->supportedShutterSpeeds(&a0));

            PyObject *sipResObj = sipConvertFromNewType(sipRes,sipType_QList_2400,SIP_NULLPTR);
            return sipBuildResult(0,"(Rb)",sipResObj,a0);
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_supportedShutterSpeeds, doc_QCameraExposure_supportedShutterSpeeds);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_setFlashMode, "setFlashMode(self, Union[QCameraExposure.FlashModes, QCameraExposure.FlashMode])");

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

    {
         ::QCameraExposure::FlashModes* a0;
        int a0State = 0;
         ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QCameraExposure, &sipCpp, sipType_QCameraExposure_FlashModes, &a0, &a0State))
        {
            sipCpp->setFlashMode(*a0);
            sipReleaseType(a0, sipType_QCameraExposure_FlashModes, a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_setFlashMode, doc_QCameraExposure_setFlashMode);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_setExposureMode, "setExposureMode(self, QCameraExposure.ExposureMode)");

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

    {
         ::QCameraExposure::ExposureMode a0;
         ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QCameraExposure, &sipCpp, sipType_QCameraExposure_ExposureMode, &a0))
        {
            sipCpp->setExposureMode(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_setExposureMode, doc_QCameraExposure_setExposureMode);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_setMeteringMode, "setMeteringMode(self, QCameraExposure.MeteringMode)");

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

    {
         ::QCameraExposure::MeteringMode a0;
         ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QCameraExposure, &sipCpp, sipType_QCameraExposure_MeteringMode, &a0))
        {
            sipCpp->setMeteringMode(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_setMeteringMode, doc_QCameraExposure_setMeteringMode);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_setExposureCompensation, "setExposureCompensation(self, float)");

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

    {
         ::qreal a0;
         ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QCameraExposure, &sipCpp, &a0))
        {
            sipCpp->setExposureCompensation(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_setExposureCompensation, doc_QCameraExposure_setExposureCompensation);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_setManualIsoSensitivity, "setManualIsoSensitivity(self, int)");

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

    {
        int a0;
         ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QCameraExposure, &sipCpp, &a0))
        {
            sipCpp->setManualIsoSensitivity(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_setManualIsoSensitivity, doc_QCameraExposure_setManualIsoSensitivity);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_setAutoIsoSensitivity, "setAutoIsoSensitivity(self)");

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

    {
         ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QCameraExposure, &sipCpp))
        {
            sipCpp->setAutoIsoSensitivity();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_setAutoIsoSensitivity, doc_QCameraExposure_setAutoIsoSensitivity);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_setManualAperture, "setManualAperture(self, float)");

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

    {
         ::qreal a0;
         ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QCameraExposure, &sipCpp, &a0))
        {
            sipCpp->setManualAperture(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_setManualAperture, doc_QCameraExposure_setManualAperture);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_setAutoAperture, "setAutoAperture(self)");

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

    {
         ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QCameraExposure, &sipCpp))
        {
            sipCpp->setAutoAperture();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_setAutoAperture, doc_QCameraExposure_setAutoAperture);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_setManualShutterSpeed, "setManualShutterSpeed(self, float)");

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

    {
         ::qreal a0;
         ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QCameraExposure, &sipCpp, &a0))
        {
            sipCpp->setManualShutterSpeed(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_setManualShutterSpeed, doc_QCameraExposure_setManualShutterSpeed);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QCameraExposure_setAutoShutterSpeed, "setAutoShutterSpeed(self)");

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

    {
         ::QCameraExposure *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QCameraExposure, &sipCpp))
        {
            sipCpp->setAutoShutterSpeed();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QCameraExposure, sipName_setAutoShutterSpeed, doc_QCameraExposure_setAutoShutterSpeed);

    return SIP_NULLPTR;
}


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

    if (targetType == sipType_QCameraExposure)
        return sipCppV;

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

    return SIP_NULLPTR;
}


/* Call the instance's destructor. */
extern "C" {static void release_QCameraExposure(void *, int);}
static void release_QCameraExposure(void *, int)
{
}


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


static PyMethodDef methods_QCameraExposure[] = {
    {sipName_aperture, meth_QCameraExposure_aperture, METH_VARARGS, doc_QCameraExposure_aperture},
    {sipName_exposureCompensation, meth_QCameraExposure_exposureCompensation, METH_VARARGS, doc_QCameraExposure_exposureCompensation},
    {sipName_exposureMode, meth_QCameraExposure_exposureMode, METH_VARARGS, doc_QCameraExposure_exposureMode},
    {sipName_flashMode, meth_QCameraExposure_flashMode, METH_VARARGS, doc_QCameraExposure_flashMode},
    {sipName_isAvailable, meth_QCameraExposure_isAvailable, METH_VARARGS, doc_QCameraExposure_isAvailable},
    {sipName_isExposureModeSupported, meth_QCameraExposure_isExposureModeSupported, METH_VARARGS, doc_QCameraExposure_isExposureModeSupported},
    {sipName_isFlashModeSupported, meth_QCameraExposure_isFlashModeSupported, METH_VARARGS, doc_QCameraExposure_isFlashModeSupported},
    {sipName_isFlashReady, meth_QCameraExposure_isFlashReady, METH_VARARGS, doc_QCameraExposure_isFlashReady},
    {sipName_isMeteringModeSupported, meth_QCameraExposure_isMeteringModeSupported, METH_VARARGS, doc_QCameraExposure_isMeteringModeSupported},
    {sipName_isoSensitivity, meth_QCameraExposure_isoSensitivity, METH_VARARGS, doc_QCameraExposure_isoSensitivity},
    {sipName_meteringMode, meth_QCameraExposure_meteringMode, METH_VARARGS, doc_QCameraExposure_meteringMode},
    {sipName_requestedAperture, meth_QCameraExposure_requestedAperture, METH_VARARGS, doc_QCameraExposure_requestedAperture},
    {sipName_requestedIsoSensitivity, meth_QCameraExposure_requestedIsoSensitivity, METH_VARARGS, doc_QCameraExposure_requestedIsoSensitivity},
    {sipName_requestedShutterSpeed, meth_QCameraExposure_requestedShutterSpeed, METH_VARARGS, doc_QCameraExposure_requestedShutterSpeed},
    {sipName_setAutoAperture, meth_QCameraExposure_setAutoAperture, METH_VARARGS, doc_QCameraExposure_setAutoAperture},
    {sipName_setAutoIsoSensitivity, meth_QCameraExposure_setAutoIsoSensitivity, METH_VARARGS, doc_QCameraExposure_setAutoIsoSensitivity},
    {sipName_setAutoShutterSpeed, meth_QCameraExposure_setAutoShutterSpeed, METH_VARARGS, doc_QCameraExposure_setAutoShutterSpeed},
    {sipName_setExposureCompensation, meth_QCameraExposure_setExposureCompensation, METH_VARARGS, doc_QCameraExposure_setExposureCompensation},
    {sipName_setExposureMode, meth_QCameraExposure_setExposureMode, METH_VARARGS, doc_QCameraExposure_setExposureMode},
    {sipName_setFlashMode, meth_QCameraExposure_setFlashMode, METH_VARARGS, doc_QCameraExposure_setFlashMode},
    {sipName_setManualAperture, meth_QCameraExposure_setManualAperture, METH_VARARGS, doc_QCameraExposure_setManualAperture},
    {sipName_setManualIsoSensitivity, meth_QCameraExposure_setManualIsoSensitivity, METH_VARARGS, doc_QCameraExposure_setManualIsoSensitivity},
    {sipName_setManualShutterSpeed, meth_QCameraExposure_setManualShutterSpeed, METH_VARARGS, doc_QCameraExposure_setManualShutterSpeed},
    {sipName_setMeteringMode, meth_QCameraExposure_setMeteringMode, METH_VARARGS, doc_QCameraExposure_setMeteringMode},
    {sipName_setSpotMeteringPoint, meth_QCameraExposure_setSpotMeteringPoint, METH_VARARGS, doc_QCameraExposure_setSpotMeteringPoint},
    {sipName_shutterSpeed, meth_QCameraExposure_shutterSpeed, METH_VARARGS, doc_QCameraExposure_shutterSpeed},
    {sipName_spotMeteringPoint, meth_QCameraExposure_spotMeteringPoint, METH_VARARGS, doc_QCameraExposure_spotMeteringPoint},
    {sipName_supportedApertures, SIP_MLMETH_CAST(meth_QCameraExposure_supportedApertures), METH_VARARGS|METH_KEYWORDS, doc_QCameraExposure_supportedApertures},
    {sipName_supportedIsoSensitivities, SIP_MLMETH_CAST(meth_QCameraExposure_supportedIsoSensitivities), METH_VARARGS|METH_KEYWORDS, doc_QCameraExposure_supportedIsoSensitivities},
    {sipName_supportedShutterSpeeds, SIP_MLMETH_CAST(meth_QCameraExposure_supportedShutterSpeeds), METH_VARARGS|METH_KEYWORDS, doc_QCameraExposure_supportedShutterSpeeds}
};

static sipEnumMemberDef enummembers_QCameraExposure[] = {
    {sipName_ExposureAction, static_cast<int>( ::QCameraExposure::ExposureAction), 47},
    {sipName_ExposureAuto, static_cast<int>( ::QCameraExposure::ExposureAuto), 47},
    {sipName_ExposureBacklight, static_cast<int>( ::QCameraExposure::ExposureBacklight), 47},
    {sipName_ExposureBarcode, static_cast<int>( ::QCameraExposure::ExposureBarcode), 47},
    {sipName_ExposureBeach, static_cast<int>( ::QCameraExposure::ExposureBeach), 47},
    {sipName_ExposureCandlelight, static_cast<int>( ::QCameraExposure::ExposureCandlelight), 47},
    {sipName_ExposureFireworks, static_cast<int>( ::QCameraExposure::ExposureFireworks), 47},
    {sipName_ExposureLandscape, static_cast<int>( ::QCameraExposure::ExposureLandscape), 47},
    {sipName_ExposureLargeAperture, static_cast<int>( ::QCameraExposure::ExposureLargeAperture), 47},
    {sipName_ExposureManual, static_cast<int>( ::QCameraExposure::ExposureManual), 47},
    {sipName_ExposureModeVendor, static_cast<int>( ::QCameraExposure::ExposureModeVendor), 47},
    {sipName_ExposureNight, static_cast<int>( ::QCameraExposure::ExposureNight), 47},
    {sipName_ExposureNightPortrait, static_cast<int>( ::QCameraExposure::ExposureNightPortrait), 47},
    {sipName_ExposureParty, static_cast<int>( ::QCameraExposure::ExposureParty), 47},
    {sipName_ExposurePortrait, static_cast<int>( ::QCameraExposure::ExposurePortrait), 47},
    {sipName_ExposureSmallAperture, static_cast<int>( ::QCameraExposure::ExposureSmallAperture), 47},
    {sipName_ExposureSnow, static_cast<int>( ::QCameraExposure::ExposureSnow), 47},
    {sipName_ExposureSports, static_cast<int>( ::QCameraExposure::ExposureSports), 47},
    {sipName_ExposureSpotlight, static_cast<int>( ::QCameraExposure::ExposureSpotlight), 47},
    {sipName_ExposureSteadyPhoto, static_cast<int>( ::QCameraExposure::ExposureSteadyPhoto), 47},
    {sipName_ExposureSunset, static_cast<int>( ::QCameraExposure::ExposureSunset), 47},
    {sipName_ExposureTheatre, static_cast<int>( ::QCameraExposure::ExposureTheatre), 47},
    {sipName_FlashAuto, static_cast<int>( ::QCameraExposure::FlashAuto), 48},
    {sipName_FlashFill, static_cast<int>( ::QCameraExposure::FlashFill), 48},
    {sipName_FlashManual, static_cast<int>( ::QCameraExposure::FlashManual), 48},
    {sipName_FlashOff, static_cast<int>( ::QCameraExposure::FlashOff), 48},
    {sipName_FlashOn, static_cast<int>( ::QCameraExposure::FlashOn), 48},
    {sipName_FlashRedEyeReduction, static_cast<int>( ::QCameraExposure::FlashRedEyeReduction), 48},
    {sipName_FlashSlowSyncFrontCurtain, static_cast<int>( ::QCameraExposure::FlashSlowSyncFrontCurtain), 48},
    {sipName_FlashSlowSyncRearCurtain, static_cast<int>( ::QCameraExposure::FlashSlowSyncRearCurtain), 48},
    {sipName_FlashTorch, static_cast<int>( ::QCameraExposure::FlashTorch), 48},
    {sipName_FlashVideoLight, static_cast<int>( ::QCameraExposure::FlashVideoLight), 48},
    {sipName_MeteringAverage, static_cast<int>( ::QCameraExposure::MeteringAverage), 50},
    {sipName_MeteringMatrix, static_cast<int>( ::QCameraExposure::MeteringMatrix), 50},
    {sipName_MeteringSpot, static_cast<int>( ::QCameraExposure::MeteringSpot), 50},
};


/* Define this type's signals. */
static const pyqt5QtSignal signals_QCameraExposure[] = {
    {"exposureCompensationChanged(qreal)", "\1exposureCompensationChanged(self, float)", SIP_NULLPTR, SIP_NULLPTR},
    {"isoSensitivityChanged(int)", "\1isoSensitivityChanged(self, int)", SIP_NULLPTR, SIP_NULLPTR},
    {"shutterSpeedRangeChanged()", "\1shutterSpeedRangeChanged(self)", SIP_NULLPTR, SIP_NULLPTR},
    {"shutterSpeedChanged(qreal)", "\1shutterSpeedChanged(self, float)", SIP_NULLPTR, SIP_NULLPTR},
    {"apertureRangeChanged()", "\1apertureRangeChanged(self)", SIP_NULLPTR, SIP_NULLPTR},
    {"apertureChanged(qreal)", "\1apertureChanged(self, float)", SIP_NULLPTR, SIP_NULLPTR},
    {"flashReady(bool)", "\1flashReady(self, bool)", SIP_NULLPTR, SIP_NULLPTR},
    {SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR}
};


static pyqt5ClassPluginDef plugin_QCameraExposure = {
    & ::QCameraExposure::staticMetaObject,
    0,
    signals_QCameraExposure,
    SIP_NULLPTR
};


sipClassTypeDef sipTypeDef_QtMultimedia_QCameraExposure = {
    {
        -1,
        SIP_NULLPTR,
        SIP_NULLPTR,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QCameraExposure,
        SIP_NULLPTR,
        &plugin_QCameraExposure
    },
    {
        sipNameNr_QCameraExposure,
        {0, 0, 1},
        30, methods_QCameraExposure,
        35, enummembers_QCameraExposure,
        0, SIP_NULLPTR,
        {SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    },
    SIP_NULLPTR,
    -1,
    -1,
    supers_QCameraExposure,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    release_QCameraExposure,
    cast_QCameraExposure,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    0,
};
