# This Python file uses the following encoding: utf-8
#############################################################################
##
## Copyright (C) 2019 The Qt Company Ltd.
## Contact: https://www.qt.io/licensing/
##
## This file is part of Qt for Python.
##
## $QT_BEGIN_LICENSE:LGPL$
## Commercial License Usage
## Licensees holding valid commercial Qt licenses may use this file in
## accordance with the commercial license agreement provided with the
## Software or, alternatively, in accordance with the terms contained in
## a written agreement between you and The Qt Company. For licensing terms
## and conditions see https://www.qt.io/terms-conditions. For further
## information use the contact form at https://www.qt.io/contact-us.
##
## GNU Lesser General Public License Usage
## Alternatively, this file may be used under the terms of the GNU Lesser
## General Public License version 3 as published by the Free Software
## Foundation and appearing in the file LICENSE.LGPL3 included in the
## packaging of this file. Please review the following information to
## ensure the GNU Lesser General Public License version 3 requirements
## will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
##
## GNU General Public License Usage
## Alternatively, this file may be used under the terms of the GNU
## General Public License version 2.0 or (at your option) the GNU General
## Public license version 3 or any later version approved by the KDE Free
## Qt Foundation. The licenses are as published by the Free Software
## Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
## included in the packaging of this file. Please review the following
## information to ensure the GNU General Public License requirements will
## be met: https://www.gnu.org/licenses/gpl-2.0.html and
## https://www.gnu.org/licenses/gpl-3.0.html.
##
## $QT_END_LICENSE$
##
#############################################################################

from __future__ import annotations

"""
This file contains the exact signatures for all functions in module
PySide2.QtMultimedia, except for defaults which are replaced by "...".
"""

# Module PySide2.QtMultimedia
import PySide2
from PySide2.support.signature import typing
from PySide2.support.signature.mapping import (
    Virtual, Missing, Invalid, Default, Instance)

class Object(object): pass

import shiboken2 as Shiboken
Shiboken.Object = Object

import PySide2.QtMultimedia


class QAbstractAudioDeviceInfo(PySide2.QtCore.QObject):

    def __init__(self): ...

    def deviceName(self) -> str: ...
    def isFormatSupported(self, format: PySide2.QtMultimedia.QAudioFormat) -> bool: ...
    def preferredFormat(self) -> PySide2.QtMultimedia.QAudioFormat: ...
    def supportedByteOrders(self) -> typing.List[PySide2.QtMultimedia.QAudioFormat.Endian]: ...
    def supportedChannelCounts(self) -> typing.List[int]: ...
    def supportedCodecs(self) -> typing.List[str]: ...
    def supportedSampleRates(self) -> typing.List[int]: ...
    def supportedSampleSizes(self) -> typing.List[int]: ...
    def supportedSampleTypes(self) -> typing.List[PySide2.QtMultimedia.QAudioFormat.SampleType]: ...


class QAbstractAudioInput(PySide2.QtCore.QObject):

    def __init__(self): ...

    def bufferSize(self) -> int: ...
    def bytesReady(self) -> int: ...
    def elapsedUSecs(self) -> int: ...
    def error(self) -> PySide2.QtMultimedia.QAudio.Error: ...
    def format(self) -> PySide2.QtMultimedia.QAudioFormat: ...
    def notifyInterval(self) -> int: ...
    def periodSize(self) -> int: ...
    def processedUSecs(self) -> int: ...
    def reset(self): ...
    def resume(self): ...
    def setBufferSize(self, value: int): ...
    def setFormat(self, fmt: PySide2.QtMultimedia.QAudioFormat): ...
    def setNotifyInterval(self, milliSeconds: int): ...
    def setVolume(self, arg__1: float): ...
    @typing.overload
    def start(self) -> PySide2.QtCore.QIODevice: ...
    @typing.overload
    def start(self, device: PySide2.QtCore.QIODevice): ...
    def state(self) -> PySide2.QtMultimedia.QAudio.State: ...
    def stop(self): ...
    def suspend(self): ...
    def volume(self) -> float: ...


class QAbstractAudioOutput(PySide2.QtCore.QObject):

    def __init__(self): ...

    def bufferSize(self) -> int: ...
    def bytesFree(self) -> int: ...
    def category(self) -> str: ...
    def elapsedUSecs(self) -> int: ...
    def error(self) -> PySide2.QtMultimedia.QAudio.Error: ...
    def format(self) -> PySide2.QtMultimedia.QAudioFormat: ...
    def notifyInterval(self) -> int: ...
    def periodSize(self) -> int: ...
    def processedUSecs(self) -> int: ...
    def reset(self): ...
    def resume(self): ...
    def setBufferSize(self, value: int): ...
    def setCategory(self, arg__1: str): ...
    def setFormat(self, fmt: PySide2.QtMultimedia.QAudioFormat): ...
    def setNotifyInterval(self, milliSeconds: int): ...
    def setVolume(self, arg__1: float): ...
    @typing.overload
    def start(self) -> PySide2.QtCore.QIODevice: ...
    @typing.overload
    def start(self, device: PySide2.QtCore.QIODevice): ...
    def state(self) -> PySide2.QtMultimedia.QAudio.State: ...
    def stop(self): ...
    def suspend(self): ...
    def volume(self) -> float: ...


class QAbstractVideoBuffer(Shiboken.Object):
    NoHandle                 : QAbstractVideoBuffer = ... # 0x0
    NotMapped                : QAbstractVideoBuffer = ... # 0x0
    GLTextureHandle          : QAbstractVideoBuffer = ... # 0x1
    ReadOnly                 : QAbstractVideoBuffer = ... # 0x1
    WriteOnly                : QAbstractVideoBuffer = ... # 0x2
    XvShmImageHandle         : QAbstractVideoBuffer = ... # 0x2
    CoreImageHandle          : QAbstractVideoBuffer = ... # 0x3
    ReadWrite                : QAbstractVideoBuffer = ... # 0x3
    QPixmapHandle            : QAbstractVideoBuffer = ... # 0x4
    EGLImageHandle           : QAbstractVideoBuffer = ... # 0x5
    UserHandle               : QAbstractVideoBuffer = ... # 0x3e8

    class HandleType(object):
        NoHandle                 : QAbstractVideoBuffer.HandleType = ... # 0x0
        GLTextureHandle          : QAbstractVideoBuffer.HandleType = ... # 0x1
        XvShmImageHandle         : QAbstractVideoBuffer.HandleType = ... # 0x2
        CoreImageHandle          : QAbstractVideoBuffer.HandleType = ... # 0x3
        QPixmapHandle            : QAbstractVideoBuffer.HandleType = ... # 0x4
        EGLImageHandle           : QAbstractVideoBuffer.HandleType = ... # 0x5
        UserHandle               : QAbstractVideoBuffer.HandleType = ... # 0x3e8

    class MapMode(object):
        NotMapped                : QAbstractVideoBuffer.MapMode = ... # 0x0
        ReadOnly                 : QAbstractVideoBuffer.MapMode = ... # 0x1
        WriteOnly                : QAbstractVideoBuffer.MapMode = ... # 0x2
        ReadWrite                : QAbstractVideoBuffer.MapMode = ... # 0x3

    def __init__(self, type: PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType): ...

    def handle(self) -> typing.Any: ...
    def handleType(self) -> PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType: ...
    def mapMode(self) -> PySide2.QtMultimedia.QAbstractVideoBuffer.MapMode: ...
    def release(self): ...
    def unmap(self): ...


class QAbstractVideoFilter(PySide2.QtCore.QObject):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def createFilterRunnable(self) -> PySide2.QtMultimedia.QVideoFilterRunnable: ...
    def isActive(self) -> bool: ...
    def setActive(self, v: bool): ...


class QAbstractVideoSurface(PySide2.QtCore.QObject):
    NoError                  : QAbstractVideoSurface = ... # 0x0
    UnsupportedFormatError   : QAbstractVideoSurface = ... # 0x1
    IncorrectFormatError     : QAbstractVideoSurface = ... # 0x2
    StoppedError             : QAbstractVideoSurface = ... # 0x3
    ResourceError            : QAbstractVideoSurface = ... # 0x4

    class Error(object):
        NoError                  : QAbstractVideoSurface.Error = ... # 0x0
        UnsupportedFormatError   : QAbstractVideoSurface.Error = ... # 0x1
        IncorrectFormatError     : QAbstractVideoSurface.Error = ... # 0x2
        StoppedError             : QAbstractVideoSurface.Error = ... # 0x3
        ResourceError            : QAbstractVideoSurface.Error = ... # 0x4

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def error(self) -> PySide2.QtMultimedia.QAbstractVideoSurface.Error: ...
    def isActive(self) -> bool: ...
    def isFormatSupported(self, format: PySide2.QtMultimedia.QVideoSurfaceFormat) -> bool: ...
    def nativeResolution(self) -> PySide2.QtCore.QSize: ...
    def nearestFormat(self, format: PySide2.QtMultimedia.QVideoSurfaceFormat) -> PySide2.QtMultimedia.QVideoSurfaceFormat: ...
    def present(self, frame: PySide2.QtMultimedia.QVideoFrame) -> bool: ...
    def setError(self, error: PySide2.QtMultimedia.QAbstractVideoSurface.Error): ...
    def setNativeResolution(self, resolution: PySide2.QtCore.QSize): ...
    def start(self, format: PySide2.QtMultimedia.QVideoSurfaceFormat) -> bool: ...
    def stop(self): ...
    def supportedPixelFormats(self, type: PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType = ...) -> typing.List[PySide2.QtMultimedia.QVideoFrame.PixelFormat]: ...
    def surfaceFormat(self) -> PySide2.QtMultimedia.QVideoSurfaceFormat: ...


class QAudio(Shiboken.Object):
    ActiveState              : QAudio = ... # 0x0
    AudioInput               : QAudio = ... # 0x0
    LinearVolumeScale        : QAudio = ... # 0x0
    NoError                  : QAudio = ... # 0x0
    UnknownRole              : QAudio = ... # 0x0
    AudioOutput              : QAudio = ... # 0x1
    CubicVolumeScale         : QAudio = ... # 0x1
    MusicRole                : QAudio = ... # 0x1
    OpenError                : QAudio = ... # 0x1
    SuspendedState           : QAudio = ... # 0x1
    IOError                  : QAudio = ... # 0x2
    LogarithmicVolumeScale   : QAudio = ... # 0x2
    StoppedState             : QAudio = ... # 0x2
    VideoRole                : QAudio = ... # 0x2
    DecibelVolumeScale       : QAudio = ... # 0x3
    IdleState                : QAudio = ... # 0x3
    UnderrunError            : QAudio = ... # 0x3
    VoiceCommunicationRole   : QAudio = ... # 0x3
    AlarmRole                : QAudio = ... # 0x4
    FatalError               : QAudio = ... # 0x4
    InterruptedState         : QAudio = ... # 0x4
    NotificationRole         : QAudio = ... # 0x5
    RingtoneRole             : QAudio = ... # 0x6
    AccessibilityRole        : QAudio = ... # 0x7
    SonificationRole         : QAudio = ... # 0x8
    GameRole                 : QAudio = ... # 0x9
    CustomRole               : QAudio = ... # 0xa

    class Error(object):
        NoError                  : QAudio.Error = ... # 0x0
        OpenError                : QAudio.Error = ... # 0x1
        IOError                  : QAudio.Error = ... # 0x2
        UnderrunError            : QAudio.Error = ... # 0x3
        FatalError               : QAudio.Error = ... # 0x4

    class Mode(object):
        AudioInput               : QAudio.Mode = ... # 0x0
        AudioOutput              : QAudio.Mode = ... # 0x1

    class Role(object):
        UnknownRole              : QAudio.Role = ... # 0x0
        MusicRole                : QAudio.Role = ... # 0x1
        VideoRole                : QAudio.Role = ... # 0x2
        VoiceCommunicationRole   : QAudio.Role = ... # 0x3
        AlarmRole                : QAudio.Role = ... # 0x4
        NotificationRole         : QAudio.Role = ... # 0x5
        RingtoneRole             : QAudio.Role = ... # 0x6
        AccessibilityRole        : QAudio.Role = ... # 0x7
        SonificationRole         : QAudio.Role = ... # 0x8
        GameRole                 : QAudio.Role = ... # 0x9
        CustomRole               : QAudio.Role = ... # 0xa

    class State(object):
        ActiveState              : QAudio.State = ... # 0x0
        SuspendedState           : QAudio.State = ... # 0x1
        StoppedState             : QAudio.State = ... # 0x2
        IdleState                : QAudio.State = ... # 0x3
        InterruptedState         : QAudio.State = ... # 0x4

    class VolumeScale(object):
        LinearVolumeScale        : QAudio.VolumeScale = ... # 0x0
        CubicVolumeScale         : QAudio.VolumeScale = ... # 0x1
        LogarithmicVolumeScale   : QAudio.VolumeScale = ... # 0x2
        DecibelVolumeScale       : QAudio.VolumeScale = ... # 0x3
    @staticmethod
    def convertVolume(volume: float, from_: PySide2.QtMultimedia.QAudio.VolumeScale, to: PySide2.QtMultimedia.QAudio.VolumeScale) -> float: ...


class QAudioBuffer(Shiboken.Object):

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, data: PySide2.QtCore.QByteArray, format: PySide2.QtMultimedia.QAudioFormat, startTime: int = ...): ...
    @typing.overload
    def __init__(self, numFrames: int, format: PySide2.QtMultimedia.QAudioFormat, startTime: int = ...): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QAudioBuffer): ...

    def __copy__(self): ...
    def byteCount(self) -> int: ...
    def constData(self) -> int: ...
    def data(self) -> int: ...
    def duration(self) -> int: ...
    def format(self) -> PySide2.QtMultimedia.QAudioFormat: ...
    def frameCount(self) -> int: ...
    def isValid(self) -> bool: ...
    def sampleCount(self) -> int: ...
    def startTime(self) -> int: ...


class QAudioDecoder(PySide2.QtMultimedia.QMediaObject):
    NoError                  : QAudioDecoder = ... # 0x0
    StoppedState             : QAudioDecoder = ... # 0x0
    DecodingState            : QAudioDecoder = ... # 0x1
    ResourceError            : QAudioDecoder = ... # 0x1
    FormatError              : QAudioDecoder = ... # 0x2
    AccessDeniedError        : QAudioDecoder = ... # 0x3
    ServiceMissingError      : QAudioDecoder = ... # 0x4

    class Error(object):
        NoError                  : QAudioDecoder.Error = ... # 0x0
        ResourceError            : QAudioDecoder.Error = ... # 0x1
        FormatError              : QAudioDecoder.Error = ... # 0x2
        AccessDeniedError        : QAudioDecoder.Error = ... # 0x3
        ServiceMissingError      : QAudioDecoder.Error = ... # 0x4

    class State(object):
        StoppedState             : QAudioDecoder.State = ... # 0x0
        DecodingState            : QAudioDecoder.State = ... # 0x1

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def audioFormat(self) -> PySide2.QtMultimedia.QAudioFormat: ...
    def bind(self, arg__1: PySide2.QtCore.QObject) -> bool: ...
    def bufferAvailable(self) -> bool: ...
    def duration(self) -> int: ...
    def error(self) -> PySide2.QtMultimedia.QAudioDecoder.Error: ...
    def errorString(self) -> str: ...
    @staticmethod
    def hasSupport(mimeType: str, codecs: typing.Sequence[str] = ...) -> PySide2.QtMultimedia.QMultimedia.SupportEstimate: ...
    def position(self) -> int: ...
    def read(self) -> PySide2.QtMultimedia.QAudioBuffer: ...
    def setAudioFormat(self, format: PySide2.QtMultimedia.QAudioFormat): ...
    def setSourceDevice(self, device: PySide2.QtCore.QIODevice): ...
    def setSourceFilename(self, fileName: str): ...
    def sourceDevice(self) -> PySide2.QtCore.QIODevice: ...
    def sourceFilename(self) -> str: ...
    def start(self): ...
    def state(self) -> PySide2.QtMultimedia.QAudioDecoder.State: ...
    def stop(self): ...
    def unbind(self, arg__1: PySide2.QtCore.QObject): ...


class QAudioDecoderControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def audioFormat(self) -> PySide2.QtMultimedia.QAudioFormat: ...
    def bufferAvailable(self) -> bool: ...
    def duration(self) -> int: ...
    def position(self) -> int: ...
    def read(self) -> PySide2.QtMultimedia.QAudioBuffer: ...
    def setAudioFormat(self, format: PySide2.QtMultimedia.QAudioFormat): ...
    def setSourceDevice(self, device: PySide2.QtCore.QIODevice): ...
    def setSourceFilename(self, fileName: str): ...
    def sourceDevice(self) -> PySide2.QtCore.QIODevice: ...
    def sourceFilename(self) -> str: ...
    def start(self): ...
    def state(self) -> PySide2.QtMultimedia.QAudioDecoder.State: ...
    def stop(self): ...


class QAudioDeviceInfo(Shiboken.Object):

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QAudioDeviceInfo): ...

    def __copy__(self): ...
    @staticmethod
    def availableDevices(mode: PySide2.QtMultimedia.QAudio.Mode) -> typing.List[PySide2.QtMultimedia.QAudioDeviceInfo]: ...
    @staticmethod
    def defaultInputDevice() -> PySide2.QtMultimedia.QAudioDeviceInfo: ...
    @staticmethod
    def defaultOutputDevice() -> PySide2.QtMultimedia.QAudioDeviceInfo: ...
    def deviceName(self) -> str: ...
    def isFormatSupported(self, format: PySide2.QtMultimedia.QAudioFormat) -> bool: ...
    def isNull(self) -> bool: ...
    def nearestFormat(self, format: PySide2.QtMultimedia.QAudioFormat) -> PySide2.QtMultimedia.QAudioFormat: ...
    def preferredFormat(self) -> PySide2.QtMultimedia.QAudioFormat: ...
    def realm(self) -> str: ...
    def supportedByteOrders(self) -> typing.List[PySide2.QtMultimedia.QAudioFormat.Endian]: ...
    def supportedChannelCounts(self) -> typing.List[int]: ...
    def supportedCodecs(self) -> typing.List[str]: ...
    def supportedSampleRates(self) -> typing.List[int]: ...
    def supportedSampleSizes(self) -> typing.List[int]: ...
    def supportedSampleTypes(self) -> typing.List[PySide2.QtMultimedia.QAudioFormat.SampleType]: ...


class QAudioEncoderSettings(Shiboken.Object):

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QAudioEncoderSettings): ...

    def __copy__(self): ...
    def bitRate(self) -> int: ...
    def channelCount(self) -> int: ...
    def codec(self) -> str: ...
    def encodingMode(self) -> PySide2.QtMultimedia.QMultimedia.EncodingMode: ...
    def encodingOption(self, option: str) -> typing.Any: ...
    def encodingOptions(self) -> typing.Dict[str, typing.Any]: ...
    def isNull(self) -> bool: ...
    def quality(self) -> PySide2.QtMultimedia.QMultimedia.EncodingQuality: ...
    def sampleRate(self) -> int: ...
    def setBitRate(self, bitrate: int): ...
    def setChannelCount(self, channels: int): ...
    def setCodec(self, codec: str): ...
    def setEncodingMode(self, arg__1: PySide2.QtMultimedia.QMultimedia.EncodingMode): ...
    def setEncodingOption(self, option: str, value: typing.Any): ...
    def setEncodingOptions(self, options: typing.Dict[str, typing.Any]): ...
    def setQuality(self, quality: PySide2.QtMultimedia.QMultimedia.EncodingQuality): ...
    def setSampleRate(self, rate: int): ...


class QAudioEncoderSettingsControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def audioSettings(self) -> PySide2.QtMultimedia.QAudioEncoderSettings: ...
    def codecDescription(self, codecName: str) -> str: ...
    def setAudioSettings(self, settings: PySide2.QtMultimedia.QAudioEncoderSettings): ...
    def supportedAudioCodecs(self) -> typing.List[str]: ...


class QAudioFormat(Shiboken.Object):
    BigEndian                : QAudioFormat = ... # 0x0
    Unknown                  : QAudioFormat = ... # 0x0
    LittleEndian             : QAudioFormat = ... # 0x1
    SignedInt                : QAudioFormat = ... # 0x1
    UnSignedInt              : QAudioFormat = ... # 0x2
    Float                    : QAudioFormat = ... # 0x3

    class Endian(object):
        BigEndian                : QAudioFormat.Endian = ... # 0x0
        LittleEndian             : QAudioFormat.Endian = ... # 0x1

    class SampleType(object):
        Unknown                  : QAudioFormat.SampleType = ... # 0x0
        SignedInt                : QAudioFormat.SampleType = ... # 0x1
        UnSignedInt              : QAudioFormat.SampleType = ... # 0x2
        Float                    : QAudioFormat.SampleType = ... # 0x3

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QAudioFormat): ...

    def __copy__(self): ...
    def byteOrder(self) -> PySide2.QtMultimedia.QAudioFormat.Endian: ...
    def bytesForDuration(self, duration: int) -> int: ...
    def bytesForFrames(self, frameCount: int) -> int: ...
    def bytesPerFrame(self) -> int: ...
    def channelCount(self) -> int: ...
    def codec(self) -> str: ...
    def durationForBytes(self, byteCount: int) -> int: ...
    def durationForFrames(self, frameCount: int) -> int: ...
    def framesForBytes(self, byteCount: int) -> int: ...
    def framesForDuration(self, duration: int) -> int: ...
    def isValid(self) -> bool: ...
    def sampleRate(self) -> int: ...
    def sampleSize(self) -> int: ...
    def sampleType(self) -> PySide2.QtMultimedia.QAudioFormat.SampleType: ...
    def setByteOrder(self, byteOrder: PySide2.QtMultimedia.QAudioFormat.Endian): ...
    def setChannelCount(self, channelCount: int): ...
    def setCodec(self, codec: str): ...
    def setSampleRate(self, sampleRate: int): ...
    def setSampleSize(self, sampleSize: int): ...
    def setSampleType(self, sampleType: PySide2.QtMultimedia.QAudioFormat.SampleType): ...


class QAudioInput(PySide2.QtCore.QObject):

    @typing.overload
    def __init__(self, audioDeviceInfo: PySide2.QtMultimedia.QAudioDeviceInfo, format: PySide2.QtMultimedia.QAudioFormat = ..., parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...
    @typing.overload
    def __init__(self, format: PySide2.QtMultimedia.QAudioFormat = ..., parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def bufferSize(self) -> int: ...
    def bytesReady(self) -> int: ...
    def elapsedUSecs(self) -> int: ...
    def error(self) -> PySide2.QtMultimedia.QAudio.Error: ...
    def format(self) -> PySide2.QtMultimedia.QAudioFormat: ...
    def notifyInterval(self) -> int: ...
    def periodSize(self) -> int: ...
    def processedUSecs(self) -> int: ...
    def reset(self): ...
    def resume(self): ...
    def setBufferSize(self, bytes: int): ...
    def setNotifyInterval(self, milliSeconds: int): ...
    def setVolume(self, volume: float): ...
    @typing.overload
    def start(self) -> PySide2.QtCore.QIODevice: ...
    @typing.overload
    def start(self, device: PySide2.QtCore.QIODevice): ...
    def state(self) -> PySide2.QtMultimedia.QAudio.State: ...
    def stop(self): ...
    def suspend(self): ...
    def volume(self) -> float: ...


class QAudioInputSelectorControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def activeInput(self) -> str: ...
    def availableInputs(self) -> typing.List[str]: ...
    def defaultInput(self) -> str: ...
    def inputDescription(self, name: str) -> str: ...
    def setActiveInput(self, name: str): ...


class QAudioOutput(PySide2.QtCore.QObject):

    @typing.overload
    def __init__(self, audioDeviceInfo: PySide2.QtMultimedia.QAudioDeviceInfo, format: PySide2.QtMultimedia.QAudioFormat = ..., parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...
    @typing.overload
    def __init__(self, format: PySide2.QtMultimedia.QAudioFormat = ..., parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def bufferSize(self) -> int: ...
    def bytesFree(self) -> int: ...
    def category(self) -> str: ...
    def elapsedUSecs(self) -> int: ...
    def error(self) -> PySide2.QtMultimedia.QAudio.Error: ...
    def format(self) -> PySide2.QtMultimedia.QAudioFormat: ...
    def notifyInterval(self) -> int: ...
    def periodSize(self) -> int: ...
    def processedUSecs(self) -> int: ...
    def reset(self): ...
    def resume(self): ...
    def setBufferSize(self, bytes: int): ...
    def setCategory(self, category: str): ...
    def setNotifyInterval(self, milliSeconds: int): ...
    def setVolume(self, arg__1: float): ...
    @typing.overload
    def start(self) -> PySide2.QtCore.QIODevice: ...
    @typing.overload
    def start(self, device: PySide2.QtCore.QIODevice): ...
    def state(self) -> PySide2.QtMultimedia.QAudio.State: ...
    def stop(self): ...
    def suspend(self): ...
    def volume(self) -> float: ...


class QAudioOutputSelectorControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def activeOutput(self) -> str: ...
    def availableOutputs(self) -> typing.List[str]: ...
    def defaultOutput(self) -> str: ...
    def outputDescription(self, name: str) -> str: ...
    def setActiveOutput(self, name: str): ...


class QAudioProbe(PySide2.QtCore.QObject):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def isActive(self) -> bool: ...
    @typing.overload
    def setSource(self, source: PySide2.QtMultimedia.QMediaObject) -> bool: ...
    @typing.overload
    def setSource(self, source: PySide2.QtMultimedia.QMediaRecorder) -> bool: ...


class QAudioRecorder(PySide2.QtMultimedia.QMediaRecorder):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def audioInput(self) -> str: ...
    def audioInputDescription(self, name: str) -> str: ...
    def audioInputs(self) -> typing.List[str]: ...
    def defaultAudioInput(self) -> str: ...
    def setAudioInput(self, name: str): ...


class QAudioRoleControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def audioRole(self) -> PySide2.QtMultimedia.QAudio.Role: ...
    def setAudioRole(self, role: PySide2.QtMultimedia.QAudio.Role): ...
    def supportedAudioRoles(self) -> typing.List[PySide2.QtMultimedia.QAudio.Role]: ...


class QCamera(PySide2.QtMultimedia.QMediaObject):
    CaptureViewfinder        : QCamera = ... # 0x0
    NoError                  : QCamera = ... # 0x0
    NoLock                   : QCamera = ... # 0x0
    UnavailableStatus        : QCamera = ... # 0x0
    UnloadedState            : QCamera = ... # 0x0
    Unlocked                 : QCamera = ... # 0x0
    UnspecifiedPosition      : QCamera = ... # 0x0
    UserRequest              : QCamera = ... # 0x0
    BackFace                 : QCamera = ... # 0x1
    CameraError              : QCamera = ... # 0x1
    CaptureStillImage        : QCamera = ... # 0x1
    LoadedState              : QCamera = ... # 0x1
    LockAcquired             : QCamera = ... # 0x1
    LockExposure             : QCamera = ... # 0x1
    Searching                : QCamera = ... # 0x1
    UnloadedStatus           : QCamera = ... # 0x1
    ActiveState              : QCamera = ... # 0x2
    CaptureVideo             : QCamera = ... # 0x2
    FrontFace                : QCamera = ... # 0x2
    InvalidRequestError      : QCamera = ... # 0x2
    LoadingStatus            : QCamera = ... # 0x2
    LockFailed               : QCamera = ... # 0x2
    LockWhiteBalance         : QCamera = ... # 0x2
    Locked                   : QCamera = ... # 0x2
    LockLost                 : QCamera = ... # 0x3
    ServiceMissingError      : QCamera = ... # 0x3
    UnloadingStatus          : QCamera = ... # 0x3
    LoadedStatus             : QCamera = ... # 0x4
    LockFocus                : QCamera = ... # 0x4
    LockTemporaryLost        : QCamera = ... # 0x4
    NotSupportedFeatureError : QCamera = ... # 0x4
    StandbyStatus            : QCamera = ... # 0x5
    StartingStatus           : QCamera = ... # 0x6
    StoppingStatus           : QCamera = ... # 0x7
    ActiveStatus             : QCamera = ... # 0x8

    class CaptureMode(object):
        CaptureViewfinder        : QCamera.CaptureMode = ... # 0x0
        CaptureStillImage        : QCamera.CaptureMode = ... # 0x1
        CaptureVideo             : QCamera.CaptureMode = ... # 0x2

    class CaptureModes(object): ...

    class Error(object):
        NoError                  : QCamera.Error = ... # 0x0
        CameraError              : QCamera.Error = ... # 0x1
        InvalidRequestError      : QCamera.Error = ... # 0x2
        ServiceMissingError      : QCamera.Error = ... # 0x3
        NotSupportedFeatureError : QCamera.Error = ... # 0x4

    class FrameRateRange(Shiboken.Object):

        @typing.overload
        def __init__(self): ...
        @typing.overload
        def __init__(self, FrameRateRange: PySide2.QtMultimedia.QCamera.FrameRateRange): ...
        @typing.overload
        def __init__(self, minimum: float, maximum: float): ...

        def __copy__(self): ...

    class LockChangeReason(object):
        UserRequest              : QCamera.LockChangeReason = ... # 0x0
        LockAcquired             : QCamera.LockChangeReason = ... # 0x1
        LockFailed               : QCamera.LockChangeReason = ... # 0x2
        LockLost                 : QCamera.LockChangeReason = ... # 0x3
        LockTemporaryLost        : QCamera.LockChangeReason = ... # 0x4

    class LockStatus(object):
        Unlocked                 : QCamera.LockStatus = ... # 0x0
        Searching                : QCamera.LockStatus = ... # 0x1
        Locked                   : QCamera.LockStatus = ... # 0x2

    class LockType(object):
        NoLock                   : QCamera.LockType = ... # 0x0
        LockExposure             : QCamera.LockType = ... # 0x1
        LockWhiteBalance         : QCamera.LockType = ... # 0x2
        LockFocus                : QCamera.LockType = ... # 0x4

    class LockTypes(object): ...

    class Position(object):
        UnspecifiedPosition      : QCamera.Position = ... # 0x0
        BackFace                 : QCamera.Position = ... # 0x1
        FrontFace                : QCamera.Position = ... # 0x2

    class State(object):
        UnloadedState            : QCamera.State = ... # 0x0
        LoadedState              : QCamera.State = ... # 0x1
        ActiveState              : QCamera.State = ... # 0x2

    class Status(object):
        UnavailableStatus        : QCamera.Status = ... # 0x0
        UnloadedStatus           : QCamera.Status = ... # 0x1
        LoadingStatus            : QCamera.Status = ... # 0x2
        UnloadingStatus          : QCamera.Status = ... # 0x3
        LoadedStatus             : QCamera.Status = ... # 0x4
        StandbyStatus            : QCamera.Status = ... # 0x5
        StartingStatus           : QCamera.Status = ... # 0x6
        StoppingStatus           : QCamera.Status = ... # 0x7
        ActiveStatus             : QCamera.Status = ... # 0x8

    @typing.overload
    def __init__(self, cameraInfo: PySide2.QtMultimedia.QCameraInfo, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...
    @typing.overload
    def __init__(self, deviceName: PySide2.QtCore.QByteArray, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...
    @typing.overload
    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...
    @typing.overload
    def __init__(self, position: PySide2.QtMultimedia.QCamera.Position, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def availability(self) -> PySide2.QtMultimedia.QMultimedia.AvailabilityStatus: ...
    @staticmethod
    def availableDevices() -> typing.List[PySide2.QtCore.QByteArray]: ...
    def captureMode(self) -> PySide2.QtMultimedia.QCamera.CaptureModes: ...
    @staticmethod
    def deviceDescription(device: PySide2.QtCore.QByteArray) -> str: ...
    def error(self) -> PySide2.QtMultimedia.QCamera.Error: ...
    def errorString(self) -> str: ...
    def exposure(self) -> PySide2.QtMultimedia.QCameraExposure: ...
    def focus(self) -> PySide2.QtMultimedia.QCameraFocus: ...
    def imageProcessing(self) -> PySide2.QtMultimedia.QCameraImageProcessing: ...
    def isCaptureModeSupported(self, mode: PySide2.QtMultimedia.QCamera.CaptureModes) -> bool: ...
    def load(self): ...
    @typing.overload
    def lockStatus(self) -> PySide2.QtMultimedia.QCamera.LockStatus: ...
    @typing.overload
    def lockStatus(self, lock: PySide2.QtMultimedia.QCamera.LockType) -> PySide2.QtMultimedia.QCamera.LockStatus: ...
    def requestedLocks(self) -> PySide2.QtMultimedia.QCamera.LockTypes: ...
    @typing.overload
    def searchAndLock(self): ...
    @typing.overload
    def searchAndLock(self, locks: PySide2.QtMultimedia.QCamera.LockTypes): ...
    def setCaptureMode(self, mode: PySide2.QtMultimedia.QCamera.CaptureModes): ...
    @typing.overload
    def setViewfinder(self, surface: PySide2.QtMultimedia.QAbstractVideoSurface): ...
    @typing.overload
    def setViewfinder(self, viewfinder: PySide2.QtMultimediaWidgets.QGraphicsVideoItem): ...
    @typing.overload
    def setViewfinder(self, viewfinder: PySide2.QtMultimediaWidgets.QVideoWidget): ...
    def setViewfinderSettings(self, settings: PySide2.QtMultimedia.QCameraViewfinderSettings): ...
    def start(self): ...
    def state(self) -> PySide2.QtMultimedia.QCamera.State: ...
    def status(self) -> PySide2.QtMultimedia.QCamera.Status: ...
    def stop(self): ...
    def supportedLocks(self) -> PySide2.QtMultimedia.QCamera.LockTypes: ...
    def supportedViewfinderFrameRateRanges(self, settings: PySide2.QtMultimedia.QCameraViewfinderSettings = ...) -> typing.List[PySide2.QtMultimedia.QCamera.FrameRateRange]: ...
    def supportedViewfinderPixelFormats(self, settings: PySide2.QtMultimedia.QCameraViewfinderSettings = ...) -> typing.List[PySide2.QtMultimedia.QVideoFrame.PixelFormat]: ...
    def supportedViewfinderResolutions(self, settings: PySide2.QtMultimedia.QCameraViewfinderSettings = ...) -> typing.List[PySide2.QtCore.QSize]: ...
    def supportedViewfinderSettings(self, settings: PySide2.QtMultimedia.QCameraViewfinderSettings = ...) -> typing.List[PySide2.QtMultimedia.QCameraViewfinderSettings]: ...
    def unload(self): ...
    @typing.overload
    def unlock(self): ...
    @typing.overload
    def unlock(self, locks: PySide2.QtMultimedia.QCamera.LockTypes): ...
    def viewfinderSettings(self) -> PySide2.QtMultimedia.QCameraViewfinderSettings: ...


class QCameraCaptureBufferFormatControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def bufferFormat(self) -> PySide2.QtMultimedia.QVideoFrame.PixelFormat: ...
    def setBufferFormat(self, format: PySide2.QtMultimedia.QVideoFrame.PixelFormat): ...
    def supportedBufferFormats(self) -> typing.List[PySide2.QtMultimedia.QVideoFrame.PixelFormat]: ...


class QCameraCaptureDestinationControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def captureDestination(self) -> PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations: ...
    def isCaptureDestinationSupported(self, destination: PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations) -> bool: ...
    def setCaptureDestination(self, destination: PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations): ...


class QCameraControl(PySide2.QtMultimedia.QMediaControl):
    CaptureMode              : QCameraControl = ... # 0x1
    ImageEncodingSettings    : QCameraControl = ... # 0x2
    VideoEncodingSettings    : QCameraControl = ... # 0x3
    Viewfinder               : QCameraControl = ... # 0x4
    ViewfinderSettings       : QCameraControl = ... # 0x5

    class PropertyChangeType(object):
        CaptureMode              : QCameraControl.PropertyChangeType = ... # 0x1
        ImageEncodingSettings    : QCameraControl.PropertyChangeType = ... # 0x2
        VideoEncodingSettings    : QCameraControl.PropertyChangeType = ... # 0x3
        Viewfinder               : QCameraControl.PropertyChangeType = ... # 0x4
        ViewfinderSettings       : QCameraControl.PropertyChangeType = ... # 0x5

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def canChangeProperty(self, changeType: PySide2.QtMultimedia.QCameraControl.PropertyChangeType, status: PySide2.QtMultimedia.QCamera.Status) -> bool: ...
    def captureMode(self) -> PySide2.QtMultimedia.QCamera.CaptureModes: ...
    def isCaptureModeSupported(self, mode: PySide2.QtMultimedia.QCamera.CaptureModes) -> bool: ...
    def setCaptureMode(self, arg__1: PySide2.QtMultimedia.QCamera.CaptureModes): ...
    def setState(self, state: PySide2.QtMultimedia.QCamera.State): ...
    def state(self) -> PySide2.QtMultimedia.QCamera.State: ...
    def status(self) -> PySide2.QtMultimedia.QCamera.Status: ...


class QCameraExposure(PySide2.QtCore.QObject):
    ExposureAuto             : QCameraExposure = ... # 0x0
    ExposureManual           : QCameraExposure = ... # 0x1
    FlashAuto                : QCameraExposure = ... # 0x1
    MeteringMatrix           : QCameraExposure = ... # 0x1
    ExposurePortrait         : QCameraExposure = ... # 0x2
    FlashOff                 : QCameraExposure = ... # 0x2
    MeteringAverage          : QCameraExposure = ... # 0x2
    ExposureNight            : QCameraExposure = ... # 0x3
    MeteringSpot             : QCameraExposure = ... # 0x3
    ExposureBacklight        : QCameraExposure = ... # 0x4
    FlashOn                  : QCameraExposure = ... # 0x4
    ExposureSpotlight        : QCameraExposure = ... # 0x5
    ExposureSports           : QCameraExposure = ... # 0x6
    ExposureSnow             : QCameraExposure = ... # 0x7
    ExposureBeach            : QCameraExposure = ... # 0x8
    FlashRedEyeReduction     : QCameraExposure = ... # 0x8
    ExposureLargeAperture    : QCameraExposure = ... # 0x9
    ExposureSmallAperture    : QCameraExposure = ... # 0xa
    ExposureAction           : QCameraExposure = ... # 0xb
    ExposureLandscape        : QCameraExposure = ... # 0xc
    ExposureNightPortrait    : QCameraExposure = ... # 0xd
    ExposureTheatre          : QCameraExposure = ... # 0xe
    ExposureSunset           : QCameraExposure = ... # 0xf
    ExposureSteadyPhoto      : QCameraExposure = ... # 0x10
    FlashFill                : QCameraExposure = ... # 0x10
    ExposureFireworks        : QCameraExposure = ... # 0x11
    ExposureParty            : QCameraExposure = ... # 0x12
    ExposureCandlelight      : QCameraExposure = ... # 0x13
    ExposureBarcode          : QCameraExposure = ... # 0x14
    FlashTorch               : QCameraExposure = ... # 0x20
    FlashVideoLight          : QCameraExposure = ... # 0x40
    FlashSlowSyncFrontCurtain: QCameraExposure = ... # 0x80
    FlashSlowSyncRearCurtain : QCameraExposure = ... # 0x100
    FlashManual              : QCameraExposure = ... # 0x200
    ExposureModeVendor       : QCameraExposure = ... # 0x3e8

    class ExposureMode(object):
        ExposureAuto             : QCameraExposure.ExposureMode = ... # 0x0
        ExposureManual           : QCameraExposure.ExposureMode = ... # 0x1
        ExposurePortrait         : QCameraExposure.ExposureMode = ... # 0x2
        ExposureNight            : QCameraExposure.ExposureMode = ... # 0x3
        ExposureBacklight        : QCameraExposure.ExposureMode = ... # 0x4
        ExposureSpotlight        : QCameraExposure.ExposureMode = ... # 0x5
        ExposureSports           : QCameraExposure.ExposureMode = ... # 0x6
        ExposureSnow             : QCameraExposure.ExposureMode = ... # 0x7
        ExposureBeach            : QCameraExposure.ExposureMode = ... # 0x8
        ExposureLargeAperture    : QCameraExposure.ExposureMode = ... # 0x9
        ExposureSmallAperture    : QCameraExposure.ExposureMode = ... # 0xa
        ExposureAction           : QCameraExposure.ExposureMode = ... # 0xb
        ExposureLandscape        : QCameraExposure.ExposureMode = ... # 0xc
        ExposureNightPortrait    : QCameraExposure.ExposureMode = ... # 0xd
        ExposureTheatre          : QCameraExposure.ExposureMode = ... # 0xe
        ExposureSunset           : QCameraExposure.ExposureMode = ... # 0xf
        ExposureSteadyPhoto      : QCameraExposure.ExposureMode = ... # 0x10
        ExposureFireworks        : QCameraExposure.ExposureMode = ... # 0x11
        ExposureParty            : QCameraExposure.ExposureMode = ... # 0x12
        ExposureCandlelight      : QCameraExposure.ExposureMode = ... # 0x13
        ExposureBarcode          : QCameraExposure.ExposureMode = ... # 0x14
        ExposureModeVendor       : QCameraExposure.ExposureMode = ... # 0x3e8

    class FlashMode(object):
        FlashAuto                : QCameraExposure.FlashMode = ... # 0x1
        FlashOff                 : QCameraExposure.FlashMode = ... # 0x2
        FlashOn                  : QCameraExposure.FlashMode = ... # 0x4
        FlashRedEyeReduction     : QCameraExposure.FlashMode = ... # 0x8
        FlashFill                : QCameraExposure.FlashMode = ... # 0x10
        FlashTorch               : QCameraExposure.FlashMode = ... # 0x20
        FlashVideoLight          : QCameraExposure.FlashMode = ... # 0x40
        FlashSlowSyncFrontCurtain: QCameraExposure.FlashMode = ... # 0x80
        FlashSlowSyncRearCurtain : QCameraExposure.FlashMode = ... # 0x100
        FlashManual              : QCameraExposure.FlashMode = ... # 0x200

    class FlashModes(object): ...

    class MeteringMode(object):
        MeteringMatrix           : QCameraExposure.MeteringMode = ... # 0x1
        MeteringAverage          : QCameraExposure.MeteringMode = ... # 0x2
        MeteringSpot             : QCameraExposure.MeteringMode = ... # 0x3
    def aperture(self) -> float: ...
    def exposureCompensation(self) -> float: ...
    def exposureMode(self) -> PySide2.QtMultimedia.QCameraExposure.ExposureMode: ...
    def flashMode(self) -> PySide2.QtMultimedia.QCameraExposure.FlashModes: ...
    def isAvailable(self) -> bool: ...
    def isExposureModeSupported(self, mode: PySide2.QtMultimedia.QCameraExposure.ExposureMode) -> bool: ...
    def isFlashModeSupported(self, mode: PySide2.QtMultimedia.QCameraExposure.FlashModes) -> bool: ...
    def isFlashReady(self) -> bool: ...
    def isMeteringModeSupported(self, mode: PySide2.QtMultimedia.QCameraExposure.MeteringMode) -> bool: ...
    def isoSensitivity(self) -> int: ...
    def meteringMode(self) -> PySide2.QtMultimedia.QCameraExposure.MeteringMode: ...
    def requestedAperture(self) -> float: ...
    def requestedIsoSensitivity(self) -> int: ...
    def requestedShutterSpeed(self) -> float: ...
    def setAutoAperture(self): ...
    def setAutoIsoSensitivity(self): ...
    def setAutoShutterSpeed(self): ...
    def setExposureCompensation(self, ev: float): ...
    def setExposureMode(self, mode: PySide2.QtMultimedia.QCameraExposure.ExposureMode): ...
    def setFlashMode(self, mode: PySide2.QtMultimedia.QCameraExposure.FlashModes): ...
    def setManualAperture(self, aperture: float): ...
    def setManualIsoSensitivity(self, iso: int): ...
    def setManualShutterSpeed(self, seconds: float): ...
    def setMeteringMode(self, mode: PySide2.QtMultimedia.QCameraExposure.MeteringMode): ...
    def setSpotMeteringPoint(self, point: PySide2.QtCore.QPointF): ...
    def shutterSpeed(self) -> float: ...
    def spotMeteringPoint(self) -> PySide2.QtCore.QPointF: ...


class QCameraExposureControl(PySide2.QtMultimedia.QMediaControl):
    ISO                      : QCameraExposureControl = ... # 0x0
    Aperture                 : QCameraExposureControl = ... # 0x1
    ShutterSpeed             : QCameraExposureControl = ... # 0x2
    ExposureCompensation     : QCameraExposureControl = ... # 0x3
    FlashPower               : QCameraExposureControl = ... # 0x4
    FlashCompensation        : QCameraExposureControl = ... # 0x5
    TorchPower               : QCameraExposureControl = ... # 0x6
    SpotMeteringPoint        : QCameraExposureControl = ... # 0x7
    ExposureMode             : QCameraExposureControl = ... # 0x8
    MeteringMode             : QCameraExposureControl = ... # 0x9
    ExtendedExposureParameter: QCameraExposureControl = ... # 0x3e8

    class ExposureParameter(object):
        ISO                      : QCameraExposureControl.ExposureParameter = ... # 0x0
        Aperture                 : QCameraExposureControl.ExposureParameter = ... # 0x1
        ShutterSpeed             : QCameraExposureControl.ExposureParameter = ... # 0x2
        ExposureCompensation     : QCameraExposureControl.ExposureParameter = ... # 0x3
        FlashPower               : QCameraExposureControl.ExposureParameter = ... # 0x4
        FlashCompensation        : QCameraExposureControl.ExposureParameter = ... # 0x5
        TorchPower               : QCameraExposureControl.ExposureParameter = ... # 0x6
        SpotMeteringPoint        : QCameraExposureControl.ExposureParameter = ... # 0x7
        ExposureMode             : QCameraExposureControl.ExposureParameter = ... # 0x8
        MeteringMode             : QCameraExposureControl.ExposureParameter = ... # 0x9
        ExtendedExposureParameter: QCameraExposureControl.ExposureParameter = ... # 0x3e8

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def actualValue(self, parameter: PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter) -> typing.Any: ...
    def isParameterSupported(self, parameter: PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter) -> bool: ...
    def requestedValue(self, parameter: PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter) -> typing.Any: ...
    def setValue(self, parameter: PySide2.QtMultimedia.QCameraExposureControl.ExposureParameter, value: typing.Any) -> bool: ...


class QCameraFeedbackControl(PySide2.QtMultimedia.QMediaControl):
    ViewfinderStarted        : QCameraFeedbackControl = ... # 0x1
    ViewfinderStopped        : QCameraFeedbackControl = ... # 0x2
    ImageCaptured            : QCameraFeedbackControl = ... # 0x3
    ImageSaved               : QCameraFeedbackControl = ... # 0x4
    ImageError               : QCameraFeedbackControl = ... # 0x5
    RecordingStarted         : QCameraFeedbackControl = ... # 0x6
    RecordingInProgress      : QCameraFeedbackControl = ... # 0x7
    RecordingStopped         : QCameraFeedbackControl = ... # 0x8
    AutoFocusInProgress      : QCameraFeedbackControl = ... # 0x9
    AutoFocusLocked          : QCameraFeedbackControl = ... # 0xa
    AutoFocusFailed          : QCameraFeedbackControl = ... # 0xb

    class EventType(object):
        ViewfinderStarted        : QCameraFeedbackControl.EventType = ... # 0x1
        ViewfinderStopped        : QCameraFeedbackControl.EventType = ... # 0x2
        ImageCaptured            : QCameraFeedbackControl.EventType = ... # 0x3
        ImageSaved               : QCameraFeedbackControl.EventType = ... # 0x4
        ImageError               : QCameraFeedbackControl.EventType = ... # 0x5
        RecordingStarted         : QCameraFeedbackControl.EventType = ... # 0x6
        RecordingInProgress      : QCameraFeedbackControl.EventType = ... # 0x7
        RecordingStopped         : QCameraFeedbackControl.EventType = ... # 0x8
        AutoFocusInProgress      : QCameraFeedbackControl.EventType = ... # 0x9
        AutoFocusLocked          : QCameraFeedbackControl.EventType = ... # 0xa
        AutoFocusFailed          : QCameraFeedbackControl.EventType = ... # 0xb

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def isEventFeedbackEnabled(self, arg__1: PySide2.QtMultimedia.QCameraFeedbackControl.EventType) -> bool: ...
    def isEventFeedbackLocked(self, arg__1: PySide2.QtMultimedia.QCameraFeedbackControl.EventType) -> bool: ...
    def resetEventFeedback(self, arg__1: PySide2.QtMultimedia.QCameraFeedbackControl.EventType): ...
    def setEventFeedbackEnabled(self, arg__1: PySide2.QtMultimedia.QCameraFeedbackControl.EventType, arg__2: bool) -> bool: ...
    def setEventFeedbackSound(self, arg__1: PySide2.QtMultimedia.QCameraFeedbackControl.EventType, filePath: str) -> bool: ...


class QCameraFlashControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def flashMode(self) -> PySide2.QtMultimedia.QCameraExposure.FlashModes: ...
    def isFlashModeSupported(self, mode: PySide2.QtMultimedia.QCameraExposure.FlashModes) -> bool: ...
    def isFlashReady(self) -> bool: ...
    def setFlashMode(self, mode: PySide2.QtMultimedia.QCameraExposure.FlashModes): ...


class QCameraFocus(PySide2.QtCore.QObject):
    FocusPointAuto           : QCameraFocus = ... # 0x0
    FocusPointCenter         : QCameraFocus = ... # 0x1
    ManualFocus              : QCameraFocus = ... # 0x1
    FocusPointFaceDetection  : QCameraFocus = ... # 0x2
    HyperfocalFocus          : QCameraFocus = ... # 0x2
    FocusPointCustom         : QCameraFocus = ... # 0x3
    InfinityFocus            : QCameraFocus = ... # 0x4
    AutoFocus                : QCameraFocus = ... # 0x8
    ContinuousFocus          : QCameraFocus = ... # 0x10
    MacroFocus               : QCameraFocus = ... # 0x20

    class FocusMode(object):
        ManualFocus              : QCameraFocus.FocusMode = ... # 0x1
        HyperfocalFocus          : QCameraFocus.FocusMode = ... # 0x2
        InfinityFocus            : QCameraFocus.FocusMode = ... # 0x4
        AutoFocus                : QCameraFocus.FocusMode = ... # 0x8
        ContinuousFocus          : QCameraFocus.FocusMode = ... # 0x10
        MacroFocus               : QCameraFocus.FocusMode = ... # 0x20

    class FocusModes(object): ...

    class FocusPointMode(object):
        FocusPointAuto           : QCameraFocus.FocusPointMode = ... # 0x0
        FocusPointCenter         : QCameraFocus.FocusPointMode = ... # 0x1
        FocusPointFaceDetection  : QCameraFocus.FocusPointMode = ... # 0x2
        FocusPointCustom         : QCameraFocus.FocusPointMode = ... # 0x3
    def customFocusPoint(self) -> PySide2.QtCore.QPointF: ...
    def digitalZoom(self) -> float: ...
    def focusMode(self) -> PySide2.QtMultimedia.QCameraFocus.FocusModes: ...
    def focusPointMode(self) -> PySide2.QtMultimedia.QCameraFocus.FocusPointMode: ...
    def focusZones(self) -> typing.List[PySide2.QtMultimedia.QCameraFocusZone]: ...
    def isAvailable(self) -> bool: ...
    def isFocusModeSupported(self, mode: PySide2.QtMultimedia.QCameraFocus.FocusModes) -> bool: ...
    def isFocusPointModeSupported(self, arg__1: PySide2.QtMultimedia.QCameraFocus.FocusPointMode) -> bool: ...
    def maximumDigitalZoom(self) -> float: ...
    def maximumOpticalZoom(self) -> float: ...
    def opticalZoom(self) -> float: ...
    def setCustomFocusPoint(self, point: PySide2.QtCore.QPointF): ...
    def setFocusMode(self, mode: PySide2.QtMultimedia.QCameraFocus.FocusModes): ...
    def setFocusPointMode(self, mode: PySide2.QtMultimedia.QCameraFocus.FocusPointMode): ...
    def zoomTo(self, opticalZoom: float, digitalZoom: float): ...


class QCameraFocusControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def customFocusPoint(self) -> PySide2.QtCore.QPointF: ...
    def focusMode(self) -> PySide2.QtMultimedia.QCameraFocus.FocusModes: ...
    def focusPointMode(self) -> PySide2.QtMultimedia.QCameraFocus.FocusPointMode: ...
    def focusZones(self) -> typing.List[PySide2.QtMultimedia.QCameraFocusZone]: ...
    def isFocusModeSupported(self, mode: PySide2.QtMultimedia.QCameraFocus.FocusModes) -> bool: ...
    def isFocusPointModeSupported(self, mode: PySide2.QtMultimedia.QCameraFocus.FocusPointMode) -> bool: ...
    def setCustomFocusPoint(self, point: PySide2.QtCore.QPointF): ...
    def setFocusMode(self, mode: PySide2.QtMultimedia.QCameraFocus.FocusModes): ...
    def setFocusPointMode(self, mode: PySide2.QtMultimedia.QCameraFocus.FocusPointMode): ...


class QCameraFocusZone(Shiboken.Object):
    Invalid                  : QCameraFocusZone = ... # 0x0
    Unused                   : QCameraFocusZone = ... # 0x1
    Selected                 : QCameraFocusZone = ... # 0x2
    Focused                  : QCameraFocusZone = ... # 0x3

    class FocusZoneStatus(object):
        Invalid                  : QCameraFocusZone.FocusZoneStatus = ... # 0x0
        Unused                   : QCameraFocusZone.FocusZoneStatus = ... # 0x1
        Selected                 : QCameraFocusZone.FocusZoneStatus = ... # 0x2
        Focused                  : QCameraFocusZone.FocusZoneStatus = ... # 0x3

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, area: PySide2.QtCore.QRectF, status: PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus = ...): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QCameraFocusZone): ...

    def __copy__(self): ...
    def area(self) -> PySide2.QtCore.QRectF: ...
    def isValid(self) -> bool: ...
    def setStatus(self, status: PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus): ...
    def status(self) -> PySide2.QtMultimedia.QCameraFocusZone.FocusZoneStatus: ...


class QCameraImageCapture(PySide2.QtCore.QObject, PySide2.QtMultimedia.QMediaBindableInterface):
    NoError                  : QCameraImageCapture = ... # 0x0
    SingleImageCapture       : QCameraImageCapture = ... # 0x0
    CaptureToFile            : QCameraImageCapture = ... # 0x1
    NotReadyError            : QCameraImageCapture = ... # 0x1
    CaptureToBuffer          : QCameraImageCapture = ... # 0x2
    ResourceError            : QCameraImageCapture = ... # 0x2
    OutOfSpaceError          : QCameraImageCapture = ... # 0x3
    NotSupportedFeatureError : QCameraImageCapture = ... # 0x4
    FormatError              : QCameraImageCapture = ... # 0x5

    class CaptureDestination(object):
        CaptureToFile            : QCameraImageCapture.CaptureDestination = ... # 0x1
        CaptureToBuffer          : QCameraImageCapture.CaptureDestination = ... # 0x2

    class CaptureDestinations(object): ...

    class DriveMode(object):
        SingleImageCapture       : QCameraImageCapture.DriveMode = ... # 0x0

    class Error(object):
        NoError                  : QCameraImageCapture.Error = ... # 0x0
        NotReadyError            : QCameraImageCapture.Error = ... # 0x1
        ResourceError            : QCameraImageCapture.Error = ... # 0x2
        OutOfSpaceError          : QCameraImageCapture.Error = ... # 0x3
        NotSupportedFeatureError : QCameraImageCapture.Error = ... # 0x4
        FormatError              : QCameraImageCapture.Error = ... # 0x5

    def __init__(self, mediaObject: PySide2.QtMultimedia.QMediaObject, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def availability(self) -> PySide2.QtMultimedia.QMultimedia.AvailabilityStatus: ...
    def bufferFormat(self) -> PySide2.QtMultimedia.QVideoFrame.PixelFormat: ...
    def cancelCapture(self): ...
    def capture(self, location: str = ...) -> int: ...
    def captureDestination(self) -> PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations: ...
    def encodingSettings(self) -> PySide2.QtMultimedia.QImageEncoderSettings: ...
    def error(self) -> PySide2.QtMultimedia.QCameraImageCapture.Error: ...
    def errorString(self) -> str: ...
    def imageCodecDescription(self, codecName: str) -> str: ...
    def isAvailable(self) -> bool: ...
    def isCaptureDestinationSupported(self, destination: PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations) -> bool: ...
    def isReadyForCapture(self) -> bool: ...
    def mediaObject(self) -> PySide2.QtMultimedia.QMediaObject: ...
    def setBufferFormat(self, format: PySide2.QtMultimedia.QVideoFrame.PixelFormat): ...
    def setCaptureDestination(self, destination: PySide2.QtMultimedia.QCameraImageCapture.CaptureDestinations): ...
    def setEncodingSettings(self, settings: PySide2.QtMultimedia.QImageEncoderSettings): ...
    def setMediaObject(self, arg__1: PySide2.QtMultimedia.QMediaObject) -> bool: ...
    def supportedBufferFormats(self) -> typing.List[PySide2.QtMultimedia.QVideoFrame.PixelFormat]: ...
    def supportedImageCodecs(self) -> typing.List[str]: ...


class QCameraImageCaptureControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def cancelCapture(self): ...
    def capture(self, fileName: str) -> int: ...
    def driveMode(self) -> PySide2.QtMultimedia.QCameraImageCapture.DriveMode: ...
    def isReadyForCapture(self) -> bool: ...
    def setDriveMode(self, mode: PySide2.QtMultimedia.QCameraImageCapture.DriveMode): ...


class QCameraImageProcessing(PySide2.QtCore.QObject):
    ColorFilterNone          : QCameraImageProcessing = ... # 0x0
    WhiteBalanceAuto         : QCameraImageProcessing = ... # 0x0
    ColorFilterGrayscale     : QCameraImageProcessing = ... # 0x1
    WhiteBalanceManual       : QCameraImageProcessing = ... # 0x1
    ColorFilterNegative      : QCameraImageProcessing = ... # 0x2
    WhiteBalanceSunlight     : QCameraImageProcessing = ... # 0x2
    ColorFilterSolarize      : QCameraImageProcessing = ... # 0x3
    WhiteBalanceCloudy       : QCameraImageProcessing = ... # 0x3
    ColorFilterSepia         : QCameraImageProcessing = ... # 0x4
    WhiteBalanceShade        : QCameraImageProcessing = ... # 0x4
    ColorFilterPosterize     : QCameraImageProcessing = ... # 0x5
    WhiteBalanceTungsten     : QCameraImageProcessing = ... # 0x5
    ColorFilterWhiteboard    : QCameraImageProcessing = ... # 0x6
    WhiteBalanceFluorescent  : QCameraImageProcessing = ... # 0x6
    ColorFilterBlackboard    : QCameraImageProcessing = ... # 0x7
    WhiteBalanceFlash        : QCameraImageProcessing = ... # 0x7
    ColorFilterAqua          : QCameraImageProcessing = ... # 0x8
    WhiteBalanceSunset       : QCameraImageProcessing = ... # 0x8
    ColorFilterVendor        : QCameraImageProcessing = ... # 0x3e8
    WhiteBalanceVendor       : QCameraImageProcessing = ... # 0x3e8

    class ColorFilter(object):
        ColorFilterNone          : QCameraImageProcessing.ColorFilter = ... # 0x0
        ColorFilterGrayscale     : QCameraImageProcessing.ColorFilter = ... # 0x1
        ColorFilterNegative      : QCameraImageProcessing.ColorFilter = ... # 0x2
        ColorFilterSolarize      : QCameraImageProcessing.ColorFilter = ... # 0x3
        ColorFilterSepia         : QCameraImageProcessing.ColorFilter = ... # 0x4
        ColorFilterPosterize     : QCameraImageProcessing.ColorFilter = ... # 0x5
        ColorFilterWhiteboard    : QCameraImageProcessing.ColorFilter = ... # 0x6
        ColorFilterBlackboard    : QCameraImageProcessing.ColorFilter = ... # 0x7
        ColorFilterAqua          : QCameraImageProcessing.ColorFilter = ... # 0x8
        ColorFilterVendor        : QCameraImageProcessing.ColorFilter = ... # 0x3e8

    class WhiteBalanceMode(object):
        WhiteBalanceAuto         : QCameraImageProcessing.WhiteBalanceMode = ... # 0x0
        WhiteBalanceManual       : QCameraImageProcessing.WhiteBalanceMode = ... # 0x1
        WhiteBalanceSunlight     : QCameraImageProcessing.WhiteBalanceMode = ... # 0x2
        WhiteBalanceCloudy       : QCameraImageProcessing.WhiteBalanceMode = ... # 0x3
        WhiteBalanceShade        : QCameraImageProcessing.WhiteBalanceMode = ... # 0x4
        WhiteBalanceTungsten     : QCameraImageProcessing.WhiteBalanceMode = ... # 0x5
        WhiteBalanceFluorescent  : QCameraImageProcessing.WhiteBalanceMode = ... # 0x6
        WhiteBalanceFlash        : QCameraImageProcessing.WhiteBalanceMode = ... # 0x7
        WhiteBalanceSunset       : QCameraImageProcessing.WhiteBalanceMode = ... # 0x8
        WhiteBalanceVendor       : QCameraImageProcessing.WhiteBalanceMode = ... # 0x3e8
    def brightness(self) -> float: ...
    def colorFilter(self) -> PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter: ...
    def contrast(self) -> float: ...
    def denoisingLevel(self) -> float: ...
    def isAvailable(self) -> bool: ...
    def isColorFilterSupported(self, filter: PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter) -> bool: ...
    def isWhiteBalanceModeSupported(self, mode: PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode) -> bool: ...
    def manualWhiteBalance(self) -> float: ...
    def saturation(self) -> float: ...
    def setBrightness(self, value: float): ...
    def setColorFilter(self, filter: PySide2.QtMultimedia.QCameraImageProcessing.ColorFilter): ...
    def setContrast(self, value: float): ...
    def setDenoisingLevel(self, value: float): ...
    def setManualWhiteBalance(self, colorTemperature: float): ...
    def setSaturation(self, value: float): ...
    def setSharpeningLevel(self, value: float): ...
    def setWhiteBalanceMode(self, mode: PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode): ...
    def sharpeningLevel(self) -> float: ...
    def whiteBalanceMode(self) -> PySide2.QtMultimedia.QCameraImageProcessing.WhiteBalanceMode: ...


class QCameraImageProcessingControl(PySide2.QtMultimedia.QMediaControl):
    WhiteBalancePreset       : QCameraImageProcessingControl = ... # 0x0
    ColorTemperature         : QCameraImageProcessingControl = ... # 0x1
    Contrast                 : QCameraImageProcessingControl = ... # 0x2
    Saturation               : QCameraImageProcessingControl = ... # 0x3
    Brightness               : QCameraImageProcessingControl = ... # 0x4
    Sharpening               : QCameraImageProcessingControl = ... # 0x5
    Denoising                : QCameraImageProcessingControl = ... # 0x6
    ContrastAdjustment       : QCameraImageProcessingControl = ... # 0x7
    SaturationAdjustment     : QCameraImageProcessingControl = ... # 0x8
    BrightnessAdjustment     : QCameraImageProcessingControl = ... # 0x9
    SharpeningAdjustment     : QCameraImageProcessingControl = ... # 0xa
    DenoisingAdjustment      : QCameraImageProcessingControl = ... # 0xb
    ColorFilter              : QCameraImageProcessingControl = ... # 0xc
    ExtendedParameter        : QCameraImageProcessingControl = ... # 0x3e8

    class ProcessingParameter(object):
        WhiteBalancePreset       : QCameraImageProcessingControl.ProcessingParameter = ... # 0x0
        ColorTemperature         : QCameraImageProcessingControl.ProcessingParameter = ... # 0x1
        Contrast                 : QCameraImageProcessingControl.ProcessingParameter = ... # 0x2
        Saturation               : QCameraImageProcessingControl.ProcessingParameter = ... # 0x3
        Brightness               : QCameraImageProcessingControl.ProcessingParameter = ... # 0x4
        Sharpening               : QCameraImageProcessingControl.ProcessingParameter = ... # 0x5
        Denoising                : QCameraImageProcessingControl.ProcessingParameter = ... # 0x6
        ContrastAdjustment       : QCameraImageProcessingControl.ProcessingParameter = ... # 0x7
        SaturationAdjustment     : QCameraImageProcessingControl.ProcessingParameter = ... # 0x8
        BrightnessAdjustment     : QCameraImageProcessingControl.ProcessingParameter = ... # 0x9
        SharpeningAdjustment     : QCameraImageProcessingControl.ProcessingParameter = ... # 0xa
        DenoisingAdjustment      : QCameraImageProcessingControl.ProcessingParameter = ... # 0xb
        ColorFilter              : QCameraImageProcessingControl.ProcessingParameter = ... # 0xc
        ExtendedParameter        : QCameraImageProcessingControl.ProcessingParameter = ... # 0x3e8

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def isParameterSupported(self, arg__1: PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter) -> bool: ...
    def isParameterValueSupported(self, parameter: PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter, value: typing.Any) -> bool: ...
    def parameter(self, parameter: PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter) -> typing.Any: ...
    def setParameter(self, parameter: PySide2.QtMultimedia.QCameraImageProcessingControl.ProcessingParameter, value: typing.Any): ...


class QCameraInfo(Shiboken.Object):

    @typing.overload
    def __init__(self, camera: PySide2.QtMultimedia.QCamera): ...
    @typing.overload
    def __init__(self, name: PySide2.QtCore.QByteArray = ...): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QCameraInfo): ...

    def __copy__(self): ...
    @staticmethod
    def availableCameras(position: PySide2.QtMultimedia.QCamera.Position = ...) -> typing.List[PySide2.QtMultimedia.QCameraInfo]: ...
    @staticmethod
    def defaultCamera() -> PySide2.QtMultimedia.QCameraInfo: ...
    def description(self) -> str: ...
    def deviceName(self) -> str: ...
    def isNull(self) -> bool: ...
    def orientation(self) -> int: ...
    def position(self) -> PySide2.QtMultimedia.QCamera.Position: ...


class QCameraInfoControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def cameraOrientation(self, deviceName: str) -> int: ...
    def cameraPosition(self, deviceName: str) -> PySide2.QtMultimedia.QCamera.Position: ...


class QCameraLocksControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def lockStatus(self, lock: PySide2.QtMultimedia.QCamera.LockType) -> PySide2.QtMultimedia.QCamera.LockStatus: ...
    def searchAndLock(self, locks: PySide2.QtMultimedia.QCamera.LockTypes): ...
    def supportedLocks(self) -> PySide2.QtMultimedia.QCamera.LockTypes: ...
    def unlock(self, locks: PySide2.QtMultimedia.QCamera.LockTypes): ...


class QCameraViewfinderSettings(Shiboken.Object):

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QCameraViewfinderSettings): ...

    def __copy__(self): ...
    def isNull(self) -> bool: ...
    def maximumFrameRate(self) -> float: ...
    def minimumFrameRate(self) -> float: ...
    def pixelAspectRatio(self) -> PySide2.QtCore.QSize: ...
    def pixelFormat(self) -> PySide2.QtMultimedia.QVideoFrame.PixelFormat: ...
    def resolution(self) -> PySide2.QtCore.QSize: ...
    def setMaximumFrameRate(self, rate: float): ...
    def setMinimumFrameRate(self, rate: float): ...
    @typing.overload
    def setPixelAspectRatio(self, horizontal: int, vertical: int): ...
    @typing.overload
    def setPixelAspectRatio(self, ratio: PySide2.QtCore.QSize): ...
    def setPixelFormat(self, format: PySide2.QtMultimedia.QVideoFrame.PixelFormat): ...
    @typing.overload
    def setResolution(self, arg__1: PySide2.QtCore.QSize): ...
    @typing.overload
    def setResolution(self, width: int, height: int): ...
    def swap(self, other: PySide2.QtMultimedia.QCameraViewfinderSettings): ...


class QCameraViewfinderSettingsControl(PySide2.QtMultimedia.QMediaControl):
    Resolution               : QCameraViewfinderSettingsControl = ... # 0x0
    PixelAspectRatio         : QCameraViewfinderSettingsControl = ... # 0x1
    MinimumFrameRate         : QCameraViewfinderSettingsControl = ... # 0x2
    MaximumFrameRate         : QCameraViewfinderSettingsControl = ... # 0x3
    PixelFormat              : QCameraViewfinderSettingsControl = ... # 0x4
    UserParameter            : QCameraViewfinderSettingsControl = ... # 0x3e8

    class ViewfinderParameter(object):
        Resolution               : QCameraViewfinderSettingsControl.ViewfinderParameter = ... # 0x0
        PixelAspectRatio         : QCameraViewfinderSettingsControl.ViewfinderParameter = ... # 0x1
        MinimumFrameRate         : QCameraViewfinderSettingsControl.ViewfinderParameter = ... # 0x2
        MaximumFrameRate         : QCameraViewfinderSettingsControl.ViewfinderParameter = ... # 0x3
        PixelFormat              : QCameraViewfinderSettingsControl.ViewfinderParameter = ... # 0x4
        UserParameter            : QCameraViewfinderSettingsControl.ViewfinderParameter = ... # 0x3e8

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def isViewfinderParameterSupported(self, parameter: PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter) -> bool: ...
    def setViewfinderParameter(self, parameter: PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter, value: typing.Any): ...
    def viewfinderParameter(self, parameter: PySide2.QtMultimedia.QCameraViewfinderSettingsControl.ViewfinderParameter) -> typing.Any: ...


class QCameraViewfinderSettingsControl2(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def setViewfinderSettings(self, settings: PySide2.QtMultimedia.QCameraViewfinderSettings): ...
    def supportedViewfinderSettings(self) -> typing.List[PySide2.QtMultimedia.QCameraViewfinderSettings]: ...
    def viewfinderSettings(self) -> PySide2.QtMultimedia.QCameraViewfinderSettings: ...


class QCameraZoomControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def currentDigitalZoom(self) -> float: ...
    def currentOpticalZoom(self) -> float: ...
    def maximumDigitalZoom(self) -> float: ...
    def maximumOpticalZoom(self) -> float: ...
    def requestedDigitalZoom(self) -> float: ...
    def requestedOpticalZoom(self) -> float: ...
    def zoomTo(self, optical: float, digital: float): ...


class QCustomAudioRoleControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def customAudioRole(self) -> str: ...
    def setCustomAudioRole(self, role: str): ...
    def supportedCustomAudioRoles(self) -> typing.List[str]: ...


class QImageEncoderControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def imageCodecDescription(self, codec: str) -> str: ...
    def imageSettings(self) -> PySide2.QtMultimedia.QImageEncoderSettings: ...
    def setImageSettings(self, settings: PySide2.QtMultimedia.QImageEncoderSettings): ...
    def supportedImageCodecs(self) -> typing.List[str]: ...


class QImageEncoderSettings(Shiboken.Object):

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QImageEncoderSettings): ...

    def __copy__(self): ...
    def codec(self) -> str: ...
    def encodingOption(self, option: str) -> typing.Any: ...
    def encodingOptions(self) -> typing.Dict[str, typing.Any]: ...
    def isNull(self) -> bool: ...
    def quality(self) -> PySide2.QtMultimedia.QMultimedia.EncodingQuality: ...
    def resolution(self) -> PySide2.QtCore.QSize: ...
    def setCodec(self, arg__1: str): ...
    def setEncodingOption(self, option: str, value: typing.Any): ...
    def setEncodingOptions(self, options: typing.Dict[str, typing.Any]): ...
    def setQuality(self, quality: PySide2.QtMultimedia.QMultimedia.EncodingQuality): ...
    @typing.overload
    def setResolution(self, arg__1: PySide2.QtCore.QSize): ...
    @typing.overload
    def setResolution(self, width: int, height: int): ...


class QMediaAudioProbeControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...


class QMediaAvailabilityControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def availability(self) -> PySide2.QtMultimedia.QMultimedia.AvailabilityStatus: ...


class QMediaBindableInterface(Shiboken.Object):

    def __init__(self): ...

    def mediaObject(self) -> PySide2.QtMultimedia.QMediaObject: ...
    def setMediaObject(self, object: PySide2.QtMultimedia.QMediaObject) -> bool: ...


class QMediaContainerControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def containerDescription(self, formatMimeType: str) -> str: ...
    def containerFormat(self) -> str: ...
    def setContainerFormat(self, format: str): ...
    def supportedContainers(self) -> typing.List[str]: ...


class QMediaContent(Shiboken.Object):

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, contentRequest: PySide2.QtNetwork.QNetworkRequest): ...
    @typing.overload
    def __init__(self, contentResource: PySide2.QtMultimedia.QMediaResource): ...
    @typing.overload
    def __init__(self, contentUrl: PySide2.QtCore.QUrl): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QMediaContent): ...
    @typing.overload
    def __init__(self, playlist: PySide2.QtMultimedia.QMediaPlaylist, contentUrl: PySide2.QtCore.QUrl = ..., takeOwnership: bool = ...): ...
    @typing.overload
    def __init__(self, resources: typing.Sequence[PySide2.QtMultimedia.QMediaResource]): ...

    def __copy__(self): ...
    def canonicalRequest(self) -> PySide2.QtNetwork.QNetworkRequest: ...
    def canonicalResource(self) -> PySide2.QtMultimedia.QMediaResource: ...
    def canonicalUrl(self) -> PySide2.QtCore.QUrl: ...
    def isNull(self) -> bool: ...
    def playlist(self) -> PySide2.QtMultimedia.QMediaPlaylist: ...
    def request(self) -> PySide2.QtNetwork.QNetworkRequest: ...
    def resources(self) -> typing.List[PySide2.QtMultimedia.QMediaResource]: ...


class QMediaControl(PySide2.QtCore.QObject):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...


class QMediaGaplessPlaybackControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def crossfadeTime(self) -> float: ...
    def isCrossfadeSupported(self) -> bool: ...
    def nextMedia(self) -> PySide2.QtMultimedia.QMediaContent: ...
    def setCrossfadeTime(self, crossfadeTime: float): ...
    def setNextMedia(self, media: PySide2.QtMultimedia.QMediaContent): ...


class QMediaNetworkAccessControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def currentConfiguration(self) -> PySide2.QtNetwork.QNetworkConfiguration: ...
    def setConfigurations(self, configuration: typing.Sequence[PySide2.QtNetwork.QNetworkConfiguration]): ...


class QMediaObject(PySide2.QtCore.QObject):

    def __init__(self, parent: PySide2.QtCore.QObject, service: PySide2.QtMultimedia.QMediaService): ...

    def addPropertyWatch(self, name: PySide2.QtCore.QByteArray): ...
    def availability(self) -> PySide2.QtMultimedia.QMultimedia.AvailabilityStatus: ...
    def availableMetaData(self) -> typing.List[str]: ...
    def bind(self, arg__1: PySide2.QtCore.QObject) -> bool: ...
    def isAvailable(self) -> bool: ...
    def isMetaDataAvailable(self) -> bool: ...
    def metaData(self, key: str) -> typing.Any: ...
    def notifyInterval(self) -> int: ...
    def removePropertyWatch(self, name: PySide2.QtCore.QByteArray): ...
    def service(self) -> PySide2.QtMultimedia.QMediaService: ...
    def setNotifyInterval(self, milliSeconds: int): ...
    def unbind(self, arg__1: PySide2.QtCore.QObject): ...


class QMediaPlayer(PySide2.QtMultimedia.QMediaObject):
    NoError                  : QMediaPlayer = ... # 0x0
    StoppedState             : QMediaPlayer = ... # 0x0
    UnknownMediaStatus       : QMediaPlayer = ... # 0x0
    LowLatency               : QMediaPlayer = ... # 0x1
    NoMedia                  : QMediaPlayer = ... # 0x1
    PlayingState             : QMediaPlayer = ... # 0x1
    ResourceError            : QMediaPlayer = ... # 0x1
    FormatError              : QMediaPlayer = ... # 0x2
    LoadingMedia             : QMediaPlayer = ... # 0x2
    PausedState              : QMediaPlayer = ... # 0x2
    StreamPlayback           : QMediaPlayer = ... # 0x2
    LoadedMedia              : QMediaPlayer = ... # 0x3
    NetworkError             : QMediaPlayer = ... # 0x3
    AccessDeniedError        : QMediaPlayer = ... # 0x4
    StalledMedia             : QMediaPlayer = ... # 0x4
    VideoSurface             : QMediaPlayer = ... # 0x4
    BufferingMedia           : QMediaPlayer = ... # 0x5
    ServiceMissingError      : QMediaPlayer = ... # 0x5
    BufferedMedia            : QMediaPlayer = ... # 0x6
    MediaIsPlaylist          : QMediaPlayer = ... # 0x6
    EndOfMedia               : QMediaPlayer = ... # 0x7
    InvalidMedia             : QMediaPlayer = ... # 0x8

    class Error(object):
        NoError                  : QMediaPlayer.Error = ... # 0x0
        ResourceError            : QMediaPlayer.Error = ... # 0x1
        FormatError              : QMediaPlayer.Error = ... # 0x2
        NetworkError             : QMediaPlayer.Error = ... # 0x3
        AccessDeniedError        : QMediaPlayer.Error = ... # 0x4
        ServiceMissingError      : QMediaPlayer.Error = ... # 0x5
        MediaIsPlaylist          : QMediaPlayer.Error = ... # 0x6

    class Flag(object):
        LowLatency               : QMediaPlayer.Flag = ... # 0x1
        StreamPlayback           : QMediaPlayer.Flag = ... # 0x2
        VideoSurface             : QMediaPlayer.Flag = ... # 0x4

    class Flags(object): ...

    class MediaStatus(object):
        UnknownMediaStatus       : QMediaPlayer.MediaStatus = ... # 0x0
        NoMedia                  : QMediaPlayer.MediaStatus = ... # 0x1
        LoadingMedia             : QMediaPlayer.MediaStatus = ... # 0x2
        LoadedMedia              : QMediaPlayer.MediaStatus = ... # 0x3
        StalledMedia             : QMediaPlayer.MediaStatus = ... # 0x4
        BufferingMedia           : QMediaPlayer.MediaStatus = ... # 0x5
        BufferedMedia            : QMediaPlayer.MediaStatus = ... # 0x6
        EndOfMedia               : QMediaPlayer.MediaStatus = ... # 0x7
        InvalidMedia             : QMediaPlayer.MediaStatus = ... # 0x8

    class State(object):
        StoppedState             : QMediaPlayer.State = ... # 0x0
        PlayingState             : QMediaPlayer.State = ... # 0x1
        PausedState              : QMediaPlayer.State = ... # 0x2

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ..., flags: PySide2.QtMultimedia.QMediaPlayer.Flags = ...): ...

    def audioRole(self) -> PySide2.QtMultimedia.QAudio.Role: ...
    def availability(self) -> PySide2.QtMultimedia.QMultimedia.AvailabilityStatus: ...
    def bind(self, arg__1: PySide2.QtCore.QObject) -> bool: ...
    def bufferStatus(self) -> int: ...
    def currentMedia(self) -> PySide2.QtMultimedia.QMediaContent: ...
    def currentNetworkConfiguration(self) -> PySide2.QtNetwork.QNetworkConfiguration: ...
    def customAudioRole(self) -> str: ...
    def duration(self) -> int: ...
    def error(self) -> PySide2.QtMultimedia.QMediaPlayer.Error: ...
    def errorString(self) -> str: ...
    @staticmethod
    def hasSupport(mimeType: str, codecs: typing.Sequence[str] = ..., flags: PySide2.QtMultimedia.QMediaPlayer.Flags = ...) -> PySide2.QtMultimedia.QMultimedia.SupportEstimate: ...
    def isAudioAvailable(self) -> bool: ...
    def isMuted(self) -> bool: ...
    def isSeekable(self) -> bool: ...
    def isVideoAvailable(self) -> bool: ...
    def media(self) -> PySide2.QtMultimedia.QMediaContent: ...
    def mediaStatus(self) -> PySide2.QtMultimedia.QMediaPlayer.MediaStatus: ...
    def mediaStream(self) -> PySide2.QtCore.QIODevice: ...
    def pause(self): ...
    def play(self): ...
    def playbackRate(self) -> float: ...
    def playlist(self) -> PySide2.QtMultimedia.QMediaPlaylist: ...
    def position(self) -> int: ...
    def setAudioRole(self, audioRole: PySide2.QtMultimedia.QAudio.Role): ...
    def setCustomAudioRole(self, audioRole: str): ...
    def setMedia(self, media: PySide2.QtMultimedia.QMediaContent, stream: typing.Optional[PySide2.QtCore.QIODevice] = ...): ...
    def setMuted(self, muted: bool): ...
    def setNetworkConfigurations(self, configurations: typing.Sequence[PySide2.QtNetwork.QNetworkConfiguration]): ...
    def setPlaybackRate(self, rate: float): ...
    def setPlaylist(self, playlist: PySide2.QtMultimedia.QMediaPlaylist): ...
    def setPosition(self, position: int): ...
    @typing.overload
    def setVideoOutput(self, arg__1: PySide2.QtMultimediaWidgets.QGraphicsVideoItem): ...
    @typing.overload
    def setVideoOutput(self, arg__1: PySide2.QtMultimediaWidgets.QVideoWidget): ...
    @typing.overload
    def setVideoOutput(self, surface: PySide2.QtMultimedia.QAbstractVideoSurface): ...
    def setVolume(self, volume: int): ...
    def state(self) -> PySide2.QtMultimedia.QMediaPlayer.State: ...
    def stop(self): ...
    def supportedAudioRoles(self) -> typing.List[PySide2.QtMultimedia.QAudio.Role]: ...
    def supportedCustomAudioRoles(self) -> typing.List[str]: ...
    @staticmethod
    def supportedMimeTypes(flags: PySide2.QtMultimedia.QMediaPlayer.Flags = ...) -> typing.List[str]: ...
    def unbind(self, arg__1: PySide2.QtCore.QObject): ...
    def volume(self) -> int: ...


class QMediaPlayerControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def availablePlaybackRanges(self) -> PySide2.QtMultimedia.QMediaTimeRange: ...
    def bufferStatus(self) -> int: ...
    def duration(self) -> int: ...
    def isAudioAvailable(self) -> bool: ...
    def isMuted(self) -> bool: ...
    def isSeekable(self) -> bool: ...
    def isVideoAvailable(self) -> bool: ...
    def media(self) -> PySide2.QtMultimedia.QMediaContent: ...
    def mediaStatus(self) -> PySide2.QtMultimedia.QMediaPlayer.MediaStatus: ...
    def mediaStream(self) -> PySide2.QtCore.QIODevice: ...
    def pause(self): ...
    def play(self): ...
    def playbackRate(self) -> float: ...
    def position(self) -> int: ...
    def setMedia(self, media: PySide2.QtMultimedia.QMediaContent, stream: PySide2.QtCore.QIODevice): ...
    def setMuted(self, mute: bool): ...
    def setPlaybackRate(self, rate: float): ...
    def setPosition(self, position: int): ...
    def setVolume(self, volume: int): ...
    def state(self) -> PySide2.QtMultimedia.QMediaPlayer.State: ...
    def stop(self): ...
    def volume(self) -> int: ...


class QMediaPlaylist(PySide2.QtCore.QObject, PySide2.QtMultimedia.QMediaBindableInterface):
    CurrentItemOnce          : QMediaPlaylist = ... # 0x0
    NoError                  : QMediaPlaylist = ... # 0x0
    CurrentItemInLoop        : QMediaPlaylist = ... # 0x1
    FormatError              : QMediaPlaylist = ... # 0x1
    FormatNotSupportedError  : QMediaPlaylist = ... # 0x2
    Sequential               : QMediaPlaylist = ... # 0x2
    Loop                     : QMediaPlaylist = ... # 0x3
    NetworkError             : QMediaPlaylist = ... # 0x3
    AccessDeniedError        : QMediaPlaylist = ... # 0x4
    Random                   : QMediaPlaylist = ... # 0x4

    class Error(object):
        NoError                  : QMediaPlaylist.Error = ... # 0x0
        FormatError              : QMediaPlaylist.Error = ... # 0x1
        FormatNotSupportedError  : QMediaPlaylist.Error = ... # 0x2
        NetworkError             : QMediaPlaylist.Error = ... # 0x3
        AccessDeniedError        : QMediaPlaylist.Error = ... # 0x4

    class PlaybackMode(object):
        CurrentItemOnce          : QMediaPlaylist.PlaybackMode = ... # 0x0
        CurrentItemInLoop        : QMediaPlaylist.PlaybackMode = ... # 0x1
        Sequential               : QMediaPlaylist.PlaybackMode = ... # 0x2
        Loop                     : QMediaPlaylist.PlaybackMode = ... # 0x3
        Random                   : QMediaPlaylist.PlaybackMode = ... # 0x4

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    @typing.overload
    def addMedia(self, content: PySide2.QtMultimedia.QMediaContent) -> bool: ...
    @typing.overload
    def addMedia(self, items: typing.Sequence[PySide2.QtMultimedia.QMediaContent]) -> bool: ...
    def clear(self) -> bool: ...
    def currentIndex(self) -> int: ...
    def currentMedia(self) -> PySide2.QtMultimedia.QMediaContent: ...
    def error(self) -> PySide2.QtMultimedia.QMediaPlaylist.Error: ...
    def errorString(self) -> str: ...
    @typing.overload
    def insertMedia(self, index: int, content: PySide2.QtMultimedia.QMediaContent) -> bool: ...
    @typing.overload
    def insertMedia(self, index: int, items: typing.Sequence[PySide2.QtMultimedia.QMediaContent]) -> bool: ...
    def isEmpty(self) -> bool: ...
    def isReadOnly(self) -> bool: ...
    @typing.overload
    def load(self, device: PySide2.QtCore.QIODevice, format: typing.Optional[bytes] = ...): ...
    @typing.overload
    def load(self, location: PySide2.QtCore.QUrl, format: typing.Optional[bytes] = ...): ...
    @typing.overload
    def load(self, request: PySide2.QtNetwork.QNetworkRequest, format: typing.Optional[bytes] = ...): ...
    def media(self, index: int) -> PySide2.QtMultimedia.QMediaContent: ...
    def mediaCount(self) -> int: ...
    def mediaObject(self) -> PySide2.QtMultimedia.QMediaObject: ...
    def moveMedia(self, from_: int, to: int) -> bool: ...
    def next(self): ...
    def nextIndex(self, steps: int = ...) -> int: ...
    def playbackMode(self) -> PySide2.QtMultimedia.QMediaPlaylist.PlaybackMode: ...
    def previous(self): ...
    def previousIndex(self, steps: int = ...) -> int: ...
    @typing.overload
    def removeMedia(self, pos: int) -> bool: ...
    @typing.overload
    def removeMedia(self, start: int, end: int) -> bool: ...
    @typing.overload
    def save(self, device: PySide2.QtCore.QIODevice, format: bytes) -> bool: ...
    @typing.overload
    def save(self, location: PySide2.QtCore.QUrl, format: typing.Optional[bytes] = ...) -> bool: ...
    def setCurrentIndex(self, index: int): ...
    def setMediaObject(self, object: PySide2.QtMultimedia.QMediaObject) -> bool: ...
    def setPlaybackMode(self, mode: PySide2.QtMultimedia.QMediaPlaylist.PlaybackMode): ...
    def shuffle(self): ...


class QMediaRecorder(PySide2.QtCore.QObject, PySide2.QtMultimedia.QMediaBindableInterface):
    NoError                  : QMediaRecorder = ... # 0x0
    StoppedState             : QMediaRecorder = ... # 0x0
    UnavailableStatus        : QMediaRecorder = ... # 0x0
    RecordingState           : QMediaRecorder = ... # 0x1
    ResourceError            : QMediaRecorder = ... # 0x1
    UnloadedStatus           : QMediaRecorder = ... # 0x1
    FormatError              : QMediaRecorder = ... # 0x2
    LoadingStatus            : QMediaRecorder = ... # 0x2
    PausedState              : QMediaRecorder = ... # 0x2
    LoadedStatus             : QMediaRecorder = ... # 0x3
    OutOfSpaceError          : QMediaRecorder = ... # 0x3
    StartingStatus           : QMediaRecorder = ... # 0x4
    RecordingStatus          : QMediaRecorder = ... # 0x5
    PausedStatus             : QMediaRecorder = ... # 0x6
    FinalizingStatus         : QMediaRecorder = ... # 0x7

    class Error(object):
        NoError                  : QMediaRecorder.Error = ... # 0x0
        ResourceError            : QMediaRecorder.Error = ... # 0x1
        FormatError              : QMediaRecorder.Error = ... # 0x2
        OutOfSpaceError          : QMediaRecorder.Error = ... # 0x3

    class State(object):
        StoppedState             : QMediaRecorder.State = ... # 0x0
        RecordingState           : QMediaRecorder.State = ... # 0x1
        PausedState              : QMediaRecorder.State = ... # 0x2

    class Status(object):
        UnavailableStatus        : QMediaRecorder.Status = ... # 0x0
        UnloadedStatus           : QMediaRecorder.Status = ... # 0x1
        LoadingStatus            : QMediaRecorder.Status = ... # 0x2
        LoadedStatus             : QMediaRecorder.Status = ... # 0x3
        StartingStatus           : QMediaRecorder.Status = ... # 0x4
        RecordingStatus          : QMediaRecorder.Status = ... # 0x5
        PausedStatus             : QMediaRecorder.Status = ... # 0x6
        FinalizingStatus         : QMediaRecorder.Status = ... # 0x7

    def __init__(self, mediaObject: PySide2.QtMultimedia.QMediaObject, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def actualLocation(self) -> PySide2.QtCore.QUrl: ...
    def audioCodecDescription(self, codecName: str) -> str: ...
    def audioSettings(self) -> PySide2.QtMultimedia.QAudioEncoderSettings: ...
    def availability(self) -> PySide2.QtMultimedia.QMultimedia.AvailabilityStatus: ...
    def availableMetaData(self) -> typing.List[str]: ...
    def containerDescription(self, format: str) -> str: ...
    def containerFormat(self) -> str: ...
    def duration(self) -> int: ...
    def error(self) -> PySide2.QtMultimedia.QMediaRecorder.Error: ...
    def errorString(self) -> str: ...
    def isAvailable(self) -> bool: ...
    def isMetaDataAvailable(self) -> bool: ...
    def isMetaDataWritable(self) -> bool: ...
    def isMuted(self) -> bool: ...
    def mediaObject(self) -> PySide2.QtMultimedia.QMediaObject: ...
    def metaData(self, key: str) -> typing.Any: ...
    def outputLocation(self) -> PySide2.QtCore.QUrl: ...
    def pause(self): ...
    def record(self): ...
    def setAudioSettings(self, audioSettings: PySide2.QtMultimedia.QAudioEncoderSettings): ...
    def setContainerFormat(self, container: str): ...
    def setEncodingSettings(self, audioSettings: PySide2.QtMultimedia.QAudioEncoderSettings, videoSettings: PySide2.QtMultimedia.QVideoEncoderSettings = ..., containerMimeType: str = ...): ...
    def setMediaObject(self, object: PySide2.QtMultimedia.QMediaObject) -> bool: ...
    def setMetaData(self, key: str, value: typing.Any): ...
    def setMuted(self, muted: bool): ...
    def setOutputLocation(self, location: PySide2.QtCore.QUrl) -> bool: ...
    def setVideoSettings(self, videoSettings: PySide2.QtMultimedia.QVideoEncoderSettings): ...
    def setVolume(self, volume: float): ...
    def state(self) -> PySide2.QtMultimedia.QMediaRecorder.State: ...
    def status(self) -> PySide2.QtMultimedia.QMediaRecorder.Status: ...
    def stop(self): ...
    def supportedAudioCodecs(self) -> typing.List[str]: ...
    def supportedContainers(self) -> typing.List[str]: ...
    def supportedVideoCodecs(self) -> typing.List[str]: ...
    def videoCodecDescription(self, codecName: str) -> str: ...
    def videoSettings(self) -> PySide2.QtMultimedia.QVideoEncoderSettings: ...
    def volume(self) -> float: ...


class QMediaRecorderControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def applySettings(self): ...
    def duration(self) -> int: ...
    def isMuted(self) -> bool: ...
    def outputLocation(self) -> PySide2.QtCore.QUrl: ...
    def setMuted(self, muted: bool): ...
    def setOutputLocation(self, location: PySide2.QtCore.QUrl) -> bool: ...
    def setState(self, state: PySide2.QtMultimedia.QMediaRecorder.State): ...
    def setVolume(self, volume: float): ...
    def state(self) -> PySide2.QtMultimedia.QMediaRecorder.State: ...
    def status(self) -> PySide2.QtMultimedia.QMediaRecorder.Status: ...
    def volume(self) -> float: ...


class QMediaResource(Shiboken.Object):

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QMediaResource): ...
    @typing.overload
    def __init__(self, request: PySide2.QtNetwork.QNetworkRequest, mimeType: str = ...): ...
    @typing.overload
    def __init__(self, url: PySide2.QtCore.QUrl, mimeType: str = ...): ...

    def __copy__(self): ...
    def audioBitRate(self) -> int: ...
    def audioCodec(self) -> str: ...
    def channelCount(self) -> int: ...
    def dataSize(self) -> int: ...
    def isNull(self) -> bool: ...
    def language(self) -> str: ...
    def mimeType(self) -> str: ...
    def request(self) -> PySide2.QtNetwork.QNetworkRequest: ...
    def resolution(self) -> PySide2.QtCore.QSize: ...
    def sampleRate(self) -> int: ...
    def setAudioBitRate(self, rate: int): ...
    def setAudioCodec(self, codec: str): ...
    def setChannelCount(self, channels: int): ...
    def setDataSize(self, size: int): ...
    def setLanguage(self, language: str): ...
    @typing.overload
    def setResolution(self, resolution: PySide2.QtCore.QSize): ...
    @typing.overload
    def setResolution(self, width: int, height: int): ...
    def setSampleRate(self, frequency: int): ...
    def setVideoBitRate(self, rate: int): ...
    def setVideoCodec(self, codec: str): ...
    def url(self) -> PySide2.QtCore.QUrl: ...
    def videoBitRate(self) -> int: ...
    def videoCodec(self) -> str: ...


class QMediaService(PySide2.QtCore.QObject):

    def __init__(self, parent: PySide2.QtCore.QObject): ...

    def releaseControl(self, control: PySide2.QtMultimedia.QMediaControl): ...
    def requestControl(self, name: bytes) -> PySide2.QtMultimedia.QMediaControl: ...


class QMediaServiceCameraInfoInterface(Shiboken.Object):

    def __init__(self): ...

    def cameraOrientation(self, device: PySide2.QtCore.QByteArray) -> int: ...
    def cameraPosition(self, device: PySide2.QtCore.QByteArray) -> PySide2.QtMultimedia.QCamera.Position: ...


class QMediaServiceDefaultDeviceInterface(Shiboken.Object):

    def __init__(self): ...

    def defaultDevice(self, service: PySide2.QtCore.QByteArray) -> PySide2.QtCore.QByteArray: ...


class QMediaServiceFeaturesInterface(Shiboken.Object):

    def __init__(self): ...

    def supportedFeatures(self, service: PySide2.QtCore.QByteArray) -> PySide2.QtMultimedia.QMediaServiceProviderHint.Features: ...


class QMediaServiceProviderHint(Shiboken.Object):
    Null                     : QMediaServiceProviderHint = ... # 0x0
    ContentType              : QMediaServiceProviderHint = ... # 0x1
    LowLatencyPlayback       : QMediaServiceProviderHint = ... # 0x1
    Device                   : QMediaServiceProviderHint = ... # 0x2
    RecordingSupport         : QMediaServiceProviderHint = ... # 0x2
    SupportedFeatures        : QMediaServiceProviderHint = ... # 0x3
    CameraPosition           : QMediaServiceProviderHint = ... # 0x4
    StreamPlayback           : QMediaServiceProviderHint = ... # 0x4
    VideoSurface             : QMediaServiceProviderHint = ... # 0x8

    class Feature(object):
        LowLatencyPlayback       : QMediaServiceProviderHint.Feature = ... # 0x1
        RecordingSupport         : QMediaServiceProviderHint.Feature = ... # 0x2
        StreamPlayback           : QMediaServiceProviderHint.Feature = ... # 0x4
        VideoSurface             : QMediaServiceProviderHint.Feature = ... # 0x8

    class Features(object): ...

    class Type(object):
        Null                     : QMediaServiceProviderHint.Type = ... # 0x0
        ContentType              : QMediaServiceProviderHint.Type = ... # 0x1
        Device                   : QMediaServiceProviderHint.Type = ... # 0x2
        SupportedFeatures        : QMediaServiceProviderHint.Type = ... # 0x3
        CameraPosition           : QMediaServiceProviderHint.Type = ... # 0x4

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, device: PySide2.QtCore.QByteArray): ...
    @typing.overload
    def __init__(self, features: PySide2.QtMultimedia.QMediaServiceProviderHint.Features): ...
    @typing.overload
    def __init__(self, mimeType: str, codecs: typing.Sequence[str]): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QMediaServiceProviderHint): ...
    @typing.overload
    def __init__(self, position: PySide2.QtMultimedia.QCamera.Position): ...

    def __copy__(self): ...
    def cameraPosition(self) -> PySide2.QtMultimedia.QCamera.Position: ...
    def codecs(self) -> typing.List[str]: ...
    def device(self) -> PySide2.QtCore.QByteArray: ...
    def features(self) -> PySide2.QtMultimedia.QMediaServiceProviderHint.Features: ...
    def isNull(self) -> bool: ...
    def mimeType(self) -> str: ...
    def type(self) -> PySide2.QtMultimedia.QMediaServiceProviderHint.Type: ...


class QMediaServiceSupportedDevicesInterface(Shiboken.Object):

    def __init__(self): ...

    def deviceDescription(self, service: PySide2.QtCore.QByteArray, device: PySide2.QtCore.QByteArray) -> str: ...
    def devices(self, service: PySide2.QtCore.QByteArray) -> typing.List[PySide2.QtCore.QByteArray]: ...


class QMediaServiceSupportedFormatsInterface(Shiboken.Object):

    def __init__(self): ...

    def hasSupport(self, mimeType: str, codecs: typing.Sequence[str]) -> PySide2.QtMultimedia.QMultimedia.SupportEstimate: ...
    def supportedMimeTypes(self) -> typing.List[str]: ...


class QMediaStreamsControl(PySide2.QtMultimedia.QMediaControl):
    UnknownStream            : QMediaStreamsControl = ... # 0x0
    VideoStream              : QMediaStreamsControl = ... # 0x1
    AudioStream              : QMediaStreamsControl = ... # 0x2
    SubPictureStream         : QMediaStreamsControl = ... # 0x3
    DataStream               : QMediaStreamsControl = ... # 0x4

    class StreamType(object):
        UnknownStream            : QMediaStreamsControl.StreamType = ... # 0x0
        VideoStream              : QMediaStreamsControl.StreamType = ... # 0x1
        AudioStream              : QMediaStreamsControl.StreamType = ... # 0x2
        SubPictureStream         : QMediaStreamsControl.StreamType = ... # 0x3
        DataStream               : QMediaStreamsControl.StreamType = ... # 0x4

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def isActive(self, streamNumber: int) -> bool: ...
    def metaData(self, streamNumber: int, key: str) -> typing.Any: ...
    def setActive(self, streamNumber: int, state: bool): ...
    def streamCount(self) -> int: ...
    def streamType(self, streamNumber: int) -> PySide2.QtMultimedia.QMediaStreamsControl.StreamType: ...


class QMediaTimeInterval(Shiboken.Object):

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, arg__1: PySide2.QtMultimedia.QMediaTimeInterval): ...
    @typing.overload
    def __init__(self, start: int, end: int): ...

    def __copy__(self): ...
    def contains(self, time: int) -> bool: ...
    def end(self) -> int: ...
    def isNormal(self) -> bool: ...
    def normalized(self) -> PySide2.QtMultimedia.QMediaTimeInterval: ...
    def start(self) -> int: ...
    def translated(self, offset: int) -> PySide2.QtMultimedia.QMediaTimeInterval: ...


class QMediaTimeRange(Shiboken.Object):

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, arg__1: PySide2.QtMultimedia.QMediaTimeInterval): ...
    @typing.overload
    def __init__(self, range: PySide2.QtMultimedia.QMediaTimeRange): ...
    @typing.overload
    def __init__(self, start: int, end: int): ...

    def __add__(self, arg__2: PySide2.QtMultimedia.QMediaTimeRange) -> PySide2.QtMultimedia.QMediaTimeRange: ...
    def __copy__(self): ...
    @typing.overload
    def __iadd__(self, arg__1: PySide2.QtMultimedia.QMediaTimeInterval) -> PySide2.QtMultimedia.QMediaTimeRange: ...
    @typing.overload
    def __iadd__(self, arg__1: PySide2.QtMultimedia.QMediaTimeRange) -> PySide2.QtMultimedia.QMediaTimeRange: ...
    @typing.overload
    def __isub__(self, arg__1: PySide2.QtMultimedia.QMediaTimeInterval) -> PySide2.QtMultimedia.QMediaTimeRange: ...
    @typing.overload
    def __isub__(self, arg__1: PySide2.QtMultimedia.QMediaTimeRange) -> PySide2.QtMultimedia.QMediaTimeRange: ...
    def __sub__(self, arg__2: PySide2.QtMultimedia.QMediaTimeRange) -> PySide2.QtMultimedia.QMediaTimeRange: ...
    @typing.overload
    def addInterval(self, interval: PySide2.QtMultimedia.QMediaTimeInterval): ...
    @typing.overload
    def addInterval(self, start: int, end: int): ...
    def addTimeRange(self, arg__1: PySide2.QtMultimedia.QMediaTimeRange): ...
    def clear(self): ...
    def contains(self, time: int) -> bool: ...
    def earliestTime(self) -> int: ...
    def intervals(self) -> typing.List[PySide2.QtMultimedia.QMediaTimeInterval]: ...
    def isContinuous(self) -> bool: ...
    def isEmpty(self) -> bool: ...
    def latestTime(self) -> int: ...
    @typing.overload
    def removeInterval(self, interval: PySide2.QtMultimedia.QMediaTimeInterval): ...
    @typing.overload
    def removeInterval(self, start: int, end: int): ...
    def removeTimeRange(self, arg__1: PySide2.QtMultimedia.QMediaTimeRange): ...


class QMediaVideoProbeControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...


class QMetaDataReaderControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def availableMetaData(self) -> typing.List[str]: ...
    def isMetaDataAvailable(self) -> bool: ...
    def metaData(self, key: str) -> typing.Any: ...


class QMetaDataWriterControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def availableMetaData(self) -> typing.List[str]: ...
    def isMetaDataAvailable(self) -> bool: ...
    def isWritable(self) -> bool: ...
    def metaData(self, key: str) -> typing.Any: ...
    def setMetaData(self, key: str, value: typing.Any): ...


class QMultimedia(Shiboken.Object):
    Available                : QMultimedia = ... # 0x0
    ConstantQualityEncoding  : QMultimedia = ... # 0x0
    NotSupported             : QMultimedia = ... # 0x0
    VeryLowQuality           : QMultimedia = ... # 0x0
    ConstantBitRateEncoding  : QMultimedia = ... # 0x1
    LowQuality               : QMultimedia = ... # 0x1
    MaybeSupported           : QMultimedia = ... # 0x1
    ServiceMissing           : QMultimedia = ... # 0x1
    AverageBitRateEncoding   : QMultimedia = ... # 0x2
    Busy                     : QMultimedia = ... # 0x2
    NormalQuality            : QMultimedia = ... # 0x2
    ProbablySupported        : QMultimedia = ... # 0x2
    HighQuality              : QMultimedia = ... # 0x3
    PreferredService         : QMultimedia = ... # 0x3
    ResourceError            : QMultimedia = ... # 0x3
    TwoPassEncoding          : QMultimedia = ... # 0x3
    VeryHighQuality          : QMultimedia = ... # 0x4

    class AvailabilityStatus(object):
        Available                : QMultimedia.AvailabilityStatus = ... # 0x0
        ServiceMissing           : QMultimedia.AvailabilityStatus = ... # 0x1
        Busy                     : QMultimedia.AvailabilityStatus = ... # 0x2
        ResourceError            : QMultimedia.AvailabilityStatus = ... # 0x3

    class EncodingMode(object):
        ConstantQualityEncoding  : QMultimedia.EncodingMode = ... # 0x0
        ConstantBitRateEncoding  : QMultimedia.EncodingMode = ... # 0x1
        AverageBitRateEncoding   : QMultimedia.EncodingMode = ... # 0x2
        TwoPassEncoding          : QMultimedia.EncodingMode = ... # 0x3

    class EncodingQuality(object):
        VeryLowQuality           : QMultimedia.EncodingQuality = ... # 0x0
        LowQuality               : QMultimedia.EncodingQuality = ... # 0x1
        NormalQuality            : QMultimedia.EncodingQuality = ... # 0x2
        HighQuality              : QMultimedia.EncodingQuality = ... # 0x3
        VeryHighQuality          : QMultimedia.EncodingQuality = ... # 0x4

    class SupportEstimate(object):
        NotSupported             : QMultimedia.SupportEstimate = ... # 0x0
        MaybeSupported           : QMultimedia.SupportEstimate = ... # 0x1
        ProbablySupported        : QMultimedia.SupportEstimate = ... # 0x2
        PreferredService         : QMultimedia.SupportEstimate = ... # 0x3


class QRadioData(PySide2.QtCore.QObject, PySide2.QtMultimedia.QMediaBindableInterface):
    NoError                  : QRadioData = ... # 0x0
    Undefined                : QRadioData = ... # 0x0
    News                     : QRadioData = ... # 0x1
    ResourceError            : QRadioData = ... # 0x1
    CurrentAffairs           : QRadioData = ... # 0x2
    OpenError                : QRadioData = ... # 0x2
    Information              : QRadioData = ... # 0x3
    OutOfRangeError          : QRadioData = ... # 0x3
    Sport                    : QRadioData = ... # 0x4
    Education                : QRadioData = ... # 0x5
    Drama                    : QRadioData = ... # 0x6
    Culture                  : QRadioData = ... # 0x7
    Science                  : QRadioData = ... # 0x8
    Varied                   : QRadioData = ... # 0x9
    PopMusic                 : QRadioData = ... # 0xa
    RockMusic                : QRadioData = ... # 0xb
    EasyListening            : QRadioData = ... # 0xc
    LightClassical           : QRadioData = ... # 0xd
    SeriousClassical         : QRadioData = ... # 0xe
    OtherMusic               : QRadioData = ... # 0xf
    Weather                  : QRadioData = ... # 0x10
    Finance                  : QRadioData = ... # 0x11
    ChildrensProgrammes      : QRadioData = ... # 0x12
    SocialAffairs            : QRadioData = ... # 0x13
    Religion                 : QRadioData = ... # 0x14
    PhoneIn                  : QRadioData = ... # 0x15
    Travel                   : QRadioData = ... # 0x16
    Leisure                  : QRadioData = ... # 0x17
    JazzMusic                : QRadioData = ... # 0x18
    CountryMusic             : QRadioData = ... # 0x19
    NationalMusic            : QRadioData = ... # 0x1a
    OldiesMusic              : QRadioData = ... # 0x1b
    FolkMusic                : QRadioData = ... # 0x1c
    Documentary              : QRadioData = ... # 0x1d
    AlarmTest                : QRadioData = ... # 0x1e
    Alarm                    : QRadioData = ... # 0x1f
    Talk                     : QRadioData = ... # 0x20
    ClassicRock              : QRadioData = ... # 0x21
    AdultHits                : QRadioData = ... # 0x22
    SoftRock                 : QRadioData = ... # 0x23
    Top40                    : QRadioData = ... # 0x24
    Soft                     : QRadioData = ... # 0x25
    Nostalgia                : QRadioData = ... # 0x26
    Classical                : QRadioData = ... # 0x27
    RhythmAndBlues           : QRadioData = ... # 0x28
    SoftRhythmAndBlues       : QRadioData = ... # 0x29
    Language                 : QRadioData = ... # 0x2a
    ReligiousMusic           : QRadioData = ... # 0x2b
    ReligiousTalk            : QRadioData = ... # 0x2c
    Personality              : QRadioData = ... # 0x2d
    Public                   : QRadioData = ... # 0x2e
    College                  : QRadioData = ... # 0x2f

    class Error(object):
        NoError                  : QRadioData.Error = ... # 0x0
        ResourceError            : QRadioData.Error = ... # 0x1
        OpenError                : QRadioData.Error = ... # 0x2
        OutOfRangeError          : QRadioData.Error = ... # 0x3

    class ProgramType(object):
        Undefined                : QRadioData.ProgramType = ... # 0x0
        News                     : QRadioData.ProgramType = ... # 0x1
        CurrentAffairs           : QRadioData.ProgramType = ... # 0x2
        Information              : QRadioData.ProgramType = ... # 0x3
        Sport                    : QRadioData.ProgramType = ... # 0x4
        Education                : QRadioData.ProgramType = ... # 0x5
        Drama                    : QRadioData.ProgramType = ... # 0x6
        Culture                  : QRadioData.ProgramType = ... # 0x7
        Science                  : QRadioData.ProgramType = ... # 0x8
        Varied                   : QRadioData.ProgramType = ... # 0x9
        PopMusic                 : QRadioData.ProgramType = ... # 0xa
        RockMusic                : QRadioData.ProgramType = ... # 0xb
        EasyListening            : QRadioData.ProgramType = ... # 0xc
        LightClassical           : QRadioData.ProgramType = ... # 0xd
        SeriousClassical         : QRadioData.ProgramType = ... # 0xe
        OtherMusic               : QRadioData.ProgramType = ... # 0xf
        Weather                  : QRadioData.ProgramType = ... # 0x10
        Finance                  : QRadioData.ProgramType = ... # 0x11
        ChildrensProgrammes      : QRadioData.ProgramType = ... # 0x12
        SocialAffairs            : QRadioData.ProgramType = ... # 0x13
        Religion                 : QRadioData.ProgramType = ... # 0x14
        PhoneIn                  : QRadioData.ProgramType = ... # 0x15
        Travel                   : QRadioData.ProgramType = ... # 0x16
        Leisure                  : QRadioData.ProgramType = ... # 0x17
        JazzMusic                : QRadioData.ProgramType = ... # 0x18
        CountryMusic             : QRadioData.ProgramType = ... # 0x19
        NationalMusic            : QRadioData.ProgramType = ... # 0x1a
        OldiesMusic              : QRadioData.ProgramType = ... # 0x1b
        FolkMusic                : QRadioData.ProgramType = ... # 0x1c
        Documentary              : QRadioData.ProgramType = ... # 0x1d
        AlarmTest                : QRadioData.ProgramType = ... # 0x1e
        Alarm                    : QRadioData.ProgramType = ... # 0x1f
        Talk                     : QRadioData.ProgramType = ... # 0x20
        ClassicRock              : QRadioData.ProgramType = ... # 0x21
        AdultHits                : QRadioData.ProgramType = ... # 0x22
        SoftRock                 : QRadioData.ProgramType = ... # 0x23
        Top40                    : QRadioData.ProgramType = ... # 0x24
        Soft                     : QRadioData.ProgramType = ... # 0x25
        Nostalgia                : QRadioData.ProgramType = ... # 0x26
        Classical                : QRadioData.ProgramType = ... # 0x27
        RhythmAndBlues           : QRadioData.ProgramType = ... # 0x28
        SoftRhythmAndBlues       : QRadioData.ProgramType = ... # 0x29
        Language                 : QRadioData.ProgramType = ... # 0x2a
        ReligiousMusic           : QRadioData.ProgramType = ... # 0x2b
        ReligiousTalk            : QRadioData.ProgramType = ... # 0x2c
        Personality              : QRadioData.ProgramType = ... # 0x2d
        Public                   : QRadioData.ProgramType = ... # 0x2e
        College                  : QRadioData.ProgramType = ... # 0x2f

    def __init__(self, mediaObject: PySide2.QtMultimedia.QMediaObject, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def availability(self) -> PySide2.QtMultimedia.QMultimedia.AvailabilityStatus: ...
    def error(self) -> PySide2.QtMultimedia.QRadioData.Error: ...
    def errorString(self) -> str: ...
    def isAlternativeFrequenciesEnabled(self) -> bool: ...
    def mediaObject(self) -> PySide2.QtMultimedia.QMediaObject: ...
    def programType(self) -> PySide2.QtMultimedia.QRadioData.ProgramType: ...
    def programTypeName(self) -> str: ...
    def radioText(self) -> str: ...
    def setAlternativeFrequenciesEnabled(self, enabled: bool): ...
    def setMediaObject(self, arg__1: PySide2.QtMultimedia.QMediaObject) -> bool: ...
    def stationId(self) -> str: ...
    def stationName(self) -> str: ...


class QRadioDataControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def error(self) -> PySide2.QtMultimedia.QRadioData.Error: ...
    def errorString(self) -> str: ...
    def isAlternativeFrequenciesEnabled(self) -> bool: ...
    def programType(self) -> PySide2.QtMultimedia.QRadioData.ProgramType: ...
    def programTypeName(self) -> str: ...
    def radioText(self) -> str: ...
    def setAlternativeFrequenciesEnabled(self, enabled: bool): ...
    def stationId(self) -> str: ...
    def stationName(self) -> str: ...


class QRadioTuner(PySide2.QtMultimedia.QMediaObject):
    AM                       : QRadioTuner = ... # 0x0
    ActiveState              : QRadioTuner = ... # 0x0
    ForceStereo              : QRadioTuner = ... # 0x0
    NoError                  : QRadioTuner = ... # 0x0
    SearchFast               : QRadioTuner = ... # 0x0
    FM                       : QRadioTuner = ... # 0x1
    ForceMono                : QRadioTuner = ... # 0x1
    ResourceError            : QRadioTuner = ... # 0x1
    SearchGetStationId       : QRadioTuner = ... # 0x1
    StoppedState             : QRadioTuner = ... # 0x1
    Auto                     : QRadioTuner = ... # 0x2
    OpenError                : QRadioTuner = ... # 0x2
    SW                       : QRadioTuner = ... # 0x2
    LW                       : QRadioTuner = ... # 0x3
    OutOfRangeError          : QRadioTuner = ... # 0x3
    FM2                      : QRadioTuner = ... # 0x4

    class Band(object):
        AM                       : QRadioTuner.Band = ... # 0x0
        FM                       : QRadioTuner.Band = ... # 0x1
        SW                       : QRadioTuner.Band = ... # 0x2
        LW                       : QRadioTuner.Band = ... # 0x3
        FM2                      : QRadioTuner.Band = ... # 0x4

    class Error(object):
        NoError                  : QRadioTuner.Error = ... # 0x0
        ResourceError            : QRadioTuner.Error = ... # 0x1
        OpenError                : QRadioTuner.Error = ... # 0x2
        OutOfRangeError          : QRadioTuner.Error = ... # 0x3

    class SearchMode(object):
        SearchFast               : QRadioTuner.SearchMode = ... # 0x0
        SearchGetStationId       : QRadioTuner.SearchMode = ... # 0x1

    class State(object):
        ActiveState              : QRadioTuner.State = ... # 0x0
        StoppedState             : QRadioTuner.State = ... # 0x1

    class StereoMode(object):
        ForceStereo              : QRadioTuner.StereoMode = ... # 0x0
        ForceMono                : QRadioTuner.StereoMode = ... # 0x1
        Auto                     : QRadioTuner.StereoMode = ... # 0x2

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def availability(self) -> PySide2.QtMultimedia.QMultimedia.AvailabilityStatus: ...
    def band(self) -> PySide2.QtMultimedia.QRadioTuner.Band: ...
    def cancelSearch(self): ...
    def error(self) -> PySide2.QtMultimedia.QRadioTuner.Error: ...
    def errorString(self) -> str: ...
    def frequency(self) -> int: ...
    def frequencyRange(self, band: PySide2.QtMultimedia.QRadioTuner.Band) -> typing.Tuple[int, int]: ...
    def frequencyStep(self, band: PySide2.QtMultimedia.QRadioTuner.Band) -> int: ...
    def isAntennaConnected(self) -> bool: ...
    def isBandSupported(self, b: PySide2.QtMultimedia.QRadioTuner.Band) -> bool: ...
    def isMuted(self) -> bool: ...
    def isSearching(self) -> bool: ...
    def isStereo(self) -> bool: ...
    def radioData(self) -> PySide2.QtMultimedia.QRadioData: ...
    def searchAllStations(self, searchMode: PySide2.QtMultimedia.QRadioTuner.SearchMode = ...): ...
    def searchBackward(self): ...
    def searchForward(self): ...
    def setBand(self, band: PySide2.QtMultimedia.QRadioTuner.Band): ...
    def setFrequency(self, frequency: int): ...
    def setMuted(self, muted: bool): ...
    def setStereoMode(self, mode: PySide2.QtMultimedia.QRadioTuner.StereoMode): ...
    def setVolume(self, volume: int): ...
    def signalStrength(self) -> int: ...
    def start(self): ...
    def state(self) -> PySide2.QtMultimedia.QRadioTuner.State: ...
    def stereoMode(self) -> PySide2.QtMultimedia.QRadioTuner.StereoMode: ...
    def stop(self): ...
    def volume(self) -> int: ...


class QRadioTunerControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def band(self) -> PySide2.QtMultimedia.QRadioTuner.Band: ...
    def cancelSearch(self): ...
    def error(self) -> PySide2.QtMultimedia.QRadioTuner.Error: ...
    def errorString(self) -> str: ...
    def frequency(self) -> int: ...
    def frequencyRange(self, b: PySide2.QtMultimedia.QRadioTuner.Band) -> typing.Tuple[int, int]: ...
    def frequencyStep(self, b: PySide2.QtMultimedia.QRadioTuner.Band) -> int: ...
    def isAntennaConnected(self) -> bool: ...
    def isBandSupported(self, b: PySide2.QtMultimedia.QRadioTuner.Band) -> bool: ...
    def isMuted(self) -> bool: ...
    def isSearching(self) -> bool: ...
    def isStereo(self) -> bool: ...
    def searchAllStations(self, searchMode: PySide2.QtMultimedia.QRadioTuner.SearchMode = ...): ...
    def searchBackward(self): ...
    def searchForward(self): ...
    def setBand(self, b: PySide2.QtMultimedia.QRadioTuner.Band): ...
    def setFrequency(self, frequency: int): ...
    def setMuted(self, muted: bool): ...
    def setStereoMode(self, mode: PySide2.QtMultimedia.QRadioTuner.StereoMode): ...
    def setVolume(self, volume: int): ...
    def signalStrength(self) -> int: ...
    def start(self): ...
    def state(self) -> PySide2.QtMultimedia.QRadioTuner.State: ...
    def stereoMode(self) -> PySide2.QtMultimedia.QRadioTuner.StereoMode: ...
    def stop(self): ...
    def volume(self) -> int: ...


class QSound(PySide2.QtCore.QObject):
    Infinite                 : QSound = ... # -0x1

    class Loop(object):
        Infinite                 : QSound.Loop = ... # -0x1

    def __init__(self, filename: str, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def fileName(self) -> str: ...
    def isFinished(self) -> bool: ...
    def loops(self) -> int: ...
    def loopsRemaining(self) -> int: ...
    @typing.overload
    @staticmethod
    def play(): ...
    @typing.overload
    @staticmethod
    def play(filename: str): ...
    def setLoops(self, arg__1: int): ...
    def stop(self): ...


class QSoundEffect(PySide2.QtCore.QObject):
    Infinite                 : QSoundEffect = ... # -0x2
    Null                     : QSoundEffect = ... # 0x0
    Loading                  : QSoundEffect = ... # 0x1
    Ready                    : QSoundEffect = ... # 0x2
    Error                    : QSoundEffect = ... # 0x3

    class Loop(object):
        Infinite                 : QSoundEffect.Loop = ... # -0x2

    class Status(object):
        Null                     : QSoundEffect.Status = ... # 0x0
        Loading                  : QSoundEffect.Status = ... # 0x1
        Ready                    : QSoundEffect.Status = ... # 0x2
        Error                    : QSoundEffect.Status = ... # 0x3

    @typing.overload
    def __init__(self, audioDevice: PySide2.QtMultimedia.QAudioDeviceInfo, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...
    @typing.overload
    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def category(self) -> str: ...
    def isLoaded(self) -> bool: ...
    def isMuted(self) -> bool: ...
    def isPlaying(self) -> bool: ...
    def loopCount(self) -> int: ...
    def loopsRemaining(self) -> int: ...
    def play(self): ...
    def setCategory(self, category: str): ...
    def setLoopCount(self, loopCount: int): ...
    def setMuted(self, muted: bool): ...
    def setSource(self, url: PySide2.QtCore.QUrl): ...
    def setVolume(self, volume: float): ...
    def source(self) -> PySide2.QtCore.QUrl: ...
    def status(self) -> PySide2.QtMultimedia.QSoundEffect.Status: ...
    def stop(self): ...
    @staticmethod
    def supportedMimeTypes() -> typing.List[str]: ...
    def volume(self) -> float: ...


class QVideoDeviceSelectorControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def defaultDevice(self) -> int: ...
    def deviceCount(self) -> int: ...
    def deviceDescription(self, index: int) -> str: ...
    def deviceName(self, index: int) -> str: ...
    def selectedDevice(self) -> int: ...
    def setSelectedDevice(self, index: int): ...


class QVideoEncoderSettings(Shiboken.Object):

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QVideoEncoderSettings): ...

    def __copy__(self): ...
    def bitRate(self) -> int: ...
    def codec(self) -> str: ...
    def encodingMode(self) -> PySide2.QtMultimedia.QMultimedia.EncodingMode: ...
    def encodingOption(self, option: str) -> typing.Any: ...
    def encodingOptions(self) -> typing.Dict[str, typing.Any]: ...
    def frameRate(self) -> float: ...
    def isNull(self) -> bool: ...
    def quality(self) -> PySide2.QtMultimedia.QMultimedia.EncodingQuality: ...
    def resolution(self) -> PySide2.QtCore.QSize: ...
    def setBitRate(self, bitrate: int): ...
    def setCodec(self, arg__1: str): ...
    def setEncodingMode(self, arg__1: PySide2.QtMultimedia.QMultimedia.EncodingMode): ...
    def setEncodingOption(self, option: str, value: typing.Any): ...
    def setEncodingOptions(self, options: typing.Dict[str, typing.Any]): ...
    def setFrameRate(self, rate: float): ...
    def setQuality(self, quality: PySide2.QtMultimedia.QMultimedia.EncodingQuality): ...
    @typing.overload
    def setResolution(self, arg__1: PySide2.QtCore.QSize): ...
    @typing.overload
    def setResolution(self, width: int, height: int): ...


class QVideoEncoderSettingsControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def setVideoSettings(self, settings: PySide2.QtMultimedia.QVideoEncoderSettings): ...
    def supportedVideoCodecs(self) -> typing.List[str]: ...
    def videoCodecDescription(self, codec: str) -> str: ...
    def videoSettings(self) -> PySide2.QtMultimedia.QVideoEncoderSettings: ...


class QVideoFilterRunnable(Shiboken.Object):
    LastInChain              : QVideoFilterRunnable = ... # 0x1

    class RunFlag(object):
        LastInChain              : QVideoFilterRunnable.RunFlag = ... # 0x1

    class RunFlags(object): ...

    def __init__(self): ...

    def run(self, input: PySide2.QtMultimedia.QVideoFrame, surfaceFormat: PySide2.QtMultimedia.QVideoSurfaceFormat, flags: PySide2.QtMultimedia.QVideoFilterRunnable.RunFlags) -> PySide2.QtMultimedia.QVideoFrame: ...


class QVideoFrame(Shiboken.Object):
    Format_Invalid           : QVideoFrame = ... # 0x0
    ProgressiveFrame         : QVideoFrame = ... # 0x0
    Format_ARGB32            : QVideoFrame = ... # 0x1
    TopField                 : QVideoFrame = ... # 0x1
    BottomField              : QVideoFrame = ... # 0x2
    Format_ARGB32_Premultiplied: QVideoFrame = ... # 0x2
    Format_RGB32             : QVideoFrame = ... # 0x3
    InterlacedFrame          : QVideoFrame = ... # 0x3
    Format_RGB24             : QVideoFrame = ... # 0x4
    Format_RGB565            : QVideoFrame = ... # 0x5
    Format_RGB555            : QVideoFrame = ... # 0x6
    Format_ARGB8565_Premultiplied: QVideoFrame = ... # 0x7
    Format_BGRA32            : QVideoFrame = ... # 0x8
    Format_BGRA32_Premultiplied: QVideoFrame = ... # 0x9
    Format_BGR32             : QVideoFrame = ... # 0xa
    Format_BGR24             : QVideoFrame = ... # 0xb
    Format_BGR565            : QVideoFrame = ... # 0xc
    Format_BGR555            : QVideoFrame = ... # 0xd
    Format_BGRA5658_Premultiplied: QVideoFrame = ... # 0xe
    Format_AYUV444           : QVideoFrame = ... # 0xf
    Format_AYUV444_Premultiplied: QVideoFrame = ... # 0x10
    Format_YUV444            : QVideoFrame = ... # 0x11
    Format_YUV420P           : QVideoFrame = ... # 0x12
    Format_YV12              : QVideoFrame = ... # 0x13
    Format_UYVY              : QVideoFrame = ... # 0x14
    Format_YUYV              : QVideoFrame = ... # 0x15
    Format_NV12              : QVideoFrame = ... # 0x16
    Format_NV21              : QVideoFrame = ... # 0x17
    Format_IMC1              : QVideoFrame = ... # 0x18
    Format_IMC2              : QVideoFrame = ... # 0x19
    Format_IMC3              : QVideoFrame = ... # 0x1a
    Format_IMC4              : QVideoFrame = ... # 0x1b
    Format_Y8                : QVideoFrame = ... # 0x1c
    Format_Y16               : QVideoFrame = ... # 0x1d
    Format_Jpeg              : QVideoFrame = ... # 0x1e
    Format_CameraRaw         : QVideoFrame = ... # 0x1f
    Format_AdobeDng          : QVideoFrame = ... # 0x20
    Format_ABGR32            : QVideoFrame = ... # 0x21
    Format_YUV422P           : QVideoFrame = ... # 0x22
    NPixelFormats            : QVideoFrame = ... # 0x23
    Format_User              : QVideoFrame = ... # 0x3e8

    class FieldType(object):
        ProgressiveFrame         : QVideoFrame.FieldType = ... # 0x0
        TopField                 : QVideoFrame.FieldType = ... # 0x1
        BottomField              : QVideoFrame.FieldType = ... # 0x2
        InterlacedFrame          : QVideoFrame.FieldType = ... # 0x3

    class PixelFormat(object):
        Format_Invalid           : QVideoFrame.PixelFormat = ... # 0x0
        Format_ARGB32            : QVideoFrame.PixelFormat = ... # 0x1
        Format_ARGB32_Premultiplied: QVideoFrame.PixelFormat = ... # 0x2
        Format_RGB32             : QVideoFrame.PixelFormat = ... # 0x3
        Format_RGB24             : QVideoFrame.PixelFormat = ... # 0x4
        Format_RGB565            : QVideoFrame.PixelFormat = ... # 0x5
        Format_RGB555            : QVideoFrame.PixelFormat = ... # 0x6
        Format_ARGB8565_Premultiplied: QVideoFrame.PixelFormat = ... # 0x7
        Format_BGRA32            : QVideoFrame.PixelFormat = ... # 0x8
        Format_BGRA32_Premultiplied: QVideoFrame.PixelFormat = ... # 0x9
        Format_BGR32             : QVideoFrame.PixelFormat = ... # 0xa
        Format_BGR24             : QVideoFrame.PixelFormat = ... # 0xb
        Format_BGR565            : QVideoFrame.PixelFormat = ... # 0xc
        Format_BGR555            : QVideoFrame.PixelFormat = ... # 0xd
        Format_BGRA5658_Premultiplied: QVideoFrame.PixelFormat = ... # 0xe
        Format_AYUV444           : QVideoFrame.PixelFormat = ... # 0xf
        Format_AYUV444_Premultiplied: QVideoFrame.PixelFormat = ... # 0x10
        Format_YUV444            : QVideoFrame.PixelFormat = ... # 0x11
        Format_YUV420P           : QVideoFrame.PixelFormat = ... # 0x12
        Format_YV12              : QVideoFrame.PixelFormat = ... # 0x13
        Format_UYVY              : QVideoFrame.PixelFormat = ... # 0x14
        Format_YUYV              : QVideoFrame.PixelFormat = ... # 0x15
        Format_NV12              : QVideoFrame.PixelFormat = ... # 0x16
        Format_NV21              : QVideoFrame.PixelFormat = ... # 0x17
        Format_IMC1              : QVideoFrame.PixelFormat = ... # 0x18
        Format_IMC2              : QVideoFrame.PixelFormat = ... # 0x19
        Format_IMC3              : QVideoFrame.PixelFormat = ... # 0x1a
        Format_IMC4              : QVideoFrame.PixelFormat = ... # 0x1b
        Format_Y8                : QVideoFrame.PixelFormat = ... # 0x1c
        Format_Y16               : QVideoFrame.PixelFormat = ... # 0x1d
        Format_Jpeg              : QVideoFrame.PixelFormat = ... # 0x1e
        Format_CameraRaw         : QVideoFrame.PixelFormat = ... # 0x1f
        Format_AdobeDng          : QVideoFrame.PixelFormat = ... # 0x20
        Format_ABGR32            : QVideoFrame.PixelFormat = ... # 0x21
        Format_YUV422P           : QVideoFrame.PixelFormat = ... # 0x22
        NPixelFormats            : QVideoFrame.PixelFormat = ... # 0x23
        Format_User              : QVideoFrame.PixelFormat = ... # 0x3e8

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, buffer: PySide2.QtMultimedia.QAbstractVideoBuffer, size: PySide2.QtCore.QSize, format: PySide2.QtMultimedia.QVideoFrame.PixelFormat): ...
    @typing.overload
    def __init__(self, bytes: int, size: PySide2.QtCore.QSize, bytesPerLine: int, format: PySide2.QtMultimedia.QVideoFrame.PixelFormat): ...
    @typing.overload
    def __init__(self, image: PySide2.QtGui.QImage): ...
    @typing.overload
    def __init__(self, other: PySide2.QtMultimedia.QVideoFrame): ...

    def __copy__(self): ...
    def availableMetaData(self) -> typing.Dict[str, typing.Any]: ...
    def bits(self) -> bytes: ...
    def buffer(self) -> PySide2.QtMultimedia.QAbstractVideoBuffer: ...
    @typing.overload
    def bytesPerLine(self) -> int: ...
    @typing.overload
    def bytesPerLine(self, plane: int) -> int: ...
    def endTime(self) -> int: ...
    def fieldType(self) -> PySide2.QtMultimedia.QVideoFrame.FieldType: ...
    def handle(self) -> typing.Any: ...
    def handleType(self) -> PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType: ...
    def height(self) -> int: ...
    @staticmethod
    def imageFormatFromPixelFormat(format: PySide2.QtMultimedia.QVideoFrame.PixelFormat) -> PySide2.QtGui.QImage.Format: ...
    def isMapped(self) -> bool: ...
    def isReadable(self) -> bool: ...
    def isValid(self) -> bool: ...
    def isWritable(self) -> bool: ...
    def map(self, mode: PySide2.QtMultimedia.QAbstractVideoBuffer.MapMode) -> bool: ...
    def mapMode(self) -> PySide2.QtMultimedia.QAbstractVideoBuffer.MapMode: ...
    def mappedBytes(self) -> int: ...
    def metaData(self, key: str) -> typing.Any: ...
    def pixelFormat(self) -> PySide2.QtMultimedia.QVideoFrame.PixelFormat: ...
    @staticmethod
    def pixelFormatFromImageFormat(format: PySide2.QtGui.QImage.Format) -> PySide2.QtMultimedia.QVideoFrame.PixelFormat: ...
    def planeCount(self) -> int: ...
    def setEndTime(self, time: int): ...
    def setFieldType(self, arg__1: PySide2.QtMultimedia.QVideoFrame.FieldType): ...
    def setMetaData(self, key: str, value: typing.Any): ...
    def setStartTime(self, time: int): ...
    def size(self) -> PySide2.QtCore.QSize: ...
    def startTime(self) -> int: ...
    def unmap(self): ...
    def width(self) -> int: ...


class QVideoProbe(PySide2.QtCore.QObject):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def isActive(self) -> bool: ...
    @typing.overload
    def setSource(self, source: PySide2.QtMultimedia.QMediaObject) -> bool: ...
    @typing.overload
    def setSource(self, source: PySide2.QtMultimedia.QMediaRecorder) -> bool: ...


class QVideoRendererControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def setSurface(self, surface: PySide2.QtMultimedia.QAbstractVideoSurface): ...
    def surface(self) -> PySide2.QtMultimedia.QAbstractVideoSurface: ...


class QVideoSurfaceFormat(Shiboken.Object):
    TopToBottom              : QVideoSurfaceFormat = ... # 0x0
    YCbCr_Undefined          : QVideoSurfaceFormat = ... # 0x0
    BottomToTop              : QVideoSurfaceFormat = ... # 0x1
    YCbCr_BT601              : QVideoSurfaceFormat = ... # 0x1
    YCbCr_BT709              : QVideoSurfaceFormat = ... # 0x2
    YCbCr_xvYCC601           : QVideoSurfaceFormat = ... # 0x3
    YCbCr_xvYCC709           : QVideoSurfaceFormat = ... # 0x4
    YCbCr_JPEG               : QVideoSurfaceFormat = ... # 0x5
    YCbCr_CustomMatrix       : QVideoSurfaceFormat = ... # 0x6

    class Direction(object):
        TopToBottom              : QVideoSurfaceFormat.Direction = ... # 0x0
        BottomToTop              : QVideoSurfaceFormat.Direction = ... # 0x1

    class YCbCrColorSpace(object):
        YCbCr_Undefined          : QVideoSurfaceFormat.YCbCrColorSpace = ... # 0x0
        YCbCr_BT601              : QVideoSurfaceFormat.YCbCrColorSpace = ... # 0x1
        YCbCr_BT709              : QVideoSurfaceFormat.YCbCrColorSpace = ... # 0x2
        YCbCr_xvYCC601           : QVideoSurfaceFormat.YCbCrColorSpace = ... # 0x3
        YCbCr_xvYCC709           : QVideoSurfaceFormat.YCbCrColorSpace = ... # 0x4
        YCbCr_JPEG               : QVideoSurfaceFormat.YCbCrColorSpace = ... # 0x5
        YCbCr_CustomMatrix       : QVideoSurfaceFormat.YCbCrColorSpace = ... # 0x6

    @typing.overload
    def __init__(self): ...
    @typing.overload
    def __init__(self, format: PySide2.QtMultimedia.QVideoSurfaceFormat): ...
    @typing.overload
    def __init__(self, size: PySide2.QtCore.QSize, pixelFormat: PySide2.QtMultimedia.QVideoFrame.PixelFormat, handleType: PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType = ...): ...

    def __copy__(self): ...
    def frameHeight(self) -> int: ...
    def frameRate(self) -> float: ...
    def frameSize(self) -> PySide2.QtCore.QSize: ...
    def frameWidth(self) -> int: ...
    def handleType(self) -> PySide2.QtMultimedia.QAbstractVideoBuffer.HandleType: ...
    def isMirrored(self) -> bool: ...
    def isValid(self) -> bool: ...
    def pixelAspectRatio(self) -> PySide2.QtCore.QSize: ...
    def pixelFormat(self) -> PySide2.QtMultimedia.QVideoFrame.PixelFormat: ...
    def property(self, name: bytes) -> typing.Any: ...
    def propertyNames(self) -> typing.List[PySide2.QtCore.QByteArray]: ...
    def scanLineDirection(self) -> PySide2.QtMultimedia.QVideoSurfaceFormat.Direction: ...
    def setFrameRate(self, rate: float): ...
    @typing.overload
    def setFrameSize(self, size: PySide2.QtCore.QSize): ...
    @typing.overload
    def setFrameSize(self, width: int, height: int): ...
    def setMirrored(self, mirrored: bool): ...
    @typing.overload
    def setPixelAspectRatio(self, ratio: PySide2.QtCore.QSize): ...
    @typing.overload
    def setPixelAspectRatio(self, width: int, height: int): ...
    def setProperty(self, name: bytes, value: typing.Any): ...
    def setScanLineDirection(self, direction: PySide2.QtMultimedia.QVideoSurfaceFormat.Direction): ...
    def setViewport(self, viewport: PySide2.QtCore.QRect): ...
    def setYCbCrColorSpace(self, colorSpace: PySide2.QtMultimedia.QVideoSurfaceFormat.YCbCrColorSpace): ...
    def sizeHint(self) -> PySide2.QtCore.QSize: ...
    def viewport(self) -> PySide2.QtCore.QRect: ...
    def yCbCrColorSpace(self) -> PySide2.QtMultimedia.QVideoSurfaceFormat.YCbCrColorSpace: ...


class QVideoWindowControl(PySide2.QtMultimedia.QMediaControl):

    def __init__(self, parent: typing.Optional[PySide2.QtCore.QObject] = ...): ...

    def aspectRatioMode(self) -> PySide2.QtCore.Qt.AspectRatioMode: ...
    def brightness(self) -> int: ...
    def contrast(self) -> int: ...
    def displayRect(self) -> PySide2.QtCore.QRect: ...
    def hue(self) -> int: ...
    def isFullScreen(self) -> bool: ...
    def nativeSize(self) -> PySide2.QtCore.QSize: ...
    def repaint(self): ...
    def saturation(self) -> int: ...
    def setAspectRatioMode(self, mode: PySide2.QtCore.Qt.AspectRatioMode): ...
    def setBrightness(self, brightness: int): ...
    def setContrast(self, contrast: int): ...
    def setDisplayRect(self, rect: PySide2.QtCore.QRect): ...
    def setFullScreen(self, fullScreen: bool): ...
    def setHue(self, hue: int): ...
    def setSaturation(self, saturation: int): ...
    def setWinId(self, id: int): ...
    def winId(self) -> int: ...

# eof
