/*
 * 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 "sipAPIQtGui.h"

#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtGui/qpalette.sip"
#include <qpalette.h>
#line 29 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQPalette.cpp"

#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtGui/qcolor.sip"
#include <qcolor.h>
#line 33 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQPalette.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 36 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQPalette.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtGui/qbrush.sip"
#include <qbrush.h>
#line 39 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQPalette.cpp"
#line 26 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 42 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQPalette.cpp"


PyDoc_STRVAR(doc_QPalette_currentColorGroup, "currentColorGroup(self) -> QPalette.ColorGroup");

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

    {
        const  ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QPalette, &sipCpp))
        {
             ::QPalette::ColorGroup sipRes;

            sipRes = sipCpp->currentColorGroup();

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_currentColorGroup, doc_QPalette_currentColorGroup);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_setCurrentColorGroup, "setCurrentColorGroup(self, QPalette.ColorGroup)");

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

    {
         ::QPalette::ColorGroup a0;
         ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorGroup, &a0))
        {
            sipCpp->setCurrentColorGroup(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_setCurrentColorGroup, doc_QPalette_setCurrentColorGroup);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_color, "color(self, QPalette.ColorGroup, QPalette.ColorRole) -> QColor\n"
"color(self, QPalette.ColorRole) -> QColor");

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

    {
         ::QPalette::ColorGroup a0;
         ::QPalette::ColorRole a1;
        const  ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEE", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorGroup, &a0, sipType_QPalette_ColorRole, &a1))
        {
             ::QColor*sipRes;

            sipRes = new  ::QColor(sipCpp->color(a0,a1));

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

    {
         ::QPalette::ColorRole a0;
        const  ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorRole, &a0))
        {
             ::QColor*sipRes;

            sipRes = new  ::QColor(sipCpp->color(a0));

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_color, doc_QPalette_color);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_brush, "brush(self, QPalette.ColorGroup, QPalette.ColorRole) -> QBrush\n"
"brush(self, QPalette.ColorRole) -> QBrush");

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

    {
         ::QPalette::ColorGroup a0;
         ::QPalette::ColorRole a1;
        const  ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEE", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorGroup, &a0, sipType_QPalette_ColorRole, &a1))
        {
             ::QBrush*sipRes;

            sipRes = new  ::QBrush(sipCpp->brush(a0,a1));

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

    {
         ::QPalette::ColorRole a0;
        const  ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorRole, &a0))
        {
             ::QBrush*sipRes;

            sipRes = new  ::QBrush(sipCpp->brush(a0));

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_brush, doc_QPalette_brush);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_setBrush, "setBrush(self, QPalette.ColorGroup, QPalette.ColorRole, Union[QBrush, QColor, Qt.GlobalColor, QGradient])\n"
"setBrush(self, QPalette.ColorRole, Union[QBrush, QColor, Qt.GlobalColor, QGradient])");

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

    {
         ::QPalette::ColorGroup a0;
         ::QPalette::ColorRole a1;
        const  ::QBrush* a2;
        int a2State = 0;
         ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEEJ1", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorGroup, &a0, sipType_QPalette_ColorRole, &a1, sipType_QBrush, &a2, &a2State))
        {
            sipCpp->setBrush(a0,a1,*a2);
            sipReleaseType(const_cast< ::QBrush *>(a2), sipType_QBrush, a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::QPalette::ColorRole a0;
        const  ::QBrush* a1;
        int a1State = 0;
         ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEJ1", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorRole, &a0, sipType_QBrush, &a1, &a1State))
        {
            sipCpp->setBrush(a0,*a1);
            sipReleaseType(const_cast< ::QBrush *>(a1), sipType_QBrush, a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_setBrush, doc_QPalette_setBrush);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_setColorGroup, "setColorGroup(self, QPalette.ColorGroup, Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient])");

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

    {
         ::QPalette::ColorGroup a0;
        const  ::QBrush* a1;
        int a1State = 0;
        const  ::QBrush* a2;
        int a2State = 0;
        const  ::QBrush* a3;
        int a3State = 0;
        const  ::QBrush* a4;
        int a4State = 0;
        const  ::QBrush* a5;
        int a5State = 0;
        const  ::QBrush* a6;
        int a6State = 0;
        const  ::QBrush* a7;
        int a7State = 0;
        const  ::QBrush* a8;
        int a8State = 0;
        const  ::QBrush* a9;
        int a9State = 0;
         ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEJ1J1J1J1J1J1J1J1J1", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorGroup, &a0, sipType_QBrush, &a1, &a1State, sipType_QBrush, &a2, &a2State, sipType_QBrush, &a3, &a3State, sipType_QBrush, &a4, &a4State, sipType_QBrush, &a5, &a5State, sipType_QBrush, &a6, &a6State, sipType_QBrush, &a7, &a7State, sipType_QBrush, &a8, &a8State, sipType_QBrush, &a9, &a9State))
        {
            sipCpp->setColorGroup(a0,*a1,*a2,*a3,*a4,*a5,*a6,*a7,*a8,*a9);
            sipReleaseType(const_cast< ::QBrush *>(a1), sipType_QBrush, a1State);
            sipReleaseType(const_cast< ::QBrush *>(a2), sipType_QBrush, a2State);
            sipReleaseType(const_cast< ::QBrush *>(a3), sipType_QBrush, a3State);
            sipReleaseType(const_cast< ::QBrush *>(a4), sipType_QBrush, a4State);
            sipReleaseType(const_cast< ::QBrush *>(a5), sipType_QBrush, a5State);
            sipReleaseType(const_cast< ::QBrush *>(a6), sipType_QBrush, a6State);
            sipReleaseType(const_cast< ::QBrush *>(a7), sipType_QBrush, a7State);
            sipReleaseType(const_cast< ::QBrush *>(a8), sipType_QBrush, a8State);
            sipReleaseType(const_cast< ::QBrush *>(a9), sipType_QBrush, a9State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_setColorGroup, doc_QPalette_setColorGroup);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_isEqual, "isEqual(self, QPalette.ColorGroup, QPalette.ColorGroup) -> bool");

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

    {
         ::QPalette::ColorGroup a0;
         ::QPalette::ColorGroup a1;
        const  ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEE", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorGroup, &a0, sipType_QPalette_ColorGroup, &a1))
        {
            bool sipRes;

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

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_isEqual, doc_QPalette_isEqual);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_windowText, "windowText(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->windowText());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_windowText, doc_QPalette_windowText);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_button, "button(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->button());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_button, doc_QPalette_button);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_light, "light(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->light());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_light, doc_QPalette_light);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_dark, "dark(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->dark());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_dark, doc_QPalette_dark);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_mid, "mid(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->mid());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_mid, doc_QPalette_mid);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_text, "text(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->text());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_text, doc_QPalette_text);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_base, "base(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->base());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_base, doc_QPalette_base);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_alternateBase, "alternateBase(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->alternateBase());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_alternateBase, doc_QPalette_alternateBase);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_window, "window(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->window());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_window, doc_QPalette_window);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_midlight, "midlight(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->midlight());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_midlight, doc_QPalette_midlight);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_brightText, "brightText(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->brightText());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_brightText, doc_QPalette_brightText);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_buttonText, "buttonText(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->buttonText());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_buttonText, doc_QPalette_buttonText);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_shadow, "shadow(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->shadow());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_shadow, doc_QPalette_shadow);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_highlight, "highlight(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->highlight());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_highlight, doc_QPalette_highlight);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_highlightedText, "highlightedText(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->highlightedText());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_highlightedText, doc_QPalette_highlightedText);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_link, "link(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->link());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_link, doc_QPalette_link);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_linkVisited, "linkVisited(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->linkVisited());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_linkVisited, doc_QPalette_linkVisited);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_toolTipBase, "toolTipBase(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->toolTipBase());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_toolTipBase, doc_QPalette_toolTipBase);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_toolTipText, "toolTipText(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->toolTipText());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_toolTipText, doc_QPalette_toolTipText);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_placeholderText, "placeholderText(self) -> QBrush");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = new  ::QBrush(sipCpp->placeholderText());

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

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_placeholderText, doc_QPalette_placeholderText);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_isCopyOf, "isCopyOf(self, QPalette) -> bool");

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

    {
        const  ::QPalette* a0;
        const  ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->isCopyOf(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_isCopyOf, doc_QPalette_isCopyOf);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_resolve, "resolve(self, QPalette) -> QPalette\n"
"resolve(self) -> int\n"
"resolve(self, int)");

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

    {
        const  ::QPalette* a0;
        const  ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette, &a0))
        {
             ::QPalette*sipRes;

            sipRes = new  ::QPalette(sipCpp->resolve(*a0));

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = sipCpp->resolve();

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
         ::uint a0;
         ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QPalette, &sipCpp, &a0))
        {
            sipCpp->resolve(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_resolve, doc_QPalette_resolve);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_setColor, "setColor(self, QPalette.ColorGroup, QPalette.ColorRole, Union[QColor, Qt.GlobalColor, QGradient])\n"
"setColor(self, QPalette.ColorRole, Union[QColor, Qt.GlobalColor, QGradient])");

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

    {
         ::QPalette::ColorGroup a0;
         ::QPalette::ColorRole a1;
        const  ::QColor* a2;
        int a2State = 0;
         ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEEJ1", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorGroup, &a0, sipType_QPalette_ColorRole, &a1, sipType_QColor, &a2, &a2State))
        {
            sipCpp->setColor(a0,a1,*a2);
            sipReleaseType(const_cast< ::QColor *>(a2), sipType_QColor, a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::QPalette::ColorRole a0;
        const  ::QColor* a1;
        int a1State = 0;
         ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEJ1", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorRole, &a0, sipType_QColor, &a1, &a1State))
        {
            sipCpp->setColor(a0,*a1);
            sipReleaseType(const_cast< ::QColor *>(a1), sipType_QColor, a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_setColor, doc_QPalette_setColor);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_isBrushSet, "isBrushSet(self, QPalette.ColorGroup, QPalette.ColorRole) -> bool");

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

    {
         ::QPalette::ColorGroup a0;
         ::QPalette::ColorRole a1;
        const  ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEE", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette_ColorGroup, &a0, sipType_QPalette_ColorRole, &a1))
        {
            bool sipRes;

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

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_isBrushSet, doc_QPalette_isBrushSet);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_cacheKey, "cacheKey(self) -> int");

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

    {
        const  ::QPalette *sipCpp;

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

            sipRes = sipCpp->cacheKey();

            return PyLong_FromLongLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_cacheKey, doc_QPalette_cacheKey);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_QPalette_swap, "swap(self, QPalette)");

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

    {
         ::QPalette* a0;
         ::QPalette *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QPalette, &sipCpp, sipType_QPalette, &a0))
        {
            sipCpp->swap(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_QPalette, sipName_swap, doc_QPalette_swap);

    return SIP_NULLPTR;
}


extern "C" {static PyObject *slot_QPalette___ne__(PyObject *,PyObject *);}
static PyObject *slot_QPalette___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QPalette *sipCpp = reinterpret_cast< ::QPalette *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QPalette));

    if (!sipCpp)
        return SIP_NULLPTR;

    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QPalette* a0;

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

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

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return SIP_NULLPTR;

    return sipPySlotExtend(&sipModuleAPI_QtGui, ne_slot, sipType_QPalette, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QPalette___eq__(PyObject *,PyObject *);}
static PyObject *slot_QPalette___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QPalette *sipCpp = reinterpret_cast< ::QPalette *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QPalette));

    if (!sipCpp)
        return SIP_NULLPTR;

    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const  ::QPalette* a0;

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

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

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return SIP_NULLPTR;

    return sipPySlotExtend(&sipModuleAPI_QtGui, eq_slot, sipType_QPalette, sipSelf, sipArg);
}


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


extern "C" {static void *array_QPalette(Py_ssize_t);}
static void *array_QPalette(Py_ssize_t sipNrElem)
{
    return new  ::QPalette[sipNrElem];
}


extern "C" {static void array_delete_QPalette(void *);}
static void array_delete_QPalette(void *sipCpp)
{
    delete[] reinterpret_cast< ::QPalette *>(sipCpp);
}


extern "C" {static void assign_QPalette(void *, Py_ssize_t, void *);}
static void assign_QPalette(void *sipDst, Py_ssize_t sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QPalette *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QPalette *>(sipSrc);
}


extern "C" {static void *copy_QPalette(const void *, Py_ssize_t);}
static void *copy_QPalette(const void *sipSrc, Py_ssize_t sipSrcIdx)
{
    return new  ::QPalette(reinterpret_cast<const  ::QPalette *>(sipSrc)[sipSrcIdx]);
}


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


extern "C" {static void *init_type_QPalette(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QPalette(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QPalette *sipCpp = SIP_NULLPTR;

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

            return sipCpp;
        }
    }

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, "J1", sipType_QColor, &a0, &a0State))
        {
            sipCpp = new  ::QPalette(*a0);
            sipReleaseType(const_cast< ::QColor *>(a0), sipType_QColor, a0State);

            return sipCpp;
        }
    }

    {
         ::Qt::GlobalColor a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, "E", sipType_Qt_GlobalColor, &a0))
        {
            sipCpp = new  ::QPalette(a0);

            return sipCpp;
        }
    }

    {
        const  ::QColor* a0;
        int a0State = 0;
        const  ::QColor* a1;
        int a1State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, "J1J1", sipType_QColor, &a0, &a0State, sipType_QColor, &a1, &a1State))
        {
            sipCpp = new  ::QPalette(*a0,*a1);
            sipReleaseType(const_cast< ::QColor *>(a0), sipType_QColor, a0State);
            sipReleaseType(const_cast< ::QColor *>(a1), sipType_QColor, a1State);

            return sipCpp;
        }
    }

    {
        const  ::QBrush* a0;
        int a0State = 0;
        const  ::QBrush* a1;
        int a1State = 0;
        const  ::QBrush* a2;
        int a2State = 0;
        const  ::QBrush* a3;
        int a3State = 0;
        const  ::QBrush* a4;
        int a4State = 0;
        const  ::QBrush* a5;
        int a5State = 0;
        const  ::QBrush* a6;
        int a6State = 0;
        const  ::QBrush* a7;
        int a7State = 0;
        const  ::QBrush* a8;
        int a8State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, "J1J1J1J1J1J1J1J1J1", sipType_QBrush, &a0, &a0State, sipType_QBrush, &a1, &a1State, sipType_QBrush, &a2, &a2State, sipType_QBrush, &a3, &a3State, sipType_QBrush, &a4, &a4State, sipType_QBrush, &a5, &a5State, sipType_QBrush, &a6, &a6State, sipType_QBrush, &a7, &a7State, sipType_QBrush, &a8, &a8State))
        {
            sipCpp = new  ::QPalette(*a0,*a1,*a2,*a3,*a4,*a5,*a6,*a7,*a8);
            sipReleaseType(const_cast< ::QBrush *>(a0), sipType_QBrush, a0State);
            sipReleaseType(const_cast< ::QBrush *>(a1), sipType_QBrush, a1State);
            sipReleaseType(const_cast< ::QBrush *>(a2), sipType_QBrush, a2State);
            sipReleaseType(const_cast< ::QBrush *>(a3), sipType_QBrush, a3State);
            sipReleaseType(const_cast< ::QBrush *>(a4), sipType_QBrush, a4State);
            sipReleaseType(const_cast< ::QBrush *>(a5), sipType_QBrush, a5State);
            sipReleaseType(const_cast< ::QBrush *>(a6), sipType_QBrush, a6State);
            sipReleaseType(const_cast< ::QBrush *>(a7), sipType_QBrush, a7State);
            sipReleaseType(const_cast< ::QBrush *>(a8), sipType_QBrush, a8State);

            return sipCpp;
        }
    }

    {
        const  ::QPalette* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, "J9", sipType_QPalette, &a0))
        {
            sipCpp = new  ::QPalette(*a0);

            return sipCpp;
        }
    }

    {
        const  ::QVariant* a0;
        PyObject *a0Wrapper;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, "@J1", &a0Wrapper, sipType_QVariant, &a0, &a0State))
        {
            sipErrorState sipError = sipErrorNone;

#line 38 "/build/pyqt5/src/PyQt5-5.15.7/sip/QtGui/qpalette.sip"
        if (a0->canConvert<QPalette>())
            sipCpp = new QPalette(a0->value<QPalette>());
        else
            sipError = sipBadCallableArg(0, a0Wrapper);
#line 1305 "/build/pyqt5/src/PyQt5-5.15.7/build/QtGui/sipQtGuiQPalette.cpp"
            sipReleaseType(const_cast< ::QVariant *>(a0), sipType_QVariant, a0State);

            if (sipError == sipErrorNone)
                return sipCpp;

            if (sipUnused)
            {
                Py_XDECREF(*sipUnused);
            }

            sipAddException(sipError, sipParseErr);

            if (sipError == sipErrorFail)
                return SIP_NULLPTR;
        }
    }

    return SIP_NULLPTR;
}


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


static PyMethodDef methods_QPalette[] = {
    {sipName_alternateBase, meth_QPalette_alternateBase, METH_VARARGS, doc_QPalette_alternateBase},
    {sipName_base, meth_QPalette_base, METH_VARARGS, doc_QPalette_base},
    {sipName_brightText, meth_QPalette_brightText, METH_VARARGS, doc_QPalette_brightText},
    {sipName_brush, meth_QPalette_brush, METH_VARARGS, doc_QPalette_brush},
    {sipName_button, meth_QPalette_button, METH_VARARGS, doc_QPalette_button},
    {sipName_buttonText, meth_QPalette_buttonText, METH_VARARGS, doc_QPalette_buttonText},
    {sipName_cacheKey, meth_QPalette_cacheKey, METH_VARARGS, doc_QPalette_cacheKey},
    {sipName_color, meth_QPalette_color, METH_VARARGS, doc_QPalette_color},
    {sipName_currentColorGroup, meth_QPalette_currentColorGroup, METH_VARARGS, doc_QPalette_currentColorGroup},
    {sipName_dark, meth_QPalette_dark, METH_VARARGS, doc_QPalette_dark},
    {sipName_highlight, meth_QPalette_highlight, METH_VARARGS, doc_QPalette_highlight},
    {sipName_highlightedText, meth_QPalette_highlightedText, METH_VARARGS, doc_QPalette_highlightedText},
    {sipName_isBrushSet, meth_QPalette_isBrushSet, METH_VARARGS, doc_QPalette_isBrushSet},
    {sipName_isCopyOf, meth_QPalette_isCopyOf, METH_VARARGS, doc_QPalette_isCopyOf},
    {sipName_isEqual, meth_QPalette_isEqual, METH_VARARGS, doc_QPalette_isEqual},
    {sipName_light, meth_QPalette_light, METH_VARARGS, doc_QPalette_light},
    {sipName_link, meth_QPalette_link, METH_VARARGS, doc_QPalette_link},
    {sipName_linkVisited, meth_QPalette_linkVisited, METH_VARARGS, doc_QPalette_linkVisited},
    {sipName_mid, meth_QPalette_mid, METH_VARARGS, doc_QPalette_mid},
    {sipName_midlight, meth_QPalette_midlight, METH_VARARGS, doc_QPalette_midlight},
    {sipName_placeholderText, meth_QPalette_placeholderText, METH_VARARGS, doc_QPalette_placeholderText},
    {sipName_resolve, meth_QPalette_resolve, METH_VARARGS, doc_QPalette_resolve},
    {sipName_setBrush, meth_QPalette_setBrush, METH_VARARGS, doc_QPalette_setBrush},
    {sipName_setColor, meth_QPalette_setColor, METH_VARARGS, doc_QPalette_setColor},
    {sipName_setColorGroup, meth_QPalette_setColorGroup, METH_VARARGS, doc_QPalette_setColorGroup},
    {sipName_setCurrentColorGroup, meth_QPalette_setCurrentColorGroup, METH_VARARGS, doc_QPalette_setCurrentColorGroup},
    {sipName_shadow, meth_QPalette_shadow, METH_VARARGS, doc_QPalette_shadow},
    {sipName_swap, meth_QPalette_swap, METH_VARARGS, doc_QPalette_swap},
    {sipName_text, meth_QPalette_text, METH_VARARGS, doc_QPalette_text},
    {sipName_toolTipBase, meth_QPalette_toolTipBase, METH_VARARGS, doc_QPalette_toolTipBase},
    {sipName_toolTipText, meth_QPalette_toolTipText, METH_VARARGS, doc_QPalette_toolTipText},
    {sipName_window, meth_QPalette_window, METH_VARARGS, doc_QPalette_window},
    {sipName_windowText, meth_QPalette_windowText, METH_VARARGS, doc_QPalette_windowText}
};

static sipEnumMemberDef enummembers_QPalette[] = {
    {sipName_Active, static_cast<int>( ::QPalette::Active), 226},
    {sipName_All, static_cast<int>( ::QPalette::All), 226},
    {sipName_AlternateBase, static_cast<int>( ::QPalette::AlternateBase), 227},
    {sipName_Background, static_cast<int>( ::QPalette::Background), 227},
    {sipName_Base, static_cast<int>( ::QPalette::Base), 227},
    {sipName_BrightText, static_cast<int>( ::QPalette::BrightText), 227},
    {sipName_Button, static_cast<int>( ::QPalette::Button), 227},
    {sipName_ButtonText, static_cast<int>( ::QPalette::ButtonText), 227},
    {sipName_Current, static_cast<int>( ::QPalette::Current), 226},
    {sipName_Dark, static_cast<int>( ::QPalette::Dark), 227},
    {sipName_Disabled, static_cast<int>( ::QPalette::Disabled), 226},
    {sipName_Foreground, static_cast<int>( ::QPalette::Foreground), 227},
    {sipName_Highlight, static_cast<int>( ::QPalette::Highlight), 227},
    {sipName_HighlightedText, static_cast<int>( ::QPalette::HighlightedText), 227},
    {sipName_Inactive, static_cast<int>( ::QPalette::Inactive), 226},
    {sipName_Light, static_cast<int>( ::QPalette::Light), 227},
    {sipName_Link, static_cast<int>( ::QPalette::Link), 227},
    {sipName_LinkVisited, static_cast<int>( ::QPalette::LinkVisited), 227},
    {sipName_Mid, static_cast<int>( ::QPalette::Mid), 227},
    {sipName_Midlight, static_cast<int>( ::QPalette::Midlight), 227},
    {sipName_NColorGroups, static_cast<int>( ::QPalette::NColorGroups), 226},
    {sipName_NColorRoles, static_cast<int>( ::QPalette::NColorRoles), 227},
    {sipName_NoRole, static_cast<int>( ::QPalette::NoRole), 227},
    {sipName_Normal, static_cast<int>( ::QPalette::Normal), 226},
    {sipName_PlaceholderText, static_cast<int>( ::QPalette::PlaceholderText), 227},
    {sipName_Shadow, static_cast<int>( ::QPalette::Shadow), 227},
    {sipName_Text, static_cast<int>( ::QPalette::Text), 227},
    {sipName_ToolTipBase, static_cast<int>( ::QPalette::ToolTipBase), 227},
    {sipName_ToolTipText, static_cast<int>( ::QPalette::ToolTipText), 227},
    {sipName_Window, static_cast<int>( ::QPalette::Window), 227},
    {sipName_WindowText, static_cast<int>( ::QPalette::WindowText), 227},
};

PyDoc_STRVAR(doc_QPalette, "\1QPalette()\n"
"QPalette(Union[QColor, Qt.GlobalColor, QGradient])\n"
"QPalette(Qt.GlobalColor)\n"
"QPalette(Union[QColor, Qt.GlobalColor, QGradient], Union[QColor, Qt.GlobalColor, QGradient])\n"
"QPalette(Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient], Union[QBrush, QColor, Qt.GlobalColor, QGradient])\n"
"QPalette(QPalette)\n"
"QPalette(Any)");


static pyqt5ClassPluginDef plugin_QPalette = {
    SIP_NULLPTR,
    0,
    SIP_NULLPTR,
    SIP_NULLPTR
};


sipClassTypeDef sipTypeDef_QtGui_QPalette = {
    {
        -1,
        SIP_NULLPTR,
        SIP_NULLPTR,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QPalette,
        SIP_NULLPTR,
        &plugin_QPalette
    },
    {
        sipNameNr_QPalette,
        {0, 0, 1},
        33, methods_QPalette,
        31, enummembers_QPalette,
        0, SIP_NULLPTR,
        {SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    },
    doc_QPalette,
    -1,
    sipNameNr_sip_simplewrapper,
    SIP_NULLPTR,
    slots_QPalette,
    init_type_QPalette,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    dealloc_QPalette,
    assign_QPalette,
    array_QPalette,
    copy_QPalette,
    release_QPalette,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    array_delete_QPalette,
    sizeof ( ::QPalette),
};
