# encoding: utf-8
# module PyQt6.QtQuick
# from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\PyQt6\QtQuick.pyd
# by generator 1.147
# no doc

# imports
import PyQt6.QtCore as __PyQt6_QtCore
import PyQt6.QtGui as __PyQt6_QtGui
import PyQt6.QtQml as __PyQt6_QtQml
import PyQt6.sip as __PyQt6_sip


class QQuickItem(__PyQt6_QtCore.QObject, __PyQt6_QtQml.QQmlParserStatus):
    """ QQuickItem(parent: typing.Optional[QQuickItem] = None) """
    def acceptedMouseButtons(self): # real signature unknown; restored from __doc__
        """ acceptedMouseButtons(self) -> Qt.MouseButton """
        pass

    def acceptHoverEvents(self): # real signature unknown; restored from __doc__
        """ acceptHoverEvents(self) -> bool """
        return False

    def acceptTouchEvents(self): # real signature unknown; restored from __doc__
        """ acceptTouchEvents(self) -> bool """
        return False

    def activeFocusChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def activeFocusOnTab(self): # real signature unknown; restored from __doc__
        """ activeFocusOnTab(self) -> bool """
        return False

    def activeFocusOnTabChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def antialiasing(self): # real signature unknown; restored from __doc__
        """ antialiasing(self) -> bool """
        return False

    def antialiasingChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def baselineOffset(self): # real signature unknown; restored from __doc__
        """ baselineOffset(self) -> float """
        return 0.0

    def baselineOffsetChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def childAt(self, x, y): # real signature unknown; restored from __doc__
        """ childAt(self, x: float, y: float) -> QQuickItem """
        return QQuickItem

    def childEvent(self, *args, **kwargs): # real signature unknown
        pass

    def childItems(self): # real signature unknown; restored from __doc__
        """ childItems(self) -> List[QQuickItem] """
        return []

    def childMouseEventFilter(self, a0, a1): # real signature unknown; restored from __doc__
        """ childMouseEventFilter(self, a0: QQuickItem, a1: QEvent) -> bool """
        return False

    def childrenRect(self): # real signature unknown; restored from __doc__
        """ childrenRect(self) -> QRectF """
        pass

    def childrenRectChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def classBegin(self): # real signature unknown; restored from __doc__
        """ classBegin(self) """
        pass

    def clip(self): # real signature unknown; restored from __doc__
        """ clip(self) -> bool """
        return False

    def clipChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def componentComplete(self): # real signature unknown; restored from __doc__
        """ componentComplete(self) """
        pass

    def connectNotify(self, *args, **kwargs): # real signature unknown
        pass

    def containmentMask(self): # real signature unknown; restored from __doc__
        """ containmentMask(self) -> QObject """
        pass

    def containmentMaskChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def contains(self, point): # real signature unknown; restored from __doc__
        """ contains(self, point: QPointF) -> bool """
        return False

    def cursor(self): # real signature unknown; restored from __doc__
        """ cursor(self) -> QCursor """
        pass

    def customEvent(self, *args, **kwargs): # real signature unknown
        pass

    def disconnectNotify(self, *args, **kwargs): # real signature unknown
        pass

    def dragEnterEvent(self, a0): # real signature unknown; restored from __doc__
        """ dragEnterEvent(self, a0: QDragEnterEvent) """
        pass

    def dragLeaveEvent(self, a0): # real signature unknown; restored from __doc__
        """ dragLeaveEvent(self, a0: QDragLeaveEvent) """
        pass

    def dragMoveEvent(self, a0): # real signature unknown; restored from __doc__
        """ dragMoveEvent(self, a0: QDragMoveEvent) """
        pass

    def dropEvent(self, a0): # real signature unknown; restored from __doc__
        """ dropEvent(self, a0: QDropEvent) """
        pass

    def dumpItemTree(self): # real signature unknown; restored from __doc__
        """ dumpItemTree(self) """
        pass

    def enabledChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def ensurePolished(self): # real signature unknown; restored from __doc__
        """ ensurePolished(self) """
        pass

    def event(self, a0): # real signature unknown; restored from __doc__
        """ event(self, a0: QEvent) -> bool """
        return False

    def filtersChildMouseEvents(self): # real signature unknown; restored from __doc__
        """ filtersChildMouseEvents(self) -> bool """
        return False

    def flags(self): # real signature unknown; restored from __doc__
        """ flags(self) -> QQuickItem.Flag """
        pass

    def focusChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def focusInEvent(self, a0): # real signature unknown; restored from __doc__
        """ focusInEvent(self, a0: QFocusEvent) """
        pass

    def focusOutEvent(self, a0): # real signature unknown; restored from __doc__
        """ focusOutEvent(self, a0: QFocusEvent) """
        pass

    def forceActiveFocus(self, reason=None): # real signature unknown; restored from __doc__ with multiple overloads
        """
        forceActiveFocus(self)
        forceActiveFocus(self, reason: Qt.FocusReason)
        """
        pass

    def geometryChange(self, newGeometry, oldGeometry): # real signature unknown; restored from __doc__
        """ geometryChange(self, newGeometry: QRectF, oldGeometry: QRectF) """
        pass

    def grabMouse(self): # real signature unknown; restored from __doc__
        """ grabMouse(self) """
        pass

    def grabToImage(self, targetSize=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """ grabToImage(self, targetSize: QSize = QSize()) -> QQuickItemGrabResult """
        pass

    def grabTouchPoints(self, ids, p_int=None): # real signature unknown; restored from __doc__
        """ grabTouchPoints(self, ids: Iterable[int]) """
        pass

    def hasActiveFocus(self): # real signature unknown; restored from __doc__
        """ hasActiveFocus(self) -> bool """
        return False

    def hasFocus(self): # real signature unknown; restored from __doc__
        """ hasFocus(self) -> bool """
        return False

    def height(self): # real signature unknown; restored from __doc__
        """ height(self) -> float """
        return 0.0

    def heightChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def heightValid(self): # real signature unknown; restored from __doc__
        """ heightValid(self) -> bool """
        return False

    def hoverEnterEvent(self, event): # real signature unknown; restored from __doc__
        """ hoverEnterEvent(self, event: QHoverEvent) """
        pass

    def hoverLeaveEvent(self, event): # real signature unknown; restored from __doc__
        """ hoverLeaveEvent(self, event: QHoverEvent) """
        pass

    def hoverMoveEvent(self, event): # real signature unknown; restored from __doc__
        """ hoverMoveEvent(self, event: QHoverEvent) """
        pass

    def implicitHeight(self): # real signature unknown; restored from __doc__
        """ implicitHeight(self) -> float """
        return 0.0

    def implicitHeightChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def implicitWidth(self): # real signature unknown; restored from __doc__
        """ implicitWidth(self) -> float """
        return 0.0

    def implicitWidthChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def inputMethodEvent(self, a0): # real signature unknown; restored from __doc__
        """ inputMethodEvent(self, a0: QInputMethodEvent) """
        pass

    def inputMethodQuery(self, query): # real signature unknown; restored from __doc__
        """ inputMethodQuery(self, query: Qt.InputMethodQuery) -> Any """
        pass

    def isAncestorOf(self, child): # real signature unknown; restored from __doc__
        """ isAncestorOf(self, child: QQuickItem) -> bool """
        return False

    def isComponentComplete(self): # real signature unknown; restored from __doc__
        """ isComponentComplete(self) -> bool """
        return False

    def isEnabled(self): # real signature unknown; restored from __doc__
        """ isEnabled(self) -> bool """
        return False

    def isFocusScope(self): # real signature unknown; restored from __doc__
        """ isFocusScope(self) -> bool """
        return False

    def isSignalConnected(self, *args, **kwargs): # real signature unknown
        pass

    def isTextureProvider(self): # real signature unknown; restored from __doc__
        """ isTextureProvider(self) -> bool """
        return False

    def isVisible(self): # real signature unknown; restored from __doc__
        """ isVisible(self) -> bool """
        return False

    def itemChange(self, a0, a1): # real signature unknown; restored from __doc__
        """ itemChange(self, a0: QQuickItem.ItemChange, a1: QQuickItem.ItemChangeData) """
        pass

    def keepMouseGrab(self): # real signature unknown; restored from __doc__
        """ keepMouseGrab(self) -> bool """
        return False

    def keepTouchGrab(self): # real signature unknown; restored from __doc__
        """ keepTouchGrab(self) -> bool """
        return False

    def keyPressEvent(self, event): # real signature unknown; restored from __doc__
        """ keyPressEvent(self, event: QKeyEvent) """
        pass

    def keyReleaseEvent(self, event): # real signature unknown; restored from __doc__
        """ keyReleaseEvent(self, event: QKeyEvent) """
        pass

    def mapFromGlobal(self, point): # real signature unknown; restored from __doc__
        """ mapFromGlobal(self, point: QPointF) -> QPointF """
        pass

    def mapFromItem(self, item, point): # real signature unknown; restored from __doc__
        """ mapFromItem(self, item: QQuickItem, point: QPointF) -> QPointF """
        pass

    def mapFromScene(self, point): # real signature unknown; restored from __doc__
        """ mapFromScene(self, point: QPointF) -> QPointF """
        pass

    def mapRectFromItem(self, item, rect): # real signature unknown; restored from __doc__
        """ mapRectFromItem(self, item: QQuickItem, rect: QRectF) -> QRectF """
        pass

    def mapRectFromScene(self, rect): # real signature unknown; restored from __doc__
        """ mapRectFromScene(self, rect: QRectF) -> QRectF """
        pass

    def mapRectToItem(self, item, rect): # real signature unknown; restored from __doc__
        """ mapRectToItem(self, item: QQuickItem, rect: QRectF) -> QRectF """
        pass

    def mapRectToScene(self, rect): # real signature unknown; restored from __doc__
        """ mapRectToScene(self, rect: QRectF) -> QRectF """
        pass

    def mapToGlobal(self, point): # real signature unknown; restored from __doc__
        """ mapToGlobal(self, point: QPointF) -> QPointF """
        pass

    def mapToItem(self, item, point): # real signature unknown; restored from __doc__
        """ mapToItem(self, item: QQuickItem, point: QPointF) -> QPointF """
        pass

    def mapToScene(self, point): # real signature unknown; restored from __doc__
        """ mapToScene(self, point: QPointF) -> QPointF """
        pass

    def mouseDoubleClickEvent(self, event): # real signature unknown; restored from __doc__
        """ mouseDoubleClickEvent(self, event: QMouseEvent) """
        pass

    def mouseMoveEvent(self, event): # real signature unknown; restored from __doc__
        """ mouseMoveEvent(self, event: QMouseEvent) """
        pass

    def mousePressEvent(self, event): # real signature unknown; restored from __doc__
        """ mousePressEvent(self, event: QMouseEvent) """
        pass

    def mouseReleaseEvent(self, event): # real signature unknown; restored from __doc__
        """ mouseReleaseEvent(self, event: QMouseEvent) """
        pass

    def mouseUngrabEvent(self): # real signature unknown; restored from __doc__
        """ mouseUngrabEvent(self) """
        pass

    def nextItemInFocusChain(self, forward=True): # real signature unknown; restored from __doc__
        """ nextItemInFocusChain(self, forward: bool = True) -> QQuickItem """
        return QQuickItem

    def opacity(self): # real signature unknown; restored from __doc__
        """ opacity(self) -> float """
        return 0.0

    def opacityChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def parentChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def parentItem(self): # real signature unknown; restored from __doc__
        """ parentItem(self) -> QQuickItem """
        return QQuickItem

    def polish(self): # real signature unknown; restored from __doc__
        """ polish(self) """
        pass

    def receivers(self, *args, **kwargs): # real signature unknown
        pass

    def releaseResources(self): # real signature unknown; restored from __doc__
        """ releaseResources(self) """
        pass

    def resetAntialiasing(self): # real signature unknown; restored from __doc__
        """ resetAntialiasing(self) """
        pass

    def resetHeight(self): # real signature unknown; restored from __doc__
        """ resetHeight(self) """
        pass

    def resetWidth(self): # real signature unknown; restored from __doc__
        """ resetWidth(self) """
        pass

    def rotation(self): # real signature unknown; restored from __doc__
        """ rotation(self) -> float """
        return 0.0

    def rotationChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def scale(self): # real signature unknown; restored from __doc__
        """ scale(self) -> float """
        return 0.0

    def scaleChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def scopedFocusItem(self): # real signature unknown; restored from __doc__
        """ scopedFocusItem(self) -> QQuickItem """
        return QQuickItem

    def sender(self, *args, **kwargs): # real signature unknown
        pass

    def senderSignalIndex(self, *args, **kwargs): # real signature unknown
        pass

    def setAcceptedMouseButtons(self, buttons): # real signature unknown; restored from __doc__
        """ setAcceptedMouseButtons(self, buttons: Qt.MouseButton) """
        pass

    def setAcceptHoverEvents(self, enabled): # real signature unknown; restored from __doc__
        """ setAcceptHoverEvents(self, enabled: bool) """
        pass

    def setAcceptTouchEvents(self, accept): # real signature unknown; restored from __doc__
        """ setAcceptTouchEvents(self, accept: bool) """
        pass

    def setActiveFocusOnTab(self, a0): # real signature unknown; restored from __doc__
        """ setActiveFocusOnTab(self, a0: bool) """
        pass

    def setAntialiasing(self, a0): # real signature unknown; restored from __doc__
        """ setAntialiasing(self, a0: bool) """
        pass

    def setBaselineOffset(self, a0): # real signature unknown; restored from __doc__
        """ setBaselineOffset(self, a0: float) """
        pass

    def setClip(self, a0): # real signature unknown; restored from __doc__
        """ setClip(self, a0: bool) """
        pass

    def setContainmentMask(self, mask): # real signature unknown; restored from __doc__
        """ setContainmentMask(self, mask: QObject) """
        pass

    def setCursor(self, cursor, QCursor=None, Qt_CursorShape=None): # real signature unknown; restored from __doc__
        """ setCursor(self, cursor: Union[QCursor, Qt.CursorShape]) """
        pass

    def setEnabled(self, a0): # real signature unknown; restored from __doc__
        """ setEnabled(self, a0: bool) """
        pass

    def setFiltersChildMouseEvents(self, filter): # real signature unknown; restored from __doc__
        """ setFiltersChildMouseEvents(self, filter: bool) """
        pass

    def setFlag(self, flag, enabled=True): # real signature unknown; restored from __doc__
        """ setFlag(self, flag: QQuickItem.Flag, enabled: bool = True) """
        pass

    def setFlags(self, flags): # real signature unknown; restored from __doc__
        """ setFlags(self, flags: QQuickItem.Flag) """
        pass

    def setFocus(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        setFocus(self, a0: bool)
        setFocus(self, focus: bool, reason: Qt.FocusReason)
        """
        pass

    def setHeight(self, a0): # real signature unknown; restored from __doc__
        """ setHeight(self, a0: float) """
        pass

    def setImplicitHeight(self, a0): # real signature unknown; restored from __doc__
        """ setImplicitHeight(self, a0: float) """
        pass

    def setImplicitWidth(self, a0): # real signature unknown; restored from __doc__
        """ setImplicitWidth(self, a0: float) """
        pass

    def setKeepMouseGrab(self, a0): # real signature unknown; restored from __doc__
        """ setKeepMouseGrab(self, a0: bool) """
        pass

    def setKeepTouchGrab(self, a0): # real signature unknown; restored from __doc__
        """ setKeepTouchGrab(self, a0: bool) """
        pass

    def setOpacity(self, a0): # real signature unknown; restored from __doc__
        """ setOpacity(self, a0: float) """
        pass

    def setParentItem(self, parent): # real signature unknown; restored from __doc__
        """ setParentItem(self, parent: QQuickItem) """
        pass

    def setRotation(self, a0): # real signature unknown; restored from __doc__
        """ setRotation(self, a0: float) """
        pass

    def setScale(self, a0): # real signature unknown; restored from __doc__
        """ setScale(self, a0: float) """
        pass

    def setSize(self, size): # real signature unknown; restored from __doc__
        """ setSize(self, size: QSizeF) """
        pass

    def setSmooth(self, a0): # real signature unknown; restored from __doc__
        """ setSmooth(self, a0: bool) """
        pass

    def setState(self, a0): # real signature unknown; restored from __doc__
        """ setState(self, a0: str) """
        pass

    def setTransformOrigin(self, a0): # real signature unknown; restored from __doc__
        """ setTransformOrigin(self, a0: QQuickItem.TransformOrigin) """
        pass

    def setVisible(self, a0): # real signature unknown; restored from __doc__
        """ setVisible(self, a0: bool) """
        pass

    def setWidth(self, a0): # real signature unknown; restored from __doc__
        """ setWidth(self, a0: float) """
        pass

    def setX(self, a0): # real signature unknown; restored from __doc__
        """ setX(self, a0: float) """
        pass

    def setY(self, a0): # real signature unknown; restored from __doc__
        """ setY(self, a0: float) """
        pass

    def setZ(self, a0): # real signature unknown; restored from __doc__
        """ setZ(self, a0: float) """
        pass

    def size(self): # real signature unknown; restored from __doc__
        """ size(self) -> QSizeF """
        pass

    def smooth(self): # real signature unknown; restored from __doc__
        """ smooth(self) -> bool """
        return False

    def smoothChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def stackAfter(self, a0): # real signature unknown; restored from __doc__
        """ stackAfter(self, a0: QQuickItem) """
        pass

    def stackBefore(self, a0): # real signature unknown; restored from __doc__
        """ stackBefore(self, a0: QQuickItem) """
        pass

    def state(self): # real signature unknown; restored from __doc__
        """ state(self) -> str """
        return ""

    def stateChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def textureProvider(self): # real signature unknown; restored from __doc__
        """ textureProvider(self) -> QSGTextureProvider """
        return QSGTextureProvider

    def timerEvent(self, *args, **kwargs): # real signature unknown
        pass

    def touchEvent(self, event): # real signature unknown; restored from __doc__
        """ touchEvent(self, event: QTouchEvent) """
        pass

    def touchUngrabEvent(self): # real signature unknown; restored from __doc__
        """ touchUngrabEvent(self) """
        pass

    def transformOrigin(self): # real signature unknown; restored from __doc__
        """ transformOrigin(self) -> QQuickItem.TransformOrigin """
        pass

    def transformOriginChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def ungrabMouse(self): # real signature unknown; restored from __doc__
        """ ungrabMouse(self) """
        pass

    def ungrabTouchPoints(self): # real signature unknown; restored from __doc__
        """ ungrabTouchPoints(self) """
        pass

    def unsetCursor(self): # real signature unknown; restored from __doc__
        """ unsetCursor(self) """
        pass

    def update(self): # real signature unknown; restored from __doc__
        """ update(self) """
        pass

    def updateInputMethod(self, queries=None): # real signature unknown; restored from __doc__
        """ updateInputMethod(self, queries: Qt.InputMethodQuery = Qt.ImQueryInput) """
        pass

    def updatePaintNode(self, a0, a1): # real signature unknown; restored from __doc__
        """ updatePaintNode(self, a0: QSGNode, a1: QQuickItem.UpdatePaintNodeData) -> QSGNode """
        return QSGNode

    def updatePolish(self): # real signature unknown; restored from __doc__
        """ updatePolish(self) """
        pass

    def viewportItem(self): # real signature unknown; restored from __doc__
        """ viewportItem(self) -> QQuickItem """
        return QQuickItem

    def visibleChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def wheelEvent(self, event): # real signature unknown; restored from __doc__
        """ wheelEvent(self, event: QWheelEvent) """
        pass

    def width(self): # real signature unknown; restored from __doc__
        """ width(self) -> float """
        return 0.0

    def widthChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def widthValid(self): # real signature unknown; restored from __doc__
        """ widthValid(self) -> bool """
        return False

    def window(self): # real signature unknown; restored from __doc__
        """ window(self) -> QQuickWindow """
        return QQuickWindow

    def windowChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def x(self): # real signature unknown; restored from __doc__
        """ x(self) -> float """
        return 0.0

    def xChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def y(self): # real signature unknown; restored from __doc__
        """ y(self) -> float """
        return 0.0

    def yChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def z(self): # real signature unknown; restored from __doc__
        """ z(self) -> float """
        return 0.0

    def zChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def __init__(self, parent, QQuickItem=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    Flag = None # (!) real value is "<flag 'Flag'>"
    ItemChange = None # (!) real value is "<enum 'ItemChange'>"
    ItemChangeData = None # (!) real value is "<class 'PyQt6.QtQuick.QQuickItem.ItemChangeData'>"
    TransformOrigin = None # (!) real value is "<enum 'TransformOrigin'>"
    UpdatePaintNodeData = None # (!) real value is "<class 'PyQt6.QtQuick.QQuickItem.UpdatePaintNodeData'>"