# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _openshot
else:
    import _openshot

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _openshot.delete_SwigPyIterator

    def value(self, *args):
        r"""value(SwigPyIterator self) -> PyObject *"""
        return _openshot.SwigPyIterator_value(self, *args)

    def incr(self, *args):
        r"""incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _openshot.SwigPyIterator_incr(self, *args)

    def decr(self, *args):
        r"""decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _openshot.SwigPyIterator_decr(self, *args)

    def distance(self, *args):
        r"""distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _openshot.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        r"""equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _openshot.SwigPyIterator_equal(self, *args)

    def copy(self, *args):
        r"""copy(SwigPyIterator self) -> SwigPyIterator"""
        return _openshot.SwigPyIterator_copy(self, *args)

    def next(self, *args):
        r"""next(SwigPyIterator self) -> PyObject *"""
        return _openshot.SwigPyIterator_next(self, *args)

    def __next__(self, *args):
        r"""__next__(SwigPyIterator self) -> PyObject *"""
        return _openshot.SwigPyIterator___next__(self, *args)

    def previous(self, *args):
        r"""previous(SwigPyIterator self) -> PyObject *"""
        return _openshot.SwigPyIterator_previous(self, *args)

    def advance(self, *args):
        r"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _openshot.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        r"""__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _openshot.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        r"""__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _openshot.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        r"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _openshot.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        r"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _openshot.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        r"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _openshot.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _openshot.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _openshot:
_openshot.SwigPyIterator_swigregister(SwigPyIterator)

SHARED_PTR_DISOWN = _openshot.SHARED_PTR_DISOWN

OPENSHOT_VERSION_ALL = _openshot.OPENSHOT_VERSION_ALL

OPENSHOT_VERSION_FULL = _openshot.OPENSHOT_VERSION_FULL

OPENSHOT_VERSION_MAJOR_MINOR = _openshot.OPENSHOT_VERSION_MAJOR_MINOR

OPENSHOT_VERSION_MAJOR = _openshot.OPENSHOT_VERSION_MAJOR

OPENSHOT_VERSION_MINOR = _openshot.OPENSHOT_VERSION_MINOR

OPENSHOT_VERSION_BUILD = _openshot.OPENSHOT_VERSION_BUILD

OPENSHOT_VERSION_SO = _openshot.OPENSHOT_VERSION_SO

class OpenShotVersion(object):
    r"""Proxy of C++ openshot::OpenShotVersion class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    Major = _openshot.OpenShotVersion_Major
    
    Minor = _openshot.OpenShotVersion_Minor
    
    Build = _openshot.OpenShotVersion_Build
    
    So = _openshot.OpenShotVersion_So
    

    @staticmethod
    def ToString(*args):
        r"""ToString() -> std::string const"""
        return _openshot.OpenShotVersion_ToString(*args)

    def __str__(self, *args):
        r"""__str__(OpenShotVersion self) -> std::string const"""
        return _openshot.OpenShotVersion___str__(self, *args)

    def __repr__(self, *args):
        r"""__repr__(OpenShotVersion self) -> std::string const"""
        return _openshot.OpenShotVersion___repr__(self, *args)

    def __init__(self, *args):
        r"""__init__(OpenShotVersion self) -> OpenShotVersion"""
        _openshot.OpenShotVersion_swiginit(self, _openshot.new_OpenShotVersion(*args))
    __swig_destroy__ = _openshot.delete_OpenShotVersion

# Register OpenShotVersion in _openshot:
_openshot.OpenShotVersion_swigregister(OpenShotVersion)

def OpenShotVersion_ToString(*args):
    r"""OpenShotVersion_ToString() -> std::string const"""
    return _openshot.OpenShotVersion_ToString(*args)


def GetVersion(*args):
    r"""GetVersion() -> OpenShotVersion"""
    return _openshot.GetVersion(*args)
class ReaderInfo(object):
    r"""Proxy of C++ openshot::ReaderInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    has_video = property(_openshot.ReaderInfo_has_video_get, _openshot.ReaderInfo_has_video_set, doc=r"""has_video : bool""")
    has_audio = property(_openshot.ReaderInfo_has_audio_get, _openshot.ReaderInfo_has_audio_set, doc=r"""has_audio : bool""")
    has_single_image = property(_openshot.ReaderInfo_has_single_image_get, _openshot.ReaderInfo_has_single_image_set, doc=r"""has_single_image : bool""")
    duration = property(_openshot.ReaderInfo_duration_get, _openshot.ReaderInfo_duration_set, doc=r"""duration : float""")
    file_size = property(_openshot.ReaderInfo_file_size_get, _openshot.ReaderInfo_file_size_set, doc=r"""file_size : int64_t""")
    height = property(_openshot.ReaderInfo_height_get, _openshot.ReaderInfo_height_set, doc=r"""height : int""")
    width = property(_openshot.ReaderInfo_width_get, _openshot.ReaderInfo_width_set, doc=r"""width : int""")
    pixel_format = property(_openshot.ReaderInfo_pixel_format_get, _openshot.ReaderInfo_pixel_format_set, doc=r"""pixel_format : int""")
    fps = property(_openshot.ReaderInfo_fps_get, _openshot.ReaderInfo_fps_set, doc=r"""fps : openshot::Fraction""")
    video_bit_rate = property(_openshot.ReaderInfo_video_bit_rate_get, _openshot.ReaderInfo_video_bit_rate_set, doc=r"""video_bit_rate : int""")
    pixel_ratio = property(_openshot.ReaderInfo_pixel_ratio_get, _openshot.ReaderInfo_pixel_ratio_set, doc=r"""pixel_ratio : openshot::Fraction""")
    display_ratio = property(_openshot.ReaderInfo_display_ratio_get, _openshot.ReaderInfo_display_ratio_set, doc=r"""display_ratio : openshot::Fraction""")
    vcodec = property(_openshot.ReaderInfo_vcodec_get, _openshot.ReaderInfo_vcodec_set, doc=r"""vcodec : std::string""")
    video_length = property(_openshot.ReaderInfo_video_length_get, _openshot.ReaderInfo_video_length_set, doc=r"""video_length : int64_t""")
    video_stream_index = property(_openshot.ReaderInfo_video_stream_index_get, _openshot.ReaderInfo_video_stream_index_set, doc=r"""video_stream_index : int""")
    video_timebase = property(_openshot.ReaderInfo_video_timebase_get, _openshot.ReaderInfo_video_timebase_set, doc=r"""video_timebase : openshot::Fraction""")
    interlaced_frame = property(_openshot.ReaderInfo_interlaced_frame_get, _openshot.ReaderInfo_interlaced_frame_set, doc=r"""interlaced_frame : bool""")
    top_field_first = property(_openshot.ReaderInfo_top_field_first_get, _openshot.ReaderInfo_top_field_first_set, doc=r"""top_field_first : bool""")
    acodec = property(_openshot.ReaderInfo_acodec_get, _openshot.ReaderInfo_acodec_set, doc=r"""acodec : std::string""")
    audio_bit_rate = property(_openshot.ReaderInfo_audio_bit_rate_get, _openshot.ReaderInfo_audio_bit_rate_set, doc=r"""audio_bit_rate : int""")
    sample_rate = property(_openshot.ReaderInfo_sample_rate_get, _openshot.ReaderInfo_sample_rate_set, doc=r"""sample_rate : int""")
    channels = property(_openshot.ReaderInfo_channels_get, _openshot.ReaderInfo_channels_set, doc=r"""channels : int""")
    channel_layout = property(_openshot.ReaderInfo_channel_layout_get, _openshot.ReaderInfo_channel_layout_set, doc=r"""channel_layout : openshot::ChannelLayout""")
    audio_stream_index = property(_openshot.ReaderInfo_audio_stream_index_get, _openshot.ReaderInfo_audio_stream_index_set, doc=r"""audio_stream_index : int""")
    audio_timebase = property(_openshot.ReaderInfo_audio_timebase_get, _openshot.ReaderInfo_audio_timebase_set, doc=r"""audio_timebase : openshot::Fraction""")
    metadata = property(_openshot.ReaderInfo_metadata_get, _openshot.ReaderInfo_metadata_set, doc=r"""metadata : std::map<(std::string,std::string,std::less<(std::string)>,std::allocator<(std::pair<(q(const).std::string,std::string)>)>)>""")

    def __init__(self, *args):
        r"""__init__(ReaderInfo self) -> ReaderInfo"""
        _openshot.ReaderInfo_swiginit(self, _openshot.new_ReaderInfo(*args))
    __swig_destroy__ = _openshot.delete_ReaderInfo

# Register ReaderInfo in _openshot:
_openshot.ReaderInfo_swigregister(ReaderInfo)
cvar = _openshot.cvar
Version = cvar.Version

class ReaderBase(object):
    r"""Proxy of C++ openshot::ReaderBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    info = property(_openshot.ReaderBase_info_get, _openshot.ReaderBase_info_set, doc=r"""info : openshot::ReaderInfo""")

    def GetClip(self, *args):
        r"""GetClip(ReaderBase self) -> ClipBase"""
        return _openshot.ReaderBase_GetClip(self, *args)

    def SetClip(self, *args):
        r"""SetClip(ReaderBase self, ClipBase clip)"""
        return _openshot.ReaderBase_SetClip(self, *args)

    def Close(self, *args):
        r"""Close(ReaderBase self)"""
        return _openshot.ReaderBase_Close(self, *args)

    def DisplayInfo(self, *args):
        r"""DisplayInfo(ReaderBase self)"""
        return _openshot.ReaderBase_DisplayInfo(self, *args)

    def GetCache(self, *args):
        r"""GetCache(ReaderBase self) -> CacheBase"""
        return _openshot.ReaderBase_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(ReaderBase self, int64_t number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.ReaderBase_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(ReaderBase self) -> bool"""
        return _openshot.ReaderBase_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(ReaderBase self) -> std::string"""
        return _openshot.ReaderBase_Name(self, *args)

    def Json(self, *args):
        r"""Json(ReaderBase self) -> std::string"""
        return _openshot.ReaderBase_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(ReaderBase self, std::string const value)"""
        return _openshot.ReaderBase_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(ReaderBase self) -> Json::Value"""
        return _openshot.ReaderBase_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(ReaderBase self, Json::Value const root)"""
        return _openshot.ReaderBase_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(ReaderBase self)"""
        return _openshot.ReaderBase_Open(self, *args)
    __swig_destroy__ = _openshot.delete_ReaderBase

# Register ReaderBase in _openshot:
_openshot.ReaderBase_swigregister(ReaderBase)

class WriterInfo(object):
    r"""Proxy of C++ openshot::WriterInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    has_video = property(_openshot.WriterInfo_has_video_get, _openshot.WriterInfo_has_video_set, doc=r"""has_video : bool""")
    has_audio = property(_openshot.WriterInfo_has_audio_get, _openshot.WriterInfo_has_audio_set, doc=r"""has_audio : bool""")
    has_single_image = property(_openshot.WriterInfo_has_single_image_get, _openshot.WriterInfo_has_single_image_set, doc=r"""has_single_image : bool""")
    duration = property(_openshot.WriterInfo_duration_get, _openshot.WriterInfo_duration_set, doc=r"""duration : float""")
    file_size = property(_openshot.WriterInfo_file_size_get, _openshot.WriterInfo_file_size_set, doc=r"""file_size : int64_t""")
    height = property(_openshot.WriterInfo_height_get, _openshot.WriterInfo_height_set, doc=r"""height : int""")
    width = property(_openshot.WriterInfo_width_get, _openshot.WriterInfo_width_set, doc=r"""width : int""")
    pixel_format = property(_openshot.WriterInfo_pixel_format_get, _openshot.WriterInfo_pixel_format_set, doc=r"""pixel_format : int""")
    fps = property(_openshot.WriterInfo_fps_get, _openshot.WriterInfo_fps_set, doc=r"""fps : openshot::Fraction""")
    video_bit_rate = property(_openshot.WriterInfo_video_bit_rate_get, _openshot.WriterInfo_video_bit_rate_set, doc=r"""video_bit_rate : int""")
    pixel_ratio = property(_openshot.WriterInfo_pixel_ratio_get, _openshot.WriterInfo_pixel_ratio_set, doc=r"""pixel_ratio : openshot::Fraction""")
    display_ratio = property(_openshot.WriterInfo_display_ratio_get, _openshot.WriterInfo_display_ratio_set, doc=r"""display_ratio : openshot::Fraction""")
    vcodec = property(_openshot.WriterInfo_vcodec_get, _openshot.WriterInfo_vcodec_set, doc=r"""vcodec : std::string""")
    video_length = property(_openshot.WriterInfo_video_length_get, _openshot.WriterInfo_video_length_set, doc=r"""video_length : int64_t""")
    video_stream_index = property(_openshot.WriterInfo_video_stream_index_get, _openshot.WriterInfo_video_stream_index_set, doc=r"""video_stream_index : int""")
    video_timebase = property(_openshot.WriterInfo_video_timebase_get, _openshot.WriterInfo_video_timebase_set, doc=r"""video_timebase : openshot::Fraction""")
    interlaced_frame = property(_openshot.WriterInfo_interlaced_frame_get, _openshot.WriterInfo_interlaced_frame_set, doc=r"""interlaced_frame : bool""")
    top_field_first = property(_openshot.WriterInfo_top_field_first_get, _openshot.WriterInfo_top_field_first_set, doc=r"""top_field_first : bool""")
    acodec = property(_openshot.WriterInfo_acodec_get, _openshot.WriterInfo_acodec_set, doc=r"""acodec : std::string""")
    audio_bit_rate = property(_openshot.WriterInfo_audio_bit_rate_get, _openshot.WriterInfo_audio_bit_rate_set, doc=r"""audio_bit_rate : int""")
    sample_rate = property(_openshot.WriterInfo_sample_rate_get, _openshot.WriterInfo_sample_rate_set, doc=r"""sample_rate : int""")
    channels = property(_openshot.WriterInfo_channels_get, _openshot.WriterInfo_channels_set, doc=r"""channels : int""")
    channel_layout = property(_openshot.WriterInfo_channel_layout_get, _openshot.WriterInfo_channel_layout_set, doc=r"""channel_layout : openshot::ChannelLayout""")
    audio_stream_index = property(_openshot.WriterInfo_audio_stream_index_get, _openshot.WriterInfo_audio_stream_index_set, doc=r"""audio_stream_index : int""")
    audio_timebase = property(_openshot.WriterInfo_audio_timebase_get, _openshot.WriterInfo_audio_timebase_set, doc=r"""audio_timebase : openshot::Fraction""")
    metadata = property(_openshot.WriterInfo_metadata_get, _openshot.WriterInfo_metadata_set, doc=r"""metadata : std::map<(std::string,std::string,std::less<(std::string)>,std::allocator<(std::pair<(q(const).std::string,std::string)>)>)>""")

    def __init__(self, *args):
        r"""__init__(WriterInfo self) -> WriterInfo"""
        _openshot.WriterInfo_swiginit(self, _openshot.new_WriterInfo(*args))
    __swig_destroy__ = _openshot.delete_WriterInfo

# Register WriterInfo in _openshot:
_openshot.WriterInfo_swigregister(WriterInfo)

class WriterBase(object):
    r"""Proxy of C++ openshot::WriterBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    info = property(_openshot.WriterBase_info_get, _openshot.WriterBase_info_set, doc=r"""info : openshot::WriterInfo""")

    def CopyReaderInfo(self, *args):
        r"""CopyReaderInfo(WriterBase self, ReaderBase reader)"""
        return _openshot.WriterBase_CopyReaderInfo(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(WriterBase self) -> bool"""
        return _openshot.WriterBase_IsOpen(self, *args)

    def WriteFrame(self, *args):
        r"""
        WriteFrame(WriterBase self, std::shared_ptr< openshot::Frame > frame)
        WriteFrame(WriterBase self, ReaderBase reader, int64_t start, int64_t length)
        """
        return _openshot.WriterBase_WriteFrame(self, *args)

    def Json(self, *args):
        r"""Json(WriterBase self) -> std::string"""
        return _openshot.WriterBase_Json(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(WriterBase self) -> Json::Value"""
        return _openshot.WriterBase_JsonValue(self, *args)

    def SetJson(self, *args):
        r"""SetJson(WriterBase self, std::string const value)"""
        return _openshot.WriterBase_SetJson(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(WriterBase self, Json::Value const root)"""
        return _openshot.WriterBase_SetJsonValue(self, *args)

    def DisplayInfo(self, *args):
        r"""DisplayInfo(WriterBase self)"""
        return _openshot.WriterBase_DisplayInfo(self, *args)

    def Open(self, *args):
        r"""Open(WriterBase self)"""
        return _openshot.WriterBase_Open(self, *args)
    __swig_destroy__ = _openshot.delete_WriterBase

# Register WriterBase in _openshot:
_openshot.WriterBase_swigregister(WriterBase)

class CacheBase(object):
    r"""Proxy of C++ openshot::CacheBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def Add(self, *args):
        r"""Add(CacheBase self, std::shared_ptr< openshot::Frame > frame)"""
        return _openshot.CacheBase_Add(self, *args)

    def Clear(self, *args):
        r"""Clear(CacheBase self)"""
        return _openshot.CacheBase_Clear(self, *args)

    def Count(self, *args):
        r"""Count(CacheBase self) -> int64_t"""
        return _openshot.CacheBase_Count(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(CacheBase self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheBase_GetFrame(self, *args)

    def GetBytes(self, *args):
        r"""GetBytes(CacheBase self) -> int64_t"""
        return _openshot.CacheBase_GetBytes(self, *args)

    def GetSmallestFrame(self, *args):
        r"""GetSmallestFrame(CacheBase self) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheBase_GetSmallestFrame(self, *args)

    def Remove(self, *args):
        r"""
        Remove(CacheBase self, int64_t frame_number)
        Remove(CacheBase self, int64_t start_frame_number, int64_t end_frame_number)
        """
        return _openshot.CacheBase_Remove(self, *args)

    def GetMaxBytes(self, *args):
        r"""GetMaxBytes(CacheBase self) -> int64_t"""
        return _openshot.CacheBase_GetMaxBytes(self, *args)

    def SetMaxBytes(self, *args):
        r"""SetMaxBytes(CacheBase self, int64_t number_of_bytes)"""
        return _openshot.CacheBase_SetMaxBytes(self, *args)

    def SetMaxBytesFromInfo(self, *args):
        r"""SetMaxBytesFromInfo(CacheBase self, int64_t number_of_frames, int width, int height, int sample_rate, int channels)"""
        return _openshot.CacheBase_SetMaxBytesFromInfo(self, *args)

    def Json(self, *args):
        r"""Json(CacheBase self) -> std::string"""
        return _openshot.CacheBase_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(CacheBase self, std::string const value)"""
        return _openshot.CacheBase_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(CacheBase self) -> Json::Value"""
        return _openshot.CacheBase_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(CacheBase self, Json::Value const root)"""
        return _openshot.CacheBase_SetJsonValue(self, *args)
    __swig_destroy__ = _openshot.delete_CacheBase

# Register CacheBase in _openshot:
_openshot.CacheBase_swigregister(CacheBase)

class CacheDisk(CacheBase):
    r"""Proxy of C++ openshot::CacheDisk class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(CacheDisk self, std::string cache_path, std::string format, float quality, float scale) -> CacheDisk
        __init__(CacheDisk self, std::string cache_path, std::string format, float quality, float scale, int64_t max_bytes) -> CacheDisk
        """
        _openshot.CacheDisk_swiginit(self, _openshot.new_CacheDisk(*args))
    __swig_destroy__ = _openshot.delete_CacheDisk

    def Add(self, *args):
        r"""Add(CacheDisk self, std::shared_ptr< openshot::Frame > frame)"""
        return _openshot.CacheDisk_Add(self, *args)

    def Clear(self, *args):
        r"""Clear(CacheDisk self)"""
        return _openshot.CacheDisk_Clear(self, *args)

    def Count(self, *args):
        r"""Count(CacheDisk self) -> int64_t"""
        return _openshot.CacheDisk_Count(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(CacheDisk self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheDisk_GetFrame(self, *args)

    def GetBytes(self, *args):
        r"""GetBytes(CacheDisk self) -> int64_t"""
        return _openshot.CacheDisk_GetBytes(self, *args)

    def GetSmallestFrame(self, *args):
        r"""GetSmallestFrame(CacheDisk self) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheDisk_GetSmallestFrame(self, *args)

    def MoveToFront(self, *args):
        r"""MoveToFront(CacheDisk self, int64_t frame_number)"""
        return _openshot.CacheDisk_MoveToFront(self, *args)

    def Remove(self, *args):
        r"""
        Remove(CacheDisk self, int64_t frame_number)
        Remove(CacheDisk self, int64_t start_frame_number, int64_t end_frame_number)
        """
        return _openshot.CacheDisk_Remove(self, *args)

    def Json(self, *args):
        r"""Json(CacheDisk self) -> std::string"""
        return _openshot.CacheDisk_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(CacheDisk self, std::string const value)"""
        return _openshot.CacheDisk_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(CacheDisk self) -> Json::Value"""
        return _openshot.CacheDisk_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(CacheDisk self, Json::Value const root)"""
        return _openshot.CacheDisk_SetJsonValue(self, *args)

# Register CacheDisk in _openshot:
_openshot.CacheDisk_swigregister(CacheDisk)

class CacheMemory(CacheBase):
    r"""Proxy of C++ openshot::CacheMemory class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(CacheMemory self) -> CacheMemory
        __init__(CacheMemory self, int64_t max_bytes) -> CacheMemory
        """
        _openshot.CacheMemory_swiginit(self, _openshot.new_CacheMemory(*args))
    __swig_destroy__ = _openshot.delete_CacheMemory

    def Add(self, *args):
        r"""Add(CacheMemory self, std::shared_ptr< openshot::Frame > frame)"""
        return _openshot.CacheMemory_Add(self, *args)

    def Clear(self, *args):
        r"""Clear(CacheMemory self)"""
        return _openshot.CacheMemory_Clear(self, *args)

    def Count(self, *args):
        r"""Count(CacheMemory self) -> int64_t"""
        return _openshot.CacheMemory_Count(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(CacheMemory self, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheMemory_GetFrame(self, *args)

    def GetBytes(self, *args):
        r"""GetBytes(CacheMemory self) -> int64_t"""
        return _openshot.CacheMemory_GetBytes(self, *args)

    def GetSmallestFrame(self, *args):
        r"""GetSmallestFrame(CacheMemory self) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.CacheMemory_GetSmallestFrame(self, *args)

    def MoveToFront(self, *args):
        r"""MoveToFront(CacheMemory self, int64_t frame_number)"""
        return _openshot.CacheMemory_MoveToFront(self, *args)

    def Remove(self, *args):
        r"""
        Remove(CacheMemory self, int64_t frame_number)
        Remove(CacheMemory self, int64_t start_frame_number, int64_t end_frame_number)
        """
        return _openshot.CacheMemory_Remove(self, *args)

    def Json(self, *args):
        r"""Json(CacheMemory self) -> std::string"""
        return _openshot.CacheMemory_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(CacheMemory self, std::string const value)"""
        return _openshot.CacheMemory_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(CacheMemory self) -> Json::Value"""
        return _openshot.CacheMemory_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(CacheMemory self, Json::Value const root)"""
        return _openshot.CacheMemory_SetJsonValue(self, *args)

# Register CacheMemory in _openshot:
_openshot.CacheMemory_swigregister(CacheMemory)

LAYOUT_MONO = _openshot.LAYOUT_MONO

LAYOUT_STEREO = _openshot.LAYOUT_STEREO

LAYOUT_2POINT1 = _openshot.LAYOUT_2POINT1

LAYOUT_2_1 = _openshot.LAYOUT_2_1

LAYOUT_SURROUND = _openshot.LAYOUT_SURROUND

LAYOUT_3POINT1 = _openshot.LAYOUT_3POINT1

LAYOUT_4POINT0 = _openshot.LAYOUT_4POINT0

LAYOUT_4POINT1 = _openshot.LAYOUT_4POINT1

LAYOUT_2_2 = _openshot.LAYOUT_2_2

LAYOUT_QUAD = _openshot.LAYOUT_QUAD

LAYOUT_5POINT0 = _openshot.LAYOUT_5POINT0

LAYOUT_5POINT1 = _openshot.LAYOUT_5POINT1

LAYOUT_5POINT0_BACK = _openshot.LAYOUT_5POINT0_BACK

LAYOUT_5POINT1_BACK = _openshot.LAYOUT_5POINT1_BACK

LAYOUT_6POINT0 = _openshot.LAYOUT_6POINT0

LAYOUT_6POINT0_FRONT = _openshot.LAYOUT_6POINT0_FRONT

LAYOUT_HEXAGONAL = _openshot.LAYOUT_HEXAGONAL

LAYOUT_6POINT1 = _openshot.LAYOUT_6POINT1

LAYOUT_6POINT1_BACK = _openshot.LAYOUT_6POINT1_BACK

LAYOUT_6POINT1_FRONT = _openshot.LAYOUT_6POINT1_FRONT

LAYOUT_7POINT0 = _openshot.LAYOUT_7POINT0

LAYOUT_7POINT0_FRONT = _openshot.LAYOUT_7POINT0_FRONT

LAYOUT_7POINT1 = _openshot.LAYOUT_7POINT1

LAYOUT_7POINT1_WIDE = _openshot.LAYOUT_7POINT1_WIDE

LAYOUT_7POINT1_WIDE_BACK = _openshot.LAYOUT_7POINT1_WIDE_BACK

LAYOUT_OCTAGONAL = _openshot.LAYOUT_OCTAGONAL

LAYOUT_STEREO_DOWNMIX = _openshot.LAYOUT_STEREO_DOWNMIX

class ChunkLocation(object):
    r"""Proxy of C++ openshot::ChunkLocation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    number = property(_openshot.ChunkLocation_number_get, _openshot.ChunkLocation_number_set, doc=r"""number : int64_t""")
    frame = property(_openshot.ChunkLocation_frame_get, _openshot.ChunkLocation_frame_set, doc=r"""frame : int64_t""")

    def __init__(self, *args):
        r"""__init__(ChunkLocation self) -> ChunkLocation"""
        _openshot.ChunkLocation_swiginit(self, _openshot.new_ChunkLocation(*args))
    __swig_destroy__ = _openshot.delete_ChunkLocation

# Register ChunkLocation in _openshot:
_openshot.ChunkLocation_swigregister(ChunkLocation)

THUMBNAIL = _openshot.THUMBNAIL

PREVIEW = _openshot.PREVIEW

FINAL = _openshot.FINAL

class ChunkReader(ReaderBase):
    r"""Proxy of C++ openshot::ChunkReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ChunkReader self, std::string path, openshot::ChunkVersion chunk_version) -> ChunkReader"""
        _openshot.ChunkReader_swiginit(self, _openshot.new_ChunkReader(*args))

    def Close(self, *args):
        r"""Close(ChunkReader self)"""
        return _openshot.ChunkReader_Close(self, *args)

    def GetChunkSize(self, *args):
        r"""GetChunkSize(ChunkReader self) -> int64_t"""
        return _openshot.ChunkReader_GetChunkSize(self, *args)

    def SetChunkSize(self, *args):
        r"""SetChunkSize(ChunkReader self, int64_t new_size)"""
        return _openshot.ChunkReader_SetChunkSize(self, *args)

    def GetCache(self, *args):
        r"""GetCache(ChunkReader self) -> CacheMemory"""
        return _openshot.ChunkReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(ChunkReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.ChunkReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(ChunkReader self) -> bool"""
        return _openshot.ChunkReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(ChunkReader self) -> std::string"""
        return _openshot.ChunkReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(ChunkReader self) -> std::string"""
        return _openshot.ChunkReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(ChunkReader self, std::string const value)"""
        return _openshot.ChunkReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(ChunkReader self) -> Json::Value"""
        return _openshot.ChunkReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(ChunkReader self, Json::Value const root)"""
        return _openshot.ChunkReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(ChunkReader self)"""
        return _openshot.ChunkReader_Open(self, *args)
    __swig_destroy__ = _openshot.delete_ChunkReader

# Register ChunkReader in _openshot:
_openshot.ChunkReader_swigregister(ChunkReader)

class ChunkWriter(WriterBase):
    r"""Proxy of C++ openshot::ChunkWriter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ChunkWriter self, std::string path, ReaderBase reader) -> ChunkWriter"""
        _openshot.ChunkWriter_swiginit(self, _openshot.new_ChunkWriter(*args))

    def Close(self, *args):
        r"""Close(ChunkWriter self)"""
        return _openshot.ChunkWriter_Close(self, *args)

    def GetChunkSize(self, *args):
        r"""GetChunkSize(ChunkWriter self) -> int64_t"""
        return _openshot.ChunkWriter_GetChunkSize(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(ChunkWriter self) -> bool"""
        return _openshot.ChunkWriter_IsOpen(self, *args)

    def Open(self, *args):
        r"""Open(ChunkWriter self)"""
        return _openshot.ChunkWriter_Open(self, *args)

    def SetChunkSize(self, *args):
        r"""SetChunkSize(ChunkWriter self, int64_t new_size)"""
        return _openshot.ChunkWriter_SetChunkSize(self, *args)

    def WriteFrame(self, *args):
        r"""
        WriteFrame(ChunkWriter self, std::shared_ptr< openshot::Frame > frame)
        WriteFrame(ChunkWriter self, int64_t start, int64_t length)
        WriteFrame(ChunkWriter self, ReaderBase reader, int64_t start, int64_t length)
        """
        return _openshot.ChunkWriter_WriteFrame(self, *args)
    __swig_destroy__ = _openshot.delete_ChunkWriter

# Register ChunkWriter in _openshot:
_openshot.ChunkWriter_swigregister(ChunkWriter)

class ClipBase(object):
    r"""Proxy of C++ openshot::ClipBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def __lt__(self, *args):
        r"""__lt__(ClipBase self, ClipBase a) -> bool"""
        return _openshot.ClipBase___lt__(self, *args)

    def __le__(self, *args):
        r"""__le__(ClipBase self, ClipBase a) -> bool"""
        return _openshot.ClipBase___le__(self, *args)

    def __gt__(self, *args):
        r"""__gt__(ClipBase self, ClipBase a) -> bool"""
        return _openshot.ClipBase___gt__(self, *args)

    def __ge__(self, *args):
        r"""__ge__(ClipBase self, ClipBase a) -> bool"""
        return _openshot.ClipBase___ge__(self, *args)

    def Duration(self, *args):
        r"""Duration(ClipBase self) -> float"""
        return _openshot.ClipBase_Duration(self, *args)

    def Id(self, *args):
        r"""
        Id(ClipBase self) -> std::string
        Id(ClipBase self, std::string value)
        """
        return _openshot.ClipBase_Id(self, *args)

    def Position(self, *args):
        r"""
        Position(ClipBase self) -> float
        Position(ClipBase self, float value)
        """
        return _openshot.ClipBase_Position(self, *args)

    def Layer(self, *args):
        r"""
        Layer(ClipBase self) -> int
        Layer(ClipBase self, int value)
        """
        return _openshot.ClipBase_Layer(self, *args)

    def Start(self, *args):
        r"""
        Start(ClipBase self) -> float
        Start(ClipBase self, float value)
        """
        return _openshot.ClipBase_Start(self, *args)

    def End(self, *args):
        r"""
        End(ClipBase self) -> float
        End(ClipBase self, float value)
        """
        return _openshot.ClipBase_End(self, *args)

    def Json(self, *args):
        r"""Json(ClipBase self) -> std::string"""
        return _openshot.ClipBase_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(ClipBase self, std::string const value)"""
        return _openshot.ClipBase_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(ClipBase self) -> Json::Value"""
        return _openshot.ClipBase_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(ClipBase self, Json::Value const root)"""
        return _openshot.ClipBase_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(ClipBase self, int64_t requested_frame) -> std::string"""
        return _openshot.ClipBase_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_ClipBase

# Register ClipBase in _openshot:
_openshot.ClipBase_swigregister(ClipBase)

class CompareClipEffects(object):
    r"""Proxy of C++ openshot::CompareClipEffects class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __call__(self, *args):
        r"""__call__(CompareClipEffects self, EffectBase lhs, EffectBase rhs) -> bool"""
        return _openshot.CompareClipEffects___call__(self, *args)

    def __init__(self, *args):
        r"""__init__(CompareClipEffects self) -> CompareClipEffects"""
        _openshot.CompareClipEffects_swiginit(self, _openshot.new_CompareClipEffects(*args))
    __swig_destroy__ = _openshot.delete_CompareClipEffects

# Register CompareClipEffects in _openshot:
_openshot.CompareClipEffects_swigregister(CompareClipEffects)

class Clip(ClipBase):
    r"""Proxy of C++ openshot::Clip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    gravity = property(_openshot.Clip_gravity_get, _openshot.Clip_gravity_set, doc=r"""gravity : openshot::GravityType""")
    scale = property(_openshot.Clip_scale_get, _openshot.Clip_scale_set, doc=r"""scale : openshot::ScaleType""")
    anchor = property(_openshot.Clip_anchor_get, _openshot.Clip_anchor_set, doc=r"""anchor : openshot::AnchorType""")
    display = property(_openshot.Clip_display_get, _openshot.Clip_display_set, doc=r"""display : openshot::FrameDisplayType""")
    mixing = property(_openshot.Clip_mixing_get, _openshot.Clip_mixing_set, doc=r"""mixing : openshot::VolumeMixType""")

    def __init__(self, *args):
        r"""
        __init__(Clip self) -> Clip
        __init__(Clip self, std::string path) -> Clip
        __init__(Clip self, ReaderBase new_reader) -> Clip
        """
        _openshot.Clip_swiginit(self, _openshot.new_Clip(*args))
    __swig_destroy__ = _openshot.delete_Clip

    def AddEffect(self, *args):
        r"""AddEffect(Clip self, EffectBase effect)"""
        return _openshot.Clip_AddEffect(self, *args)

    def Close(self, *args):
        r"""Close(Clip self)"""
        return _openshot.Clip_Close(self, *args)

    def Effects(self, *args):
        r"""Effects(Clip self) -> EffectBaseList"""
        return _openshot.Clip_Effects(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(Clip self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Clip_GetFrame(self, *args)

    def Open(self, *args):
        r"""Open(Clip self)"""
        return _openshot.Clip_Open(self, *args)

    def Reader(self, *args):
        r"""
        Reader(Clip self, ReaderBase new_reader)
        Reader(Clip self) -> ReaderBase
        """
        return _openshot.Clip_Reader(self, *args)

    def End(self, *args):
        r"""
        End(Clip self) -> float
        End(Clip self, float value)
        """
        return _openshot.Clip_End(self, *args)

    def Json(self, *args):
        r"""Json(Clip self) -> std::string"""
        return _openshot.Clip_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Clip self, std::string const value)"""
        return _openshot.Clip_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Clip self) -> Json::Value"""
        return _openshot.Clip_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Clip self, Json::Value const root)"""
        return _openshot.Clip_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Clip self, int64_t requested_frame) -> std::string"""
        return _openshot.Clip_PropertiesJSON(self, *args)

    def RemoveEffect(self, *args):
        r"""RemoveEffect(Clip self, EffectBase effect)"""
        return _openshot.Clip_RemoveEffect(self, *args)

    def Waveform(self, *args):
        r"""
        Waveform(Clip self) -> bool
        Waveform(Clip self, bool value)
        """
        return _openshot.Clip_Waveform(self, *args)
    scale_x = property(_openshot.Clip_scale_x_get, _openshot.Clip_scale_x_set, doc=r"""scale_x : openshot::Keyframe""")
    scale_y = property(_openshot.Clip_scale_y_get, _openshot.Clip_scale_y_set, doc=r"""scale_y : openshot::Keyframe""")
    location_x = property(_openshot.Clip_location_x_get, _openshot.Clip_location_x_set, doc=r"""location_x : openshot::Keyframe""")
    location_y = property(_openshot.Clip_location_y_get, _openshot.Clip_location_y_set, doc=r"""location_y : openshot::Keyframe""")
    alpha = property(_openshot.Clip_alpha_get, _openshot.Clip_alpha_set, doc=r"""alpha : openshot::Keyframe""")
    rotation = property(_openshot.Clip_rotation_get, _openshot.Clip_rotation_set, doc=r"""rotation : openshot::Keyframe""")
    time = property(_openshot.Clip_time_get, _openshot.Clip_time_set, doc=r"""time : openshot::Keyframe""")
    volume = property(_openshot.Clip_volume_get, _openshot.Clip_volume_set, doc=r"""volume : openshot::Keyframe""")
    wave_color = property(_openshot.Clip_wave_color_get, _openshot.Clip_wave_color_set, doc=r"""wave_color : openshot::Color""")
    crop_gravity = property(_openshot.Clip_crop_gravity_get, _openshot.Clip_crop_gravity_set, doc=r"""crop_gravity : openshot::GravityType""")
    crop_width = property(_openshot.Clip_crop_width_get, _openshot.Clip_crop_width_set, doc=r"""crop_width : openshot::Keyframe""")
    crop_height = property(_openshot.Clip_crop_height_get, _openshot.Clip_crop_height_set, doc=r"""crop_height : openshot::Keyframe""")
    crop_x = property(_openshot.Clip_crop_x_get, _openshot.Clip_crop_x_set, doc=r"""crop_x : openshot::Keyframe""")
    crop_y = property(_openshot.Clip_crop_y_get, _openshot.Clip_crop_y_set, doc=r"""crop_y : openshot::Keyframe""")
    shear_x = property(_openshot.Clip_shear_x_get, _openshot.Clip_shear_x_set, doc=r"""shear_x : openshot::Keyframe""")
    shear_y = property(_openshot.Clip_shear_y_get, _openshot.Clip_shear_y_set, doc=r"""shear_y : openshot::Keyframe""")
    perspective_c1_x = property(_openshot.Clip_perspective_c1_x_get, _openshot.Clip_perspective_c1_x_set, doc=r"""perspective_c1_x : openshot::Keyframe""")
    perspective_c1_y = property(_openshot.Clip_perspective_c1_y_get, _openshot.Clip_perspective_c1_y_set, doc=r"""perspective_c1_y : openshot::Keyframe""")
    perspective_c2_x = property(_openshot.Clip_perspective_c2_x_get, _openshot.Clip_perspective_c2_x_set, doc=r"""perspective_c2_x : openshot::Keyframe""")
    perspective_c2_y = property(_openshot.Clip_perspective_c2_y_get, _openshot.Clip_perspective_c2_y_set, doc=r"""perspective_c2_y : openshot::Keyframe""")
    perspective_c3_x = property(_openshot.Clip_perspective_c3_x_get, _openshot.Clip_perspective_c3_x_set, doc=r"""perspective_c3_x : openshot::Keyframe""")
    perspective_c3_y = property(_openshot.Clip_perspective_c3_y_get, _openshot.Clip_perspective_c3_y_set, doc=r"""perspective_c3_y : openshot::Keyframe""")
    perspective_c4_x = property(_openshot.Clip_perspective_c4_x_get, _openshot.Clip_perspective_c4_x_set, doc=r"""perspective_c4_x : openshot::Keyframe""")
    perspective_c4_y = property(_openshot.Clip_perspective_c4_y_get, _openshot.Clip_perspective_c4_y_set, doc=r"""perspective_c4_y : openshot::Keyframe""")
    channel_filter = property(_openshot.Clip_channel_filter_get, _openshot.Clip_channel_filter_set, doc=r"""channel_filter : openshot::Keyframe""")
    channel_mapping = property(_openshot.Clip_channel_mapping_get, _openshot.Clip_channel_mapping_set, doc=r"""channel_mapping : openshot::Keyframe""")
    has_audio = property(_openshot.Clip_has_audio_get, _openshot.Clip_has_audio_set, doc=r"""has_audio : openshot::Keyframe""")
    has_video = property(_openshot.Clip_has_video_get, _openshot.Clip_has_video_set, doc=r"""has_video : openshot::Keyframe""")

# Register Clip in _openshot:
_openshot.Clip_swigregister(Clip)

class Coordinate(object):
    r"""Proxy of C++ openshot::Coordinate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    X = property(_openshot.Coordinate_X_get, _openshot.Coordinate_X_set, doc=r"""X : double""")
    Y = property(_openshot.Coordinate_Y_get, _openshot.Coordinate_Y_set, doc=r"""Y : double""")

    def __init__(self, *args):
        r"""
        __init__(Coordinate self) -> Coordinate
        __init__(Coordinate self, double x, double y) -> Coordinate
        """
        _openshot.Coordinate_swiginit(self, _openshot.new_Coordinate(*args))

    def Json(self, *args):
        r"""Json(Coordinate self) -> std::string"""
        return _openshot.Coordinate_Json(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Coordinate self) -> Json::Value"""
        return _openshot.Coordinate_JsonValue(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Coordinate self, std::string const value)"""
        return _openshot.Coordinate_SetJson(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Coordinate self, Json::Value const root)"""
        return _openshot.Coordinate_SetJsonValue(self, *args)
    __swig_destroy__ = _openshot.delete_Coordinate

# Register Coordinate in _openshot:
_openshot.Coordinate_swigregister(Coordinate)

class Color(object):
    r"""Proxy of C++ openshot::Color class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    red = property(_openshot.Color_red_get, _openshot.Color_red_set, doc=r"""red : openshot::Keyframe""")
    green = property(_openshot.Color_green_get, _openshot.Color_green_set, doc=r"""green : openshot::Keyframe""")
    blue = property(_openshot.Color_blue_get, _openshot.Color_blue_set, doc=r"""blue : openshot::Keyframe""")
    alpha = property(_openshot.Color_alpha_get, _openshot.Color_alpha_set, doc=r"""alpha : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Color self) -> Color
        __init__(Color self, std::string color_hex) -> Color
        __init__(Color self, unsigned char Red, unsigned char Green, unsigned char Blue, unsigned char Alpha) -> Color
        __init__(Color self, Keyframe Red, Keyframe Green, Keyframe Blue, Keyframe Alpha) -> Color
        """
        _openshot.Color_swiginit(self, _openshot.new_Color(*args))

    def GetColorHex(self, *args):
        r"""GetColorHex(Color self, int64_t frame_number) -> std::string"""
        return _openshot.Color_GetColorHex(self, *args)

    @staticmethod
    def GetDistance(*args):
        r"""GetDistance(long R1, long G1, long B1, long R2, long G2, long B2) -> long"""
        return _openshot.Color_GetDistance(*args)

    def Json(self, *args):
        r"""Json(Color self) -> std::string"""
        return _openshot.Color_Json(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Color self) -> Json::Value"""
        return _openshot.Color_JsonValue(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Color self, std::string const value)"""
        return _openshot.Color_SetJson(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Color self, Json::Value const root)"""
        return _openshot.Color_SetJsonValue(self, *args)
    __swig_destroy__ = _openshot.delete_Color

# Register Color in _openshot:
_openshot.Color_swigregister(Color)

def Color_GetDistance(*args):
    r"""Color_GetDistance(long R1, long G1, long B1, long R2, long G2, long B2) -> long"""
    return _openshot.Color_GetDistance(*args)

class DummyReader(ReaderBase):
    r"""Proxy of C++ openshot::DummyReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(DummyReader self) -> DummyReader
        __init__(DummyReader self, Fraction fps, int width, int height, int sample_rate, int channels, float duration) -> DummyReader
        """
        _openshot.DummyReader_swiginit(self, _openshot.new_DummyReader(*args))
    __swig_destroy__ = _openshot.delete_DummyReader

    def Close(self, *args):
        r"""Close(DummyReader self)"""
        return _openshot.DummyReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(DummyReader self) -> CacheMemory"""
        return _openshot.DummyReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(DummyReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.DummyReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(DummyReader self) -> bool"""
        return _openshot.DummyReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(DummyReader self) -> std::string"""
        return _openshot.DummyReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(DummyReader self) -> std::string"""
        return _openshot.DummyReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(DummyReader self, std::string const value)"""
        return _openshot.DummyReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(DummyReader self) -> Json::Value"""
        return _openshot.DummyReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(DummyReader self, Json::Value const root)"""
        return _openshot.DummyReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(DummyReader self)"""
        return _openshot.DummyReader_Open(self, *args)

# Register DummyReader in _openshot:
_openshot.DummyReader_swigregister(DummyReader)

class EffectInfoStruct(object):
    r"""Proxy of C++ openshot::EffectInfoStruct class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    class_name = property(_openshot.EffectInfoStruct_class_name_get, _openshot.EffectInfoStruct_class_name_set, doc=r"""class_name : std::string""")
    name = property(_openshot.EffectInfoStruct_name_get, _openshot.EffectInfoStruct_name_set, doc=r"""name : std::string""")
    description = property(_openshot.EffectInfoStruct_description_get, _openshot.EffectInfoStruct_description_set, doc=r"""description : std::string""")
    has_video = property(_openshot.EffectInfoStruct_has_video_get, _openshot.EffectInfoStruct_has_video_set, doc=r"""has_video : bool""")
    has_audio = property(_openshot.EffectInfoStruct_has_audio_get, _openshot.EffectInfoStruct_has_audio_set, doc=r"""has_audio : bool""")

    def __init__(self, *args):
        r"""__init__(EffectInfoStruct self) -> EffectInfoStruct"""
        _openshot.EffectInfoStruct_swiginit(self, _openshot.new_EffectInfoStruct(*args))
    __swig_destroy__ = _openshot.delete_EffectInfoStruct

# Register EffectInfoStruct in _openshot:
_openshot.EffectInfoStruct_swigregister(EffectInfoStruct)

class EffectBase(ClipBase):
    r"""Proxy of C++ openshot::EffectBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    info = property(_openshot.EffectBase_info_get, _openshot.EffectBase_info_set, doc=r"""info : openshot::EffectInfoStruct""")

    def DisplayInfo(self, *args):
        r"""DisplayInfo(EffectBase self)"""
        return _openshot.EffectBase_DisplayInfo(self, *args)

    def constrain(self, *args):
        r"""constrain(EffectBase self, int color_value) -> int"""
        return _openshot.EffectBase_constrain(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(EffectBase self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.EffectBase_GetFrame(self, *args)

    def InitEffectInfo(self, *args):
        r"""InitEffectInfo(EffectBase self)"""
        return _openshot.EffectBase_InitEffectInfo(self, *args)

    def Json(self, *args):
        r"""Json(EffectBase self) -> std::string"""
        return _openshot.EffectBase_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(EffectBase self, std::string const value)"""
        return _openshot.EffectBase_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(EffectBase self) -> Json::Value"""
        return _openshot.EffectBase_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(EffectBase self, Json::Value const root)"""
        return _openshot.EffectBase_SetJsonValue(self, *args)

    def JsonInfo(self, *args):
        r"""JsonInfo(EffectBase self) -> Json::Value"""
        return _openshot.EffectBase_JsonInfo(self, *args)

    def Order(self, *args):
        r"""
        Order(EffectBase self) -> int
        Order(EffectBase self, int new_order)
        """
        return _openshot.EffectBase_Order(self, *args)
    __swig_destroy__ = _openshot.delete_EffectBase

# Register EffectBase in _openshot:
_openshot.EffectBase_swigregister(EffectBase)

class EffectInfo(object):
    r"""Proxy of C++ openshot::EffectInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def CreateEffect(self, *args):
        r"""CreateEffect(EffectInfo self, std::string effect_type) -> EffectBase"""
        return _openshot.EffectInfo_CreateEffect(self, *args)

    @staticmethod
    def Json(*args):
        r"""Json() -> std::string"""
        return _openshot.EffectInfo_Json(*args)

    @staticmethod
    def JsonValue(*args):
        r"""JsonValue() -> Json::Value"""
        return _openshot.EffectInfo_JsonValue(*args)

    def __init__(self, *args):
        r"""__init__(EffectInfo self) -> EffectInfo"""
        _openshot.EffectInfo_swiginit(self, _openshot.new_EffectInfo(*args))
    __swig_destroy__ = _openshot.delete_EffectInfo

# Register EffectInfo in _openshot:
_openshot.EffectInfo_swigregister(EffectInfo)

def EffectInfo_Json(*args):
    r"""EffectInfo_Json() -> std::string"""
    return _openshot.EffectInfo_Json(*args)

def EffectInfo_JsonValue(*args):
    r"""EffectInfo_JsonValue() -> Json::Value"""
    return _openshot.EffectInfo_JsonValue(*args)

GRAVITY_TOP_LEFT = _openshot.GRAVITY_TOP_LEFT

GRAVITY_TOP = _openshot.GRAVITY_TOP

GRAVITY_TOP_RIGHT = _openshot.GRAVITY_TOP_RIGHT

GRAVITY_LEFT = _openshot.GRAVITY_LEFT

GRAVITY_CENTER = _openshot.GRAVITY_CENTER

GRAVITY_RIGHT = _openshot.GRAVITY_RIGHT

GRAVITY_BOTTOM_LEFT = _openshot.GRAVITY_BOTTOM_LEFT

GRAVITY_BOTTOM = _openshot.GRAVITY_BOTTOM

GRAVITY_BOTTOM_RIGHT = _openshot.GRAVITY_BOTTOM_RIGHT

SCALE_CROP = _openshot.SCALE_CROP

SCALE_FIT = _openshot.SCALE_FIT

SCALE_STRETCH = _openshot.SCALE_STRETCH

SCALE_NONE = _openshot.SCALE_NONE

ANCHOR_CANVAS = _openshot.ANCHOR_CANVAS

ANCHOR_VIEWPORT = _openshot.ANCHOR_VIEWPORT

FRAME_DISPLAY_NONE = _openshot.FRAME_DISPLAY_NONE

FRAME_DISPLAY_CLIP = _openshot.FRAME_DISPLAY_CLIP

FRAME_DISPLAY_TIMELINE = _openshot.FRAME_DISPLAY_TIMELINE

FRAME_DISPLAY_BOTH = _openshot.FRAME_DISPLAY_BOTH

VOLUME_MIX_NONE = _openshot.VOLUME_MIX_NONE

VOLUME_MIX_AVERAGE = _openshot.VOLUME_MIX_AVERAGE

VOLUME_MIX_REDUCE = _openshot.VOLUME_MIX_REDUCE

class BaseException(object):
    r"""Proxy of C++ openshot::BaseException class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(BaseException self, std::string message) -> BaseException"""
        _openshot.BaseException_swiginit(self, _openshot.new_BaseException(*args))
    __swig_destroy__ = _openshot.delete_BaseException

    def what(self, *args):
        r"""what(BaseException self) -> char const *"""
        return _openshot.BaseException_what(self, *args)

# Register BaseException in _openshot:
_openshot.BaseException_swigregister(BaseException)

class ChunkNotFound(BaseException):
    r"""Proxy of C++ openshot::ChunkNotFound class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    frame_number = property(_openshot.ChunkNotFound_frame_number_get, _openshot.ChunkNotFound_frame_number_set, doc=r"""frame_number : int64_t""")
    chunk_number = property(_openshot.ChunkNotFound_chunk_number_get, _openshot.ChunkNotFound_chunk_number_set, doc=r"""chunk_number : int64_t""")
    chunk_frame = property(_openshot.ChunkNotFound_chunk_frame_get, _openshot.ChunkNotFound_chunk_frame_set, doc=r"""chunk_frame : int64_t""")

    def __init__(self, *args):
        r"""__init__(ChunkNotFound self, std::string message, int64_t frame_number, int64_t chunk_number, int64_t chunk_frame) -> ChunkNotFound"""
        _openshot.ChunkNotFound_swiginit(self, _openshot.new_ChunkNotFound(*args))
    __swig_destroy__ = _openshot.delete_ChunkNotFound

# Register ChunkNotFound in _openshot:
_openshot.ChunkNotFound_swigregister(ChunkNotFound)

class DecklinkError(BaseException):
    r"""Proxy of C++ openshot::DecklinkError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(DecklinkError self, std::string message) -> DecklinkError"""
        _openshot.DecklinkError_swiginit(self, _openshot.new_DecklinkError(*args))
    __swig_destroy__ = _openshot.delete_DecklinkError

# Register DecklinkError in _openshot:
_openshot.DecklinkError_swigregister(DecklinkError)

class ErrorDecodingAudio(BaseException):
    r"""Proxy of C++ openshot::ErrorDecodingAudio class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    frame_number = property(_openshot.ErrorDecodingAudio_frame_number_get, _openshot.ErrorDecodingAudio_frame_number_set, doc=r"""frame_number : int64_t""")

    def __init__(self, *args):
        r"""__init__(ErrorDecodingAudio self, std::string message, int64_t frame_number) -> ErrorDecodingAudio"""
        _openshot.ErrorDecodingAudio_swiginit(self, _openshot.new_ErrorDecodingAudio(*args))
    __swig_destroy__ = _openshot.delete_ErrorDecodingAudio

# Register ErrorDecodingAudio in _openshot:
_openshot.ErrorDecodingAudio_swigregister(ErrorDecodingAudio)

class ErrorEncodingAudio(BaseException):
    r"""Proxy of C++ openshot::ErrorEncodingAudio class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    frame_number = property(_openshot.ErrorEncodingAudio_frame_number_get, _openshot.ErrorEncodingAudio_frame_number_set, doc=r"""frame_number : int64_t""")

    def __init__(self, *args):
        r"""__init__(ErrorEncodingAudio self, std::string message, int64_t frame_number) -> ErrorEncodingAudio"""
        _openshot.ErrorEncodingAudio_swiginit(self, _openshot.new_ErrorEncodingAudio(*args))
    __swig_destroy__ = _openshot.delete_ErrorEncodingAudio

# Register ErrorEncodingAudio in _openshot:
_openshot.ErrorEncodingAudio_swigregister(ErrorEncodingAudio)

class ErrorEncodingVideo(BaseException):
    r"""Proxy of C++ openshot::ErrorEncodingVideo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    frame_number = property(_openshot.ErrorEncodingVideo_frame_number_get, _openshot.ErrorEncodingVideo_frame_number_set, doc=r"""frame_number : int64_t""")

    def __init__(self, *args):
        r"""__init__(ErrorEncodingVideo self, std::string message, int64_t frame_number) -> ErrorEncodingVideo"""
        _openshot.ErrorEncodingVideo_swiginit(self, _openshot.new_ErrorEncodingVideo(*args))
    __swig_destroy__ = _openshot.delete_ErrorEncodingVideo

# Register ErrorEncodingVideo in _openshot:
_openshot.ErrorEncodingVideo_swigregister(ErrorEncodingVideo)

class InvalidChannels(BaseException):
    r"""Proxy of C++ openshot::InvalidChannels class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.InvalidChannels_file_path_get, _openshot.InvalidChannels_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(InvalidChannels self, std::string message, std::string file_path="") -> InvalidChannels"""
        _openshot.InvalidChannels_swiginit(self, _openshot.new_InvalidChannels(*args))
    __swig_destroy__ = _openshot.delete_InvalidChannels

# Register InvalidChannels in _openshot:
_openshot.InvalidChannels_swigregister(InvalidChannels)

class InvalidCodec(BaseException):
    r"""Proxy of C++ openshot::InvalidCodec class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.InvalidCodec_file_path_get, _openshot.InvalidCodec_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(InvalidCodec self, std::string message, std::string file_path="") -> InvalidCodec"""
        _openshot.InvalidCodec_swiginit(self, _openshot.new_InvalidCodec(*args))
    __swig_destroy__ = _openshot.delete_InvalidCodec

# Register InvalidCodec in _openshot:
_openshot.InvalidCodec_swigregister(InvalidCodec)

class InvalidFile(BaseException):
    r"""Proxy of C++ openshot::InvalidFile class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.InvalidFile_file_path_get, _openshot.InvalidFile_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(InvalidFile self, std::string message, std::string file_path) -> InvalidFile"""
        _openshot.InvalidFile_swiginit(self, _openshot.new_InvalidFile(*args))
    __swig_destroy__ = _openshot.delete_InvalidFile

# Register InvalidFile in _openshot:
_openshot.InvalidFile_swigregister(InvalidFile)

class InvalidFormat(BaseException):
    r"""Proxy of C++ openshot::InvalidFormat class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.InvalidFormat_file_path_get, _openshot.InvalidFormat_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(InvalidFormat self, std::string message, std::string file_path="") -> InvalidFormat"""
        _openshot.InvalidFormat_swiginit(self, _openshot.new_InvalidFormat(*args))
    __swig_destroy__ = _openshot.delete_InvalidFormat

# Register InvalidFormat in _openshot:
_openshot.InvalidFormat_swigregister(InvalidFormat)

class InvalidJSON(BaseException):
    r"""Proxy of C++ openshot::InvalidJSON class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.InvalidJSON_file_path_get, _openshot.InvalidJSON_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(InvalidJSON self, std::string message, std::string file_path="") -> InvalidJSON"""
        _openshot.InvalidJSON_swiginit(self, _openshot.new_InvalidJSON(*args))
    __swig_destroy__ = _openshot.delete_InvalidJSON

# Register InvalidJSON in _openshot:
_openshot.InvalidJSON_swigregister(InvalidJSON)

class InvalidOptions(BaseException):
    r"""Proxy of C++ openshot::InvalidOptions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.InvalidOptions_file_path_get, _openshot.InvalidOptions_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(InvalidOptions self, std::string message, std::string file_path="") -> InvalidOptions"""
        _openshot.InvalidOptions_swiginit(self, _openshot.new_InvalidOptions(*args))
    __swig_destroy__ = _openshot.delete_InvalidOptions

# Register InvalidOptions in _openshot:
_openshot.InvalidOptions_swigregister(InvalidOptions)

class InvalidSampleRate(BaseException):
    r"""Proxy of C++ openshot::InvalidSampleRate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.InvalidSampleRate_file_path_get, _openshot.InvalidSampleRate_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(InvalidSampleRate self, std::string message, std::string file_path="") -> InvalidSampleRate"""
        _openshot.InvalidSampleRate_swiginit(self, _openshot.new_InvalidSampleRate(*args))
    __swig_destroy__ = _openshot.delete_InvalidSampleRate

# Register InvalidSampleRate in _openshot:
_openshot.InvalidSampleRate_swigregister(InvalidSampleRate)

class InvalidJSONKey(BaseException):
    r"""Proxy of C++ openshot::InvalidJSONKey class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    json = property(_openshot.InvalidJSONKey_json_get, _openshot.InvalidJSONKey_json_set, doc=r"""json : std::string""")

    def __init__(self, *args):
        r"""__init__(InvalidJSONKey self, std::string message, std::string json) -> InvalidJSONKey"""
        _openshot.InvalidJSONKey_swiginit(self, _openshot.new_InvalidJSONKey(*args))
    __swig_destroy__ = _openshot.delete_InvalidJSONKey

# Register InvalidJSONKey in _openshot:
_openshot.InvalidJSONKey_swigregister(InvalidJSONKey)

class NoStreamsFound(BaseException):
    r"""Proxy of C++ openshot::NoStreamsFound class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.NoStreamsFound_file_path_get, _openshot.NoStreamsFound_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(NoStreamsFound self, std::string message, std::string file_path="") -> NoStreamsFound"""
        _openshot.NoStreamsFound_swiginit(self, _openshot.new_NoStreamsFound(*args))
    __swig_destroy__ = _openshot.delete_NoStreamsFound

# Register NoStreamsFound in _openshot:
_openshot.NoStreamsFound_swigregister(NoStreamsFound)

class OutOfBoundsFrame(BaseException):
    r"""Proxy of C++ openshot::OutOfBoundsFrame class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    FrameRequested = property(_openshot.OutOfBoundsFrame_FrameRequested_get, _openshot.OutOfBoundsFrame_FrameRequested_set, doc=r"""FrameRequested : int64_t""")
    MaxFrames = property(_openshot.OutOfBoundsFrame_MaxFrames_get, _openshot.OutOfBoundsFrame_MaxFrames_set, doc=r"""MaxFrames : int64_t""")

    def __init__(self, *args):
        r"""__init__(OutOfBoundsFrame self, std::string message, int64_t frame_requested, int64_t max_frames) -> OutOfBoundsFrame"""
        _openshot.OutOfBoundsFrame_swiginit(self, _openshot.new_OutOfBoundsFrame(*args))
    __swig_destroy__ = _openshot.delete_OutOfBoundsFrame

# Register OutOfBoundsFrame in _openshot:
_openshot.OutOfBoundsFrame_swigregister(OutOfBoundsFrame)

class OutOfBoundsPoint(BaseException):
    r"""Proxy of C++ openshot::OutOfBoundsPoint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    PointRequested = property(_openshot.OutOfBoundsPoint_PointRequested_get, _openshot.OutOfBoundsPoint_PointRequested_set, doc=r"""PointRequested : int""")
    MaxPoints = property(_openshot.OutOfBoundsPoint_MaxPoints_get, _openshot.OutOfBoundsPoint_MaxPoints_set, doc=r"""MaxPoints : int""")

    def __init__(self, *args):
        r"""__init__(OutOfBoundsPoint self, std::string message, int point_requested, int max_points) -> OutOfBoundsPoint"""
        _openshot.OutOfBoundsPoint_swiginit(self, _openshot.new_OutOfBoundsPoint(*args))
    __swig_destroy__ = _openshot.delete_OutOfBoundsPoint

# Register OutOfBoundsPoint in _openshot:
_openshot.OutOfBoundsPoint_swigregister(OutOfBoundsPoint)

class OutOfMemory(BaseException):
    r"""Proxy of C++ openshot::OutOfMemory class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.OutOfMemory_file_path_get, _openshot.OutOfMemory_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(OutOfMemory self, std::string message, std::string file_path="") -> OutOfMemory"""
        _openshot.OutOfMemory_swiginit(self, _openshot.new_OutOfMemory(*args))
    __swig_destroy__ = _openshot.delete_OutOfMemory

# Register OutOfMemory in _openshot:
_openshot.OutOfMemory_swigregister(OutOfMemory)

class ReaderClosed(BaseException):
    r"""Proxy of C++ openshot::ReaderClosed class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.ReaderClosed_file_path_get, _openshot.ReaderClosed_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(ReaderClosed self, std::string message, std::string file_path="") -> ReaderClosed"""
        _openshot.ReaderClosed_swiginit(self, _openshot.new_ReaderClosed(*args))
    __swig_destroy__ = _openshot.delete_ReaderClosed

# Register ReaderClosed in _openshot:
_openshot.ReaderClosed_swigregister(ReaderClosed)

class ResampleError(BaseException):
    r"""Proxy of C++ openshot::ResampleError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.ResampleError_file_path_get, _openshot.ResampleError_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(ResampleError self, std::string message, std::string file_path="") -> ResampleError"""
        _openshot.ResampleError_swiginit(self, _openshot.new_ResampleError(*args))
    __swig_destroy__ = _openshot.delete_ResampleError

# Register ResampleError in _openshot:
_openshot.ResampleError_swigregister(ResampleError)

class TooManySeeks(BaseException):
    r"""Proxy of C++ openshot::TooManySeeks class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.TooManySeeks_file_path_get, _openshot.TooManySeeks_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(TooManySeeks self, std::string message, std::string file_path="") -> TooManySeeks"""
        _openshot.TooManySeeks_swiginit(self, _openshot.new_TooManySeeks(*args))
    __swig_destroy__ = _openshot.delete_TooManySeeks

# Register TooManySeeks in _openshot:
_openshot.TooManySeeks_swigregister(TooManySeeks)

class WriterClosed(BaseException):
    r"""Proxy of C++ openshot::WriterClosed class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_path = property(_openshot.WriterClosed_file_path_get, _openshot.WriterClosed_file_path_set, doc=r"""file_path : std::string""")

    def __init__(self, *args):
        r"""__init__(WriterClosed self, std::string message, std::string file_path="") -> WriterClosed"""
        _openshot.WriterClosed_swiginit(self, _openshot.new_WriterClosed(*args))
    __swig_destroy__ = _openshot.delete_WriterClosed

# Register WriterClosed in _openshot:
_openshot.WriterClosed_swigregister(WriterClosed)

class AudioLocation(object):
    r"""Proxy of C++ openshot::AudioLocation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    frame = property(_openshot.AudioLocation_frame_get, _openshot.AudioLocation_frame_set, doc=r"""frame : int64_t""")
    sample_start = property(_openshot.AudioLocation_sample_start_get, _openshot.AudioLocation_sample_start_set, doc=r"""sample_start : int""")

    def is_near(self, *args):
        r"""is_near(AudioLocation self, AudioLocation location, int samples_per_frame, int64_t amount) -> bool"""
        return _openshot.AudioLocation_is_near(self, *args)

    def __init__(self, *args):
        r"""__init__(AudioLocation self) -> AudioLocation"""
        _openshot.AudioLocation_swiginit(self, _openshot.new_AudioLocation(*args))
    __swig_destroy__ = _openshot.delete_AudioLocation

# Register AudioLocation in _openshot:
_openshot.AudioLocation_swigregister(AudioLocation)

class FFmpegReader(ReaderBase):
    r"""Proxy of C++ openshot::FFmpegReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    final_cache = property(_openshot.FFmpegReader_final_cache_get, _openshot.FFmpegReader_final_cache_set, doc=r"""final_cache : openshot::CacheMemory""")
    enable_seek = property(_openshot.FFmpegReader_enable_seek_get, _openshot.FFmpegReader_enable_seek_set, doc=r"""enable_seek : bool""")

    def __init__(self, *args):
        r"""
        __init__(FFmpegReader self, std::string path) -> FFmpegReader
        __init__(FFmpegReader self, std::string path, bool inspect_reader) -> FFmpegReader
        """
        _openshot.FFmpegReader_swiginit(self, _openshot.new_FFmpegReader(*args))
    __swig_destroy__ = _openshot.delete_FFmpegReader

    def Close(self, *args):
        r"""Close(FFmpegReader self)"""
        return _openshot.FFmpegReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(FFmpegReader self) -> CacheMemory"""
        return _openshot.FFmpegReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(FFmpegReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.FFmpegReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(FFmpegReader self) -> bool"""
        return _openshot.FFmpegReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(FFmpegReader self) -> std::string"""
        return _openshot.FFmpegReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(FFmpegReader self) -> std::string"""
        return _openshot.FFmpegReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(FFmpegReader self, std::string const value)"""
        return _openshot.FFmpegReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(FFmpegReader self) -> Json::Value"""
        return _openshot.FFmpegReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(FFmpegReader self, Json::Value const root)"""
        return _openshot.FFmpegReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(FFmpegReader self)"""
        return _openshot.FFmpegReader_Open(self, *args)

# Register FFmpegReader in _openshot:
_openshot.FFmpegReader_swigregister(FFmpegReader)

VIDEO_STREAM = _openshot.VIDEO_STREAM

AUDIO_STREAM = _openshot.AUDIO_STREAM

class FFmpegWriter(WriterBase):
    r"""Proxy of C++ openshot::FFmpegWriter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(FFmpegWriter self, std::string path) -> FFmpegWriter"""
        _openshot.FFmpegWriter_swiginit(self, _openshot.new_FFmpegWriter(*args))

    def Close(self, *args):
        r"""Close(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_Close(self, *args)

    def GetCacheSize(self, *args):
        r"""GetCacheSize(FFmpegWriter self) -> int"""
        return _openshot.FFmpegWriter_GetCacheSize(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(FFmpegWriter self) -> bool"""
        return _openshot.FFmpegWriter_IsOpen(self, *args)

    @staticmethod
    def IsValidCodec(*args):
        r"""IsValidCodec(std::string codec_name) -> bool"""
        return _openshot.FFmpegWriter_IsValidCodec(*args)

    def Open(self, *args):
        r"""Open(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_Open(self, *args)

    def OutputStreamInfo(self, *args):
        r"""OutputStreamInfo(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_OutputStreamInfo(self, *args)

    def PrepareStreams(self, *args):
        r"""PrepareStreams(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_PrepareStreams(self, *args)

    def RemoveScalers(self, *args):
        r"""RemoveScalers(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_RemoveScalers(self, *args)

    def ResampleAudio(self, *args):
        r"""ResampleAudio(FFmpegWriter self, int sample_rate, int channels)"""
        return _openshot.FFmpegWriter_ResampleAudio(self, *args)

    def SetAudioOptions(self, *args):
        r"""
        SetAudioOptions(FFmpegWriter self, bool has_audio, std::string codec, int sample_rate, int channels, openshot::ChannelLayout channel_layout, int bit_rate)
        SetAudioOptions(FFmpegWriter self, std::string codec, int sample_rate, int bit_rate)
        """
        return _openshot.FFmpegWriter_SetAudioOptions(self, *args)

    def SetCacheSize(self, *args):
        r"""SetCacheSize(FFmpegWriter self, int new_size)"""
        return _openshot.FFmpegWriter_SetCacheSize(self, *args)

    def SetVideoOptions(self, *args):
        r"""
        SetVideoOptions(FFmpegWriter self, bool has_video, std::string codec, Fraction fps, int width, int height, Fraction pixel_ratio, bool interlaced, bool top_field_first, int bit_rate)
        SetVideoOptions(FFmpegWriter self, std::string codec, int width, int height, Fraction fps, int bit_rate)
        """
        return _openshot.FFmpegWriter_SetVideoOptions(self, *args)

    def SetOption(self, *args):
        r"""SetOption(FFmpegWriter self, openshot::StreamType stream, std::string name, std::string value)"""
        return _openshot.FFmpegWriter_SetOption(self, *args)

    def WriteHeader(self, *args):
        r"""WriteHeader(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_WriteHeader(self, *args)

    def WriteFrame(self, *args):
        r"""
        WriteFrame(FFmpegWriter self, std::shared_ptr< openshot::Frame > frame)
        WriteFrame(FFmpegWriter self, ReaderBase reader, int64_t start, int64_t length)
        """
        return _openshot.FFmpegWriter_WriteFrame(self, *args)

    def WriteTrailer(self, *args):
        r"""WriteTrailer(FFmpegWriter self)"""
        return _openshot.FFmpegWriter_WriteTrailer(self, *args)
    __swig_destroy__ = _openshot.delete_FFmpegWriter

# Register FFmpegWriter in _openshot:
_openshot.FFmpegWriter_swigregister(FFmpegWriter)

def FFmpegWriter_IsValidCodec(*args):
    r"""FFmpegWriter_IsValidCodec(std::string codec_name) -> bool"""
    return _openshot.FFmpegWriter_IsValidCodec(*args)

class Fraction(object):
    r"""Proxy of C++ openshot::Fraction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    num = property(_openshot.Fraction_num_get, _openshot.Fraction_num_set, doc=r"""num : int""")
    den = property(_openshot.Fraction_den_get, _openshot.Fraction_den_set, doc=r"""den : int""")

    def __init__(self, *args):
        r"""
        __init__(Fraction self) -> Fraction
        __init__(Fraction self, int num, int den) -> Fraction
        """
        _openshot.Fraction_swiginit(self, _openshot.new_Fraction(*args))

    def GreatestCommonDenominator(self, *args):
        r"""GreatestCommonDenominator(Fraction self) -> int"""
        return _openshot.Fraction_GreatestCommonDenominator(self, *args)

    def Reduce(self, *args):
        r"""Reduce(Fraction self)"""
        return _openshot.Fraction_Reduce(self, *args)

    def ToFloat(self, *args):
        r"""ToFloat(Fraction self) -> float"""
        return _openshot.Fraction_ToFloat(self, *args)

    def ToDouble(self, *args):
        r"""ToDouble(Fraction self) -> double"""
        return _openshot.Fraction_ToDouble(self, *args)

    def ToInt(self, *args):
        r"""ToInt(Fraction self) -> int"""
        return _openshot.Fraction_ToInt(self, *args)

    def Reciprocal(self, *args):
        r"""Reciprocal(Fraction self) -> Fraction"""
        return _openshot.Fraction_Reciprocal(self, *args)

    def __float__(self, *args):
        r"""__float__(Fraction self) -> double"""
        return _openshot.Fraction___float__(self, *args)

    def __int__(self, *args):
        r"""__int__(Fraction self) -> int"""
        return _openshot.Fraction___int__(self, *args)

    def GetMap(self, *args):
        r"""GetMap(Fraction self) -> std::map< std::string,int,std::less< std::string >,std::allocator< std::pair< std::string const,int > > >"""
        return _openshot.Fraction_GetMap(self, *args)

    def __repr__(self, *args):
        r"""__repr__(Fraction self) -> std::string"""
        return _openshot.Fraction___repr__(self, *args)
    __swig_destroy__ = _openshot.delete_Fraction

# Register Fraction in _openshot:
_openshot.Fraction_swigregister(Fraction)

class Frame(object):
    r"""Proxy of C++ openshot::Frame class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    number = property(_openshot.Frame_number_get, _openshot.Frame_number_set, doc=r"""number : int64_t""")
    has_audio_data = property(_openshot.Frame_has_audio_data_get, _openshot.Frame_has_audio_data_set, doc=r"""has_audio_data : bool""")
    has_image_data = property(_openshot.Frame_has_image_data_get, _openshot.Frame_has_image_data_set, doc=r"""has_image_data : bool""")

    def __init__(self, *args):
        r"""
        __init__(Frame self) -> Frame
        __init__(Frame self, int64_t number, int width, int height, std::string color) -> Frame
        __init__(Frame self, int64_t number, int samples, int channels) -> Frame
        __init__(Frame self, int64_t number, int width, int height, std::string color, int samples, int channels) -> Frame
        __init__(Frame self, Frame other) -> Frame
        """
        _openshot.Frame_swiginit(self, _openshot.new_Frame(*args))
    __swig_destroy__ = _openshot.delete_Frame

    def AddColor(self, *args):
        r"""AddColor(Frame self, int new_width, int new_height, std::string new_color)"""
        return _openshot.Frame_AddColor(self, *args)

    def AddImage(self, *args):
        r"""
        AddImage(Frame self, int new_width, int new_height, int bytes_per_pixel, QImage::Format type, unsigned char const * pixels_)
        AddImage(Frame self, std::shared_ptr< QImage > new_image)
        AddImage(Frame self, std::shared_ptr< QImage > new_image, bool only_odd_lines)
        """
        return _openshot.Frame_AddImage(self, *args)

    def AddMagickImage(self, *args):
        r"""AddMagickImage(Frame self, std::shared_ptr< Magick::Image > new_image)"""
        return _openshot.Frame_AddMagickImage(self, *args)

    def AddAudio(self, *args):
        r"""AddAudio(Frame self, bool replaceSamples, int destChannel, int destStartSample, float const * source, int numSamples, float gainToApplyToSource)"""
        return _openshot.Frame_AddAudio(self, *args)

    def AddAudioSilence(self, *args):
        r"""AddAudioSilence(Frame self, int numSamples)"""
        return _openshot.Frame_AddAudioSilence(self, *args)

    def ApplyGainRamp(self, *args):
        r"""ApplyGainRamp(Frame self, int destChannel, int destStartSample, int numSamples, float initial_gain, float final_gain)"""
        return _openshot.Frame_ApplyGainRamp(self, *args)

    def ChannelsLayout(self, *args):
        r"""
        ChannelsLayout(Frame self) -> openshot::ChannelLayout
        ChannelsLayout(Frame self, openshot::ChannelLayout new_channel_layout)
        """
        return _openshot.Frame_ChannelsLayout(self, *args)

    @staticmethod
    def cleanUpBuffer(*args):
        r"""cleanUpBuffer(void * info)"""
        return _openshot.Frame_cleanUpBuffer(*args)

    def ClearWaveform(self, *args):
        r"""ClearWaveform(Frame self)"""
        return _openshot.Frame_ClearWaveform(self, *args)

    def DeepCopy(self, *args):
        r"""DeepCopy(Frame self, Frame other)"""
        return _openshot.Frame_DeepCopy(self, *args)

    def Display(self, *args):
        r"""Display(Frame self)"""
        return _openshot.Frame_Display(self, *args)

    def DisplayWaveform(self, *args):
        r"""DisplayWaveform(Frame self)"""
        return _openshot.Frame_DisplayWaveform(self, *args)

    def GetAudioSample(self, *args):
        r"""GetAudioSample(Frame self, int channel, int sample, int magnitude_range) -> float"""
        return _openshot.Frame_GetAudioSample(self, *args)

    def GetAudioSamples(self, *args):
        r"""GetAudioSamples(Frame self, int channel) -> float *"""
        return _openshot.Frame_GetAudioSamples(self, *args)

    def GetInterleavedAudioSamples(self, *args):
        r"""GetInterleavedAudioSamples(Frame self, int new_sample_rate, openshot::AudioResampler * resampler, int * sample_count) -> float *"""
        return _openshot.Frame_GetInterleavedAudioSamples(self, *args)

    def GetPlanarAudioSamples(self, *args):
        r"""GetPlanarAudioSamples(Frame self, int new_sample_rate, openshot::AudioResampler * resampler, int * sample_count) -> float *"""
        return _openshot.Frame_GetPlanarAudioSamples(self, *args)

    def GetAudioChannelsCount(self, *args):
        r"""GetAudioChannelsCount(Frame self) -> int"""
        return _openshot.Frame_GetAudioChannelsCount(self, *args)

    def GetAudioSamplesCount(self, *args):
        r"""GetAudioSamplesCount(Frame self) -> int"""
        return _openshot.Frame_GetAudioSamplesCount(self, *args)

    def GetAudioSampleBuffer(self, *args):
        r"""GetAudioSampleBuffer(Frame self) -> juce::AudioSampleBuffer *"""
        return _openshot.Frame_GetAudioSampleBuffer(self, *args)

    def GetBytes(self, *args):
        r"""GetBytes(Frame self) -> int64_t"""
        return _openshot.Frame_GetBytes(self, *args)

    def GetImage(self, *args):
        r"""GetImage(Frame self) -> std::shared_ptr< QImage >"""
        return _openshot.Frame_GetImage(self, *args)

    def GetMagickImage(self, *args):
        r"""GetMagickImage(Frame self) -> std::shared_ptr< Magick::Image >"""
        return _openshot.Frame_GetMagickImage(self, *args)

    def GetPixelRatio(self, *args):
        r"""GetPixelRatio(Frame self) -> Fraction"""
        return _openshot.Frame_GetPixelRatio(self, *args)

    def GetPixels(self, *args):
        r"""
        GetPixels(Frame self) -> unsigned char const
        GetPixels(Frame self, int row) -> unsigned char const *
        """
        return _openshot.Frame_GetPixels(self, *args)

    def CheckPixel(self, *args):
        r"""CheckPixel(Frame self, int row, int col, int red, int green, int blue, int alpha, int threshold) -> bool"""
        return _openshot.Frame_CheckPixel(self, *args)

    def GetHeight(self, *args):
        r"""GetHeight(Frame self) -> int"""
        return _openshot.Frame_GetHeight(self, *args)

    @staticmethod
    def GetSamplesPerFrame(*args):
        r"""
        GetSamplesPerFrame(Fraction fps, int sample_rate, int channels) -> int
        GetSamplesPerFrame(int64_t frame_number, Fraction fps, int sample_rate, int channels) -> int
        """
        return _openshot.Frame_GetSamplesPerFrame(*args)

    def GetWaveform(self, *args):
        r"""GetWaveform(Frame self, int width, int height, int Red, int Green, int Blue, int Alpha) -> std::shared_ptr< QImage >"""
        return _openshot.Frame_GetWaveform(self, *args)

    def GetWaveformPixels(self, *args):
        r"""GetWaveformPixels(Frame self, int width, int height, int Red, int Green, int Blue, int Alpha) -> unsigned char const *"""
        return _openshot.Frame_GetWaveformPixels(self, *args)

    def GetWidth(self, *args):
        r"""GetWidth(Frame self) -> int"""
        return _openshot.Frame_GetWidth(self, *args)

    def ResizeAudio(self, *args):
        r"""ResizeAudio(Frame self, int channels, int length, int sample_rate, openshot::ChannelLayout channel_layout)"""
        return _openshot.Frame_ResizeAudio(self, *args)

    def SampleRate(self, *args):
        r"""
        SampleRate(Frame self) -> int
        SampleRate(Frame self, int orig_sample_rate)
        """
        return _openshot.Frame_SampleRate(self, *args)

    def Save(self, *args):
        r"""Save(Frame self, std::string path, float scale, std::string format="PNG", int quality=100)"""
        return _openshot.Frame_Save(self, *args)

    def SetFrameNumber(self, *args):
        r"""SetFrameNumber(Frame self, int64_t number)"""
        return _openshot.Frame_SetFrameNumber(self, *args)

    def SetPixelRatio(self, *args):
        r"""SetPixelRatio(Frame self, int num, int den)"""
        return _openshot.Frame_SetPixelRatio(self, *args)

    def Thumbnail(self, *args):
        r"""Thumbnail(Frame self, std::string path, int new_width, int new_height, std::string mask_path, std::string overlay_path, std::string background_color, bool ignore_aspect, std::string format="png", int quality=100, float rotate=0.0)"""
        return _openshot.Frame_Thumbnail(self, *args)

    def Play(self, *args):
        r"""Play(Frame self)"""
        return _openshot.Frame_Play(self, *args)

# Register Frame in _openshot:
_openshot.Frame_swigregister(Frame)

def Frame_cleanUpBuffer(*args):
    r"""Frame_cleanUpBuffer(void * info)"""
    return _openshot.Frame_cleanUpBuffer(*args)

def Frame_GetSamplesPerFrame(*args):
    r"""
    Frame_GetSamplesPerFrame(Fraction fps, int sample_rate, int channels) -> int
    Frame_GetSamplesPerFrame(int64_t frame_number, Fraction fps, int sample_rate, int channels) -> int
    """
    return _openshot.Frame_GetSamplesPerFrame(*args)

PULLDOWN_CLASSIC = _openshot.PULLDOWN_CLASSIC

PULLDOWN_ADVANCED = _openshot.PULLDOWN_ADVANCED

PULLDOWN_NONE = _openshot.PULLDOWN_NONE

class Field(object):
    r"""Proxy of C++ openshot::Field class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Frame = property(_openshot.Field_Frame_get, _openshot.Field_Frame_set, doc=r"""Frame : int64_t""")
    isOdd = property(_openshot.Field_isOdd_get, _openshot.Field_isOdd_set, doc=r"""isOdd : bool""")

    def __init__(self, *args):
        r"""
        __init__(Field self) -> Field
        __init__(Field self, int64_t frame, bool isodd) -> Field
        """
        _openshot.Field_swiginit(self, _openshot.new_Field(*args))
    __swig_destroy__ = _openshot.delete_Field

# Register Field in _openshot:
_openshot.Field_swigregister(Field)

class SampleRange(object):
    r"""Proxy of C++ openshot::SampleRange class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    frame_start = property(_openshot.SampleRange_frame_start_get, _openshot.SampleRange_frame_start_set, doc=r"""frame_start : int64_t""")
    sample_start = property(_openshot.SampleRange_sample_start_get, _openshot.SampleRange_sample_start_set, doc=r"""sample_start : int""")
    frame_end = property(_openshot.SampleRange_frame_end_get, _openshot.SampleRange_frame_end_set, doc=r"""frame_end : int64_t""")
    sample_end = property(_openshot.SampleRange_sample_end_get, _openshot.SampleRange_sample_end_set, doc=r"""sample_end : int""")
    total = property(_openshot.SampleRange_total_get, _openshot.SampleRange_total_set, doc=r"""total : int""")

    def __init__(self, *args):
        r"""__init__(SampleRange self) -> SampleRange"""
        _openshot.SampleRange_swiginit(self, _openshot.new_SampleRange(*args))
    __swig_destroy__ = _openshot.delete_SampleRange

# Register SampleRange in _openshot:
_openshot.SampleRange_swigregister(SampleRange)

class MappedFrame(object):
    r"""Proxy of C++ openshot::MappedFrame class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Odd = property(_openshot.MappedFrame_Odd_get, _openshot.MappedFrame_Odd_set, doc=r"""Odd : openshot::Field""")
    Even = property(_openshot.MappedFrame_Even_get, _openshot.MappedFrame_Even_set, doc=r"""Even : openshot::Field""")
    Samples = property(_openshot.MappedFrame_Samples_get, _openshot.MappedFrame_Samples_set, doc=r"""Samples : openshot::SampleRange""")

    def __init__(self, *args):
        r"""__init__(MappedFrame self) -> MappedFrame"""
        _openshot.MappedFrame_swiginit(self, _openshot.new_MappedFrame(*args))
    __swig_destroy__ = _openshot.delete_MappedFrame

# Register MappedFrame in _openshot:
_openshot.MappedFrame_swigregister(MappedFrame)

class FrameMapper(ReaderBase):
    r"""Proxy of C++ openshot::FrameMapper class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    fields = property(_openshot.FrameMapper_fields_get, _openshot.FrameMapper_fields_set, doc=r"""fields : std::vector<(openshot::Field,std::allocator<(openshot::Field)>)>""")
    frames = property(_openshot.FrameMapper_frames_get, _openshot.FrameMapper_frames_set, doc=r"""frames : std::vector<(openshot::MappedFrame,std::allocator<(openshot::MappedFrame)>)>""")

    def __init__(self, *args):
        r"""__init__(FrameMapper self, ReaderBase reader, Fraction target_fps, openshot::PulldownType target_pulldown, int target_sample_rate, int target_channels, openshot::ChannelLayout target_channel_layout) -> FrameMapper"""
        _openshot.FrameMapper_swiginit(self, _openshot.new_FrameMapper(*args))
    __swig_destroy__ = _openshot.delete_FrameMapper

    def ChangeMapping(self, *args):
        r"""ChangeMapping(FrameMapper self, Fraction target_fps, openshot::PulldownType pulldown, int target_sample_rate, int target_channels, openshot::ChannelLayout target_channel_layout)"""
        return _openshot.FrameMapper_ChangeMapping(self, *args)

    def Close(self, *args):
        r"""Close(FrameMapper self)"""
        return _openshot.FrameMapper_Close(self, *args)

    def GetMappedFrame(self, *args):
        r"""GetMappedFrame(FrameMapper self, int64_t TargetFrameNumber) -> MappedFrame"""
        return _openshot.FrameMapper_GetMappedFrame(self, *args)

    def GetCache(self, *args):
        r"""GetCache(FrameMapper self) -> CacheMemory"""
        return _openshot.FrameMapper_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(FrameMapper self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.FrameMapper_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(FrameMapper self) -> bool"""
        return _openshot.FrameMapper_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(FrameMapper self) -> std::string"""
        return _openshot.FrameMapper_Name(self, *args)

    def Json(self, *args):
        r"""Json(FrameMapper self) -> std::string"""
        return _openshot.FrameMapper_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(FrameMapper self, std::string const value)"""
        return _openshot.FrameMapper_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(FrameMapper self) -> Json::Value"""
        return _openshot.FrameMapper_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(FrameMapper self, Json::Value const root)"""
        return _openshot.FrameMapper_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(FrameMapper self)"""
        return _openshot.FrameMapper_Open(self, *args)

    def PrintMapping(self, *args):
        r"""PrintMapping(FrameMapper self)"""
        return _openshot.FrameMapper_PrintMapping(self, *args)

    def Reader(self, *args):
        r"""
        Reader(FrameMapper self) -> ReaderBase
        Reader(FrameMapper self, ReaderBase new_reader)
        """
        return _openshot.FrameMapper_Reader(self, *args)

    def ResampleMappedAudio(self, *args):
        r"""ResampleMappedAudio(FrameMapper self, std::shared_ptr< openshot::Frame > frame, int64_t original_frame_number)"""
        return _openshot.FrameMapper_ResampleMappedAudio(self, *args)

# Register FrameMapper in _openshot:
_openshot.FrameMapper_swigregister(FrameMapper)

PLAYBACK_PLAY = _openshot.PLAYBACK_PLAY

PLAYBACK_PAUSED = _openshot.PLAYBACK_PAUSED

PLAYBACK_LOADING = _openshot.PLAYBACK_LOADING

PLAYBACK_STOPPED = _openshot.PLAYBACK_STOPPED

class PlayerBase(object):
    r"""Proxy of C++ openshot::PlayerBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def Loading(self, *args):
        r"""Loading(PlayerBase self)"""
        return _openshot.PlayerBase_Loading(self, *args)

    def Mode(self, *args):
        r"""Mode(PlayerBase self) -> openshot::PlaybackMode"""
        return _openshot.PlayerBase_Mode(self, *args)

    def Play(self, *args):
        r"""Play(PlayerBase self)"""
        return _openshot.PlayerBase_Play(self, *args)

    def Pause(self, *args):
        r"""Pause(PlayerBase self)"""
        return _openshot.PlayerBase_Pause(self, *args)

    def Position(self, *args):
        r"""Position(PlayerBase self) -> int64_t"""
        return _openshot.PlayerBase_Position(self, *args)

    def Seek(self, *args):
        r"""Seek(PlayerBase self, int64_t new_frame)"""
        return _openshot.PlayerBase_Seek(self, *args)

    def Speed(self, *args):
        r"""
        Speed(PlayerBase self) -> float
        Speed(PlayerBase self, float new_speed)
        """
        return _openshot.PlayerBase_Speed(self, *args)

    def Stop(self, *args):
        r"""Stop(PlayerBase self)"""
        return _openshot.PlayerBase_Stop(self, *args)

    def Reader(self, *args):
        r"""
        Reader(PlayerBase self) -> ReaderBase
        Reader(PlayerBase self, ReaderBase new_reader)
        """
        return _openshot.PlayerBase_Reader(self, *args)

    def Volume(self, *args):
        r"""
        Volume(PlayerBase self) -> float
        Volume(PlayerBase self, float new_volume)
        """
        return _openshot.PlayerBase_Volume(self, *args)
    __swig_destroy__ = _openshot.delete_PlayerBase

# Register PlayerBase in _openshot:
_openshot.PlayerBase_swigregister(PlayerBase)

BEZIER = _openshot.BEZIER

LINEAR = _openshot.LINEAR

CONSTANT = _openshot.CONSTANT

AUTO = _openshot.AUTO

MANUAL = _openshot.MANUAL

class Point(object):
    r"""Proxy of C++ openshot::Point class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    co = property(_openshot.Point_co_get, _openshot.Point_co_set, doc=r"""co : openshot::Coordinate""")
    handle_left = property(_openshot.Point_handle_left_get, _openshot.Point_handle_left_set, doc=r"""handle_left : openshot::Coordinate""")
    handle_right = property(_openshot.Point_handle_right_get, _openshot.Point_handle_right_set, doc=r"""handle_right : openshot::Coordinate""")
    interpolation = property(_openshot.Point_interpolation_get, _openshot.Point_interpolation_set, doc=r"""interpolation : openshot::InterpolationType""")
    handle_type = property(_openshot.Point_handle_type_get, _openshot.Point_handle_type_set, doc=r"""handle_type : openshot::HandleType""")

    def __init__(self, *args):
        r"""
        __init__(Point self) -> Point
        __init__(Point self, float y) -> Point
        __init__(Point self, float x, float y) -> Point
        __init__(Point self, float x, float y, openshot::InterpolationType interpolation) -> Point
        __init__(Point self, Coordinate co) -> Point
        __init__(Point self, Coordinate co, openshot::InterpolationType interpolation) -> Point
        __init__(Point self, Coordinate co, openshot::InterpolationType interpolation, openshot::HandleType handle_type) -> Point
        """
        _openshot.Point_swiginit(self, _openshot.new_Point(*args))

    def Initialize_Handles(self, *args):
        r"""Initialize_Handles(Point self)"""
        return _openshot.Point_Initialize_Handles(self, *args)

    def Initialize_LeftHandle(self, *args):
        r"""Initialize_LeftHandle(Point self, float x, float y)"""
        return _openshot.Point_Initialize_LeftHandle(self, *args)

    def Initialize_RightHandle(self, *args):
        r"""Initialize_RightHandle(Point self, float x, float y)"""
        return _openshot.Point_Initialize_RightHandle(self, *args)

    def Json(self, *args):
        r"""Json(Point self) -> std::string"""
        return _openshot.Point_Json(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Point self) -> Json::Value"""
        return _openshot.Point_JsonValue(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Point self, std::string const value)"""
        return _openshot.Point_SetJson(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Point self, Json::Value const root)"""
        return _openshot.Point_SetJsonValue(self, *args)
    __swig_destroy__ = _openshot.delete_Point

# Register Point in _openshot:
_openshot.Point_swigregister(Point)

class ProfileInfo(object):
    r"""Proxy of C++ openshot::ProfileInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    description = property(_openshot.ProfileInfo_description_get, _openshot.ProfileInfo_description_set, doc=r"""description : std::string""")
    height = property(_openshot.ProfileInfo_height_get, _openshot.ProfileInfo_height_set, doc=r"""height : int""")
    width = property(_openshot.ProfileInfo_width_get, _openshot.ProfileInfo_width_set, doc=r"""width : int""")
    pixel_format = property(_openshot.ProfileInfo_pixel_format_get, _openshot.ProfileInfo_pixel_format_set, doc=r"""pixel_format : int""")
    fps = property(_openshot.ProfileInfo_fps_get, _openshot.ProfileInfo_fps_set, doc=r"""fps : openshot::Fraction""")
    pixel_ratio = property(_openshot.ProfileInfo_pixel_ratio_get, _openshot.ProfileInfo_pixel_ratio_set, doc=r"""pixel_ratio : openshot::Fraction""")
    display_ratio = property(_openshot.ProfileInfo_display_ratio_get, _openshot.ProfileInfo_display_ratio_set, doc=r"""display_ratio : openshot::Fraction""")
    interlaced_frame = property(_openshot.ProfileInfo_interlaced_frame_get, _openshot.ProfileInfo_interlaced_frame_set, doc=r"""interlaced_frame : bool""")

    def __init__(self, *args):
        r"""__init__(ProfileInfo self) -> ProfileInfo"""
        _openshot.ProfileInfo_swiginit(self, _openshot.new_ProfileInfo(*args))
    __swig_destroy__ = _openshot.delete_ProfileInfo

# Register ProfileInfo in _openshot:
_openshot.ProfileInfo_swigregister(ProfileInfo)

class Profile(object):
    r"""Proxy of C++ openshot::Profile class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    info = property(_openshot.Profile_info_get, _openshot.Profile_info_set, doc=r"""info : openshot::ProfileInfo""")

    def __init__(self, *args):
        r"""__init__(Profile self, std::string path) -> Profile"""
        _openshot.Profile_swiginit(self, _openshot.new_Profile(*args))

    def Json(self, *args):
        r"""Json(Profile self) -> std::string"""
        return _openshot.Profile_Json(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Profile self) -> Json::Value"""
        return _openshot.Profile_JsonValue(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Profile self, std::string const value)"""
        return _openshot.Profile_SetJson(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Profile self, Json::Value const root)"""
        return _openshot.Profile_SetJsonValue(self, *args)
    __swig_destroy__ = _openshot.delete_Profile

# Register Profile in _openshot:
_openshot.Profile_swigregister(Profile)

class QtHtmlReader(ReaderBase):
    r"""Proxy of C++ openshot::QtHtmlReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(QtHtmlReader self) -> QtHtmlReader
        __init__(QtHtmlReader self, int width, int height, int x_offset, int y_offset, openshot::GravityType gravity, std::string html, std::string css, std::string background_color) -> QtHtmlReader
        """
        _openshot.QtHtmlReader_swiginit(self, _openshot.new_QtHtmlReader(*args))

    def Close(self, *args):
        r"""Close(QtHtmlReader self)"""
        return _openshot.QtHtmlReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(QtHtmlReader self) -> CacheMemory"""
        return _openshot.QtHtmlReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(QtHtmlReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.QtHtmlReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(QtHtmlReader self) -> bool"""
        return _openshot.QtHtmlReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(QtHtmlReader self) -> std::string"""
        return _openshot.QtHtmlReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(QtHtmlReader self) -> std::string"""
        return _openshot.QtHtmlReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(QtHtmlReader self, std::string const value)"""
        return _openshot.QtHtmlReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(QtHtmlReader self) -> Json::Value"""
        return _openshot.QtHtmlReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(QtHtmlReader self, Json::Value const root)"""
        return _openshot.QtHtmlReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(QtHtmlReader self)"""
        return _openshot.QtHtmlReader_Open(self, *args)
    __swig_destroy__ = _openshot.delete_QtHtmlReader

# Register QtHtmlReader in _openshot:
_openshot.QtHtmlReader_swigregister(QtHtmlReader)

class QtImageReader(ReaderBase):
    r"""Proxy of C++ openshot::QtImageReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(QtImageReader self, std::string path) -> QtImageReader
        __init__(QtImageReader self, std::string path, bool inspect_reader) -> QtImageReader
        """
        _openshot.QtImageReader_swiginit(self, _openshot.new_QtImageReader(*args))
    __swig_destroy__ = _openshot.delete_QtImageReader

    def Close(self, *args):
        r"""Close(QtImageReader self)"""
        return _openshot.QtImageReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(QtImageReader self) -> CacheMemory"""
        return _openshot.QtImageReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(QtImageReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.QtImageReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(QtImageReader self) -> bool"""
        return _openshot.QtImageReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(QtImageReader self) -> std::string"""
        return _openshot.QtImageReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(QtImageReader self) -> std::string"""
        return _openshot.QtImageReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(QtImageReader self, std::string const value)"""
        return _openshot.QtImageReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(QtImageReader self) -> Json::Value"""
        return _openshot.QtImageReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(QtImageReader self, Json::Value const root)"""
        return _openshot.QtImageReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(QtImageReader self)"""
        return _openshot.QtImageReader_Open(self, *args)

# Register QtImageReader in _openshot:
_openshot.QtImageReader_swigregister(QtImageReader)

class QtPlayer(PlayerBase):
    r"""Proxy of C++ openshot::QtPlayer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(QtPlayer self) -> QtPlayer
        __init__(QtPlayer self, RendererBase rb) -> QtPlayer
        """
        _openshot.QtPlayer_swiginit(self, _openshot.new_QtPlayer(*args))
    __swig_destroy__ = _openshot.delete_QtPlayer

    def CloseAudioDevice(self, *args):
        r"""CloseAudioDevice(QtPlayer self)"""
        return _openshot.QtPlayer_CloseAudioDevice(self, *args)

    def GetError(self, *args):
        r"""GetError(QtPlayer self) -> std::string"""
        return _openshot.QtPlayer_GetError(self, *args)

    def GetAudioDeviceNames(self, *args):
        r"""GetAudioDeviceNames(QtPlayer self) -> AudioDeviceInfoVector"""
        return _openshot.QtPlayer_GetAudioDeviceNames(self, *args)

    def Play(self, *args):
        r"""Play(QtPlayer self)"""
        return _openshot.QtPlayer_Play(self, *args)

    def Loading(self, *args):
        r"""Loading(QtPlayer self)"""
        return _openshot.QtPlayer_Loading(self, *args)

    def Mode(self, *args):
        r"""Mode(QtPlayer self) -> openshot::PlaybackMode"""
        return _openshot.QtPlayer_Mode(self, *args)

    def Pause(self, *args):
        r"""Pause(QtPlayer self)"""
        return _openshot.QtPlayer_Pause(self, *args)

    def Position(self, *args):
        r"""Position(QtPlayer self) -> int64_t"""
        return _openshot.QtPlayer_Position(self, *args)

    def Seek(self, *args):
        r"""Seek(QtPlayer self, int64_t new_frame)"""
        return _openshot.QtPlayer_Seek(self, *args)

    def SetSource(self, *args):
        r"""SetSource(QtPlayer self, std::string const & source)"""
        return _openshot.QtPlayer_SetSource(self, *args)

    def SetQWidget(self, *args):
        r"""SetQWidget(QtPlayer self, int64_t qwidget_address)"""
        return _openshot.QtPlayer_SetQWidget(self, *args)

    def GetRendererQObject(self, *args):
        r"""GetRendererQObject(QtPlayer self) -> int64_t"""
        return _openshot.QtPlayer_GetRendererQObject(self, *args)

    def Speed(self, *args):
        r"""
        Speed(QtPlayer self) -> float
        Speed(QtPlayer self, float new_speed)
        """
        return _openshot.QtPlayer_Speed(self, *args)

    def Stop(self, *args):
        r"""Stop(QtPlayer self)"""
        return _openshot.QtPlayer_Stop(self, *args)

    def Reader(self, *args):
        r"""
        Reader(QtPlayer self, ReaderBase new_reader)
        Reader(QtPlayer self) -> ReaderBase
        """
        return _openshot.QtPlayer_Reader(self, *args)

    def Volume(self, *args):
        r"""
        Volume(QtPlayer self) -> float
        Volume(QtPlayer self, float new_volume)
        """
        return _openshot.QtPlayer_Volume(self, *args)

# Register QtPlayer in _openshot:
_openshot.QtPlayer_swigregister(QtPlayer)

class QtTextReader(ReaderBase):
    r"""Proxy of C++ openshot::QtTextReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(QtTextReader self) -> QtTextReader
        __init__(QtTextReader self, int width, int height, int x_offset, int y_offset, openshot::GravityType gravity, std::string text, QFont font, std::string text_color, std::string background_color) -> QtTextReader
        """
        _openshot.QtTextReader_swiginit(self, _openshot.new_QtTextReader(*args))

    def SetTextBackgroundColor(self, *args):
        r"""SetTextBackgroundColor(QtTextReader self, std::string color)"""
        return _openshot.QtTextReader_SetTextBackgroundColor(self, *args)

    def Close(self, *args):
        r"""Close(QtTextReader self)"""
        return _openshot.QtTextReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(QtTextReader self) -> CacheMemory"""
        return _openshot.QtTextReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(QtTextReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.QtTextReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(QtTextReader self) -> bool"""
        return _openshot.QtTextReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(QtTextReader self) -> std::string"""
        return _openshot.QtTextReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(QtTextReader self) -> std::string"""
        return _openshot.QtTextReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(QtTextReader self, std::string const value)"""
        return _openshot.QtTextReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(QtTextReader self) -> Json::Value"""
        return _openshot.QtTextReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(QtTextReader self, Json::Value const root)"""
        return _openshot.QtTextReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(QtTextReader self)"""
        return _openshot.QtTextReader_Open(self, *args)
    __swig_destroy__ = _openshot.delete_QtTextReader

# Register QtTextReader in _openshot:
_openshot.QtTextReader_swigregister(QtTextReader)

class Keyframe(object):
    r"""Proxy of C++ openshot::Keyframe class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(Keyframe self) -> Keyframe
        __init__(Keyframe self, double value) -> Keyframe
        """
        _openshot.Keyframe_swiginit(self, _openshot.new_Keyframe(*args))

    def AddPoint(self, *args):
        r"""
        AddPoint(Keyframe self, Point p)
        AddPoint(Keyframe self, double x, double y)
        AddPoint(Keyframe self, double x, double y, openshot::InterpolationType interpolate)
        """
        return _openshot.Keyframe_AddPoint(self, *args)

    def Contains(self, *args):
        r"""Contains(Keyframe self, Point p) -> bool"""
        return _openshot.Keyframe_Contains(self, *args)

    def FlipPoints(self, *args):
        r"""FlipPoints(Keyframe self)"""
        return _openshot.Keyframe_FlipPoints(self, *args)

    def FindIndex(self, *args):
        r"""FindIndex(Keyframe self, Point p) -> int64_t"""
        return _openshot.Keyframe_FindIndex(self, *args)

    def GetValue(self, *args):
        r"""GetValue(Keyframe self, int64_t index) -> double"""
        return _openshot.Keyframe_GetValue(self, *args)

    def GetInt(self, *args):
        r"""GetInt(Keyframe self, int64_t index) -> int"""
        return _openshot.Keyframe_GetInt(self, *args)

    def GetLong(self, *args):
        r"""GetLong(Keyframe self, int64_t index) -> int64_t"""
        return _openshot.Keyframe_GetLong(self, *args)

    def GetRepeatFraction(self, *args):
        r"""GetRepeatFraction(Keyframe self, int64_t index) -> Fraction"""
        return _openshot.Keyframe_GetRepeatFraction(self, *args)

    def GetDelta(self, *args):
        r"""GetDelta(Keyframe self, int64_t index) -> double"""
        return _openshot.Keyframe_GetDelta(self, *args)

    def GetPoint(self, *args):
        r"""GetPoint(Keyframe self, int64_t index) -> Point"""
        return _openshot.Keyframe_GetPoint(self, *args)

    def GetClosestPoint(self, *args):
        r"""
        GetClosestPoint(Keyframe self, Point p) -> Point
        GetClosestPoint(Keyframe self, Point p, bool useLeft) -> Point
        """
        return _openshot.Keyframe_GetClosestPoint(self, *args)

    def GetPreviousPoint(self, *args):
        r"""GetPreviousPoint(Keyframe self, Point p) -> Point"""
        return _openshot.Keyframe_GetPreviousPoint(self, *args)

    def GetMaxPoint(self, *args):
        r"""GetMaxPoint(Keyframe self) -> Point"""
        return _openshot.Keyframe_GetMaxPoint(self, *args)

    def GetLength(self, *args):
        r"""GetLength(Keyframe self) -> int64_t"""
        return _openshot.Keyframe_GetLength(self, *args)

    def GetCount(self, *args):
        r"""GetCount(Keyframe self) -> int64_t"""
        return _openshot.Keyframe_GetCount(self, *args)

    def IsIncreasing(self, *args):
        r"""IsIncreasing(Keyframe self, int index) -> bool"""
        return _openshot.Keyframe_IsIncreasing(self, *args)

    def Json(self, *args):
        r"""Json(Keyframe self) -> std::string"""
        return _openshot.Keyframe_Json(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Keyframe self) -> Json::Value"""
        return _openshot.Keyframe_JsonValue(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Keyframe self, std::string const value)"""
        return _openshot.Keyframe_SetJson(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Keyframe self, Json::Value const root)"""
        return _openshot.Keyframe_SetJsonValue(self, *args)

    def RemovePoint(self, *args):
        r"""
        RemovePoint(Keyframe self, Point p)
        RemovePoint(Keyframe self, int64_t index)
        """
        return _openshot.Keyframe_RemovePoint(self, *args)

    def ScalePoints(self, *args):
        r"""ScalePoints(Keyframe self, double scale)"""
        return _openshot.Keyframe_ScalePoints(self, *args)

    def UpdatePoint(self, *args):
        r"""UpdatePoint(Keyframe self, int64_t index, Point p)"""
        return _openshot.Keyframe_UpdatePoint(self, *args)

    def PrintPoints(self, *args):
        r"""PrintPoints(Keyframe self)"""
        return _openshot.Keyframe_PrintPoints(self, *args)

    def PrintValues(self, *args):
        r"""PrintValues(Keyframe self)"""
        return _openshot.Keyframe_PrintValues(self, *args)
    __swig_destroy__ = _openshot.delete_Keyframe

# Register Keyframe in _openshot:
_openshot.Keyframe_swigregister(Keyframe)

class RendererBase(object):
    r"""Proxy of C++ openshot::RendererBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def paint(self, *args):
        r"""paint(RendererBase self, std::shared_ptr< openshot::Frame > const & frame)"""
        return _openshot.RendererBase_paint(self, *args)

    def OverrideWidget(self, *args):
        r"""OverrideWidget(RendererBase self, int64_t qwidget_address)"""
        return _openshot.RendererBase_OverrideWidget(self, *args)

# Register RendererBase in _openshot:
_openshot.RendererBase_swigregister(RendererBase)

class Settings(object):
    r"""Proxy of C++ openshot::Settings class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    HARDWARE_DECODER = property(_openshot.Settings_HARDWARE_DECODER_get, _openshot.Settings_HARDWARE_DECODER_set, doc=r"""HARDWARE_DECODER : int""")
    HIGH_QUALITY_SCALING = property(_openshot.Settings_HIGH_QUALITY_SCALING_get, _openshot.Settings_HIGH_QUALITY_SCALING_set, doc=r"""HIGH_QUALITY_SCALING : bool""")
    MAX_WIDTH = property(_openshot.Settings_MAX_WIDTH_get, _openshot.Settings_MAX_WIDTH_set, doc=r"""MAX_WIDTH : int""")
    MAX_HEIGHT = property(_openshot.Settings_MAX_HEIGHT_get, _openshot.Settings_MAX_HEIGHT_set, doc=r"""MAX_HEIGHT : int""")
    WAIT_FOR_VIDEO_PROCESSING_TASK = property(_openshot.Settings_WAIT_FOR_VIDEO_PROCESSING_TASK_get, _openshot.Settings_WAIT_FOR_VIDEO_PROCESSING_TASK_set, doc=r"""WAIT_FOR_VIDEO_PROCESSING_TASK : bool""")
    OMP_THREADS = property(_openshot.Settings_OMP_THREADS_get, _openshot.Settings_OMP_THREADS_set, doc=r"""OMP_THREADS : int""")
    FF_THREADS = property(_openshot.Settings_FF_THREADS_get, _openshot.Settings_FF_THREADS_set, doc=r"""FF_THREADS : int""")
    DE_LIMIT_HEIGHT_MAX = property(_openshot.Settings_DE_LIMIT_HEIGHT_MAX_get, _openshot.Settings_DE_LIMIT_HEIGHT_MAX_set, doc=r"""DE_LIMIT_HEIGHT_MAX : int""")
    DE_LIMIT_WIDTH_MAX = property(_openshot.Settings_DE_LIMIT_WIDTH_MAX_get, _openshot.Settings_DE_LIMIT_WIDTH_MAX_set, doc=r"""DE_LIMIT_WIDTH_MAX : int""")
    HW_DE_DEVICE_SET = property(_openshot.Settings_HW_DE_DEVICE_SET_get, _openshot.Settings_HW_DE_DEVICE_SET_set, doc=r"""HW_DE_DEVICE_SET : int""")
    HW_EN_DEVICE_SET = property(_openshot.Settings_HW_EN_DEVICE_SET_get, _openshot.Settings_HW_EN_DEVICE_SET_set, doc=r"""HW_EN_DEVICE_SET : int""")
    PLAYBACK_AUDIO_DEVICE_NAME = property(_openshot.Settings_PLAYBACK_AUDIO_DEVICE_NAME_get, _openshot.Settings_PLAYBACK_AUDIO_DEVICE_NAME_set, doc=r"""PLAYBACK_AUDIO_DEVICE_NAME : std::string""")

    @staticmethod
    def Instance(*args):
        r"""Instance() -> Settings"""
        return _openshot.Settings_Instance(*args)
    __swig_destroy__ = _openshot.delete_Settings

# Register Settings in _openshot:
_openshot.Settings_swigregister(Settings)

def Settings_Instance(*args):
    r"""Settings_Instance() -> Settings"""
    return _openshot.Settings_Instance(*args)

class CompareClips(object):
    r"""Proxy of C++ openshot::CompareClips class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __call__(self, *args):
        r"""__call__(CompareClips self, Clip lhs, Clip rhs) -> bool"""
        return _openshot.CompareClips___call__(self, *args)

    def __init__(self, *args):
        r"""__init__(CompareClips self) -> CompareClips"""
        _openshot.CompareClips_swiginit(self, _openshot.new_CompareClips(*args))
    __swig_destroy__ = _openshot.delete_CompareClips

# Register CompareClips in _openshot:
_openshot.CompareClips_swigregister(CompareClips)

class CompareEffects(object):
    r"""Proxy of C++ openshot::CompareEffects class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __call__(self, *args):
        r"""__call__(CompareEffects self, EffectBase lhs, EffectBase rhs) -> bool"""
        return _openshot.CompareEffects___call__(self, *args)

    def __init__(self, *args):
        r"""__init__(CompareEffects self) -> CompareEffects"""
        _openshot.CompareEffects_swiginit(self, _openshot.new_CompareEffects(*args))
    __swig_destroy__ = _openshot.delete_CompareEffects

# Register CompareEffects in _openshot:
_openshot.CompareEffects_swigregister(CompareEffects)

class Timeline(ReaderBase):
    r"""Proxy of C++ openshot::Timeline class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(Timeline self, int width, int height, Fraction fps, int sample_rate, int channels, openshot::ChannelLayout channel_layout) -> Timeline"""
        _openshot.Timeline_swiginit(self, _openshot.new_Timeline(*args))
    __swig_destroy__ = _openshot.delete_Timeline

    def AddClip(self, *args):
        r"""AddClip(Timeline self, Clip clip)"""
        return _openshot.Timeline_AddClip(self, *args)

    def AddEffect(self, *args):
        r"""AddEffect(Timeline self, EffectBase effect)"""
        return _openshot.Timeline_AddEffect(self, *args)

    def ApplyMapperToClips(self, *args):
        r"""ApplyMapperToClips(Timeline self)"""
        return _openshot.Timeline_ApplyMapperToClips(self, *args)

    def AutoMapClips(self, *args):
        r"""
        AutoMapClips(Timeline self) -> bool
        AutoMapClips(Timeline self, bool auto_map)
        """
        return _openshot.Timeline_AutoMapClips(self, *args)

    def ClearAllCache(self, *args):
        r"""ClearAllCache(Timeline self)"""
        return _openshot.Timeline_ClearAllCache(self, *args)

    def Clips(self, *args):
        r"""Clips(Timeline self) -> ClipList"""
        return _openshot.Timeline_Clips(self, *args)

    def Close(self, *args):
        r"""Close(Timeline self)"""
        return _openshot.Timeline_Close(self, *args)

    def Effects(self, *args):
        r"""Effects(Timeline self) -> EffectBaseList"""
        return _openshot.Timeline_Effects(self, *args)

    def GetCache(self, *args):
        r"""GetCache(Timeline self) -> CacheBase"""
        return _openshot.Timeline_GetCache(self, *args)

    def SetCache(self, *args):
        r"""SetCache(Timeline self, CacheBase new_cache)"""
        return _openshot.Timeline_SetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(Timeline self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Timeline_GetFrame(self, *args)
    viewport_scale = property(_openshot.Timeline_viewport_scale_get, _openshot.Timeline_viewport_scale_set, doc=r"""viewport_scale : openshot::Keyframe""")
    viewport_x = property(_openshot.Timeline_viewport_x_get, _openshot.Timeline_viewport_x_set, doc=r"""viewport_x : openshot::Keyframe""")
    viewport_y = property(_openshot.Timeline_viewport_y_get, _openshot.Timeline_viewport_y_set, doc=r"""viewport_y : openshot::Keyframe""")
    color = property(_openshot.Timeline_color_get, _openshot.Timeline_color_set, doc=r"""color : openshot::Color""")

    def IsOpen(self, *args):
        r"""IsOpen(Timeline self) -> bool"""
        return _openshot.Timeline_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(Timeline self) -> std::string"""
        return _openshot.Timeline_Name(self, *args)

    def Json(self, *args):
        r"""Json(Timeline self) -> std::string"""
        return _openshot.Timeline_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Timeline self, std::string const value)"""
        return _openshot.Timeline_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Timeline self) -> Json::Value"""
        return _openshot.Timeline_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Timeline self, Json::Value const root)"""
        return _openshot.Timeline_SetJsonValue(self, *args)

    def SetMaxSize(self, *args):
        r"""SetMaxSize(Timeline self, int width, int height)"""
        return _openshot.Timeline_SetMaxSize(self, *args)

    def ApplyJsonDiff(self, *args):
        r"""ApplyJsonDiff(Timeline self, std::string value)"""
        return _openshot.Timeline_ApplyJsonDiff(self, *args)

    def Open(self, *args):
        r"""Open(Timeline self)"""
        return _openshot.Timeline_Open(self, *args)

    def RemoveClip(self, *args):
        r"""RemoveClip(Timeline self, Clip clip)"""
        return _openshot.Timeline_RemoveClip(self, *args)

    def RemoveEffect(self, *args):
        r"""RemoveEffect(Timeline self, EffectBase effect)"""
        return _openshot.Timeline_RemoveEffect(self, *args)

# Register Timeline in _openshot:
_openshot.Timeline_swigregister(Timeline)

class ZmqLogger(object):
    r"""Proxy of C++ openshot::ZmqLogger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def Instance(*args):
        r"""Instance() -> ZmqLogger"""
        return _openshot.ZmqLogger_Instance(*args)

    def AppendDebugMethod(self, *args):
        r"""AppendDebugMethod(ZmqLogger self, std::string method_name, std::string arg1_name="", float arg1_value=-1.0, std::string arg2_name="", float arg2_value=-1.0, std::string arg3_name="", float arg3_value=-1.0, std::string arg4_name="", float arg4_value=-1.0, std::string arg5_name="", float arg5_value=-1.0, std::string arg6_name="", float arg6_value=-1.0)"""
        return _openshot.ZmqLogger_AppendDebugMethod(self, *args)

    def Close(self, *args):
        r"""Close(ZmqLogger self)"""
        return _openshot.ZmqLogger_Close(self, *args)

    def Connection(self, *args):
        r"""Connection(ZmqLogger self, std::string new_connection)"""
        return _openshot.ZmqLogger_Connection(self, *args)

    def Enable(self, *args):
        r"""Enable(ZmqLogger self, bool is_enabled)"""
        return _openshot.ZmqLogger_Enable(self, *args)

    def Path(self, *args):
        r"""Path(ZmqLogger self, std::string new_path)"""
        return _openshot.ZmqLogger_Path(self, *args)

    def Log(self, *args):
        r"""Log(ZmqLogger self, std::string message)"""
        return _openshot.ZmqLogger_Log(self, *args)

    def LogToFile(self, *args):
        r"""LogToFile(ZmqLogger self, std::string message)"""
        return _openshot.ZmqLogger_LogToFile(self, *args)
    __swig_destroy__ = _openshot.delete_ZmqLogger

# Register ZmqLogger in _openshot:
_openshot.ZmqLogger_swigregister(ZmqLogger)

def ZmqLogger_Instance(*args):
    r"""ZmqLogger_Instance() -> ZmqLogger"""
    return _openshot.ZmqLogger_Instance(*args)

class AudioDeviceInfo(object):
    r"""Proxy of C++ openshot::AudioDeviceInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    name = property(_openshot.AudioDeviceInfo_name_get, _openshot.AudioDeviceInfo_name_set, doc=r"""name : std::string""")
    type = property(_openshot.AudioDeviceInfo_type_get, _openshot.AudioDeviceInfo_type_set, doc=r"""type : std::string""")

    def __init__(self, *args):
        r"""__init__(AudioDeviceInfo self) -> AudioDeviceInfo"""
        _openshot.AudioDeviceInfo_swiginit(self, _openshot.new_AudioDeviceInfo(*args))
    __swig_destroy__ = _openshot.delete_AudioDeviceInfo

# Register AudioDeviceInfo in _openshot:
_openshot.AudioDeviceInfo_swigregister(AudioDeviceInfo)

class ImageReader(ReaderBase):
    r"""Proxy of C++ openshot::ImageReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ImageReader self, std::string path) -> ImageReader
        __init__(ImageReader self, std::string path, bool inspect_reader) -> ImageReader
        """
        _openshot.ImageReader_swiginit(self, _openshot.new_ImageReader(*args))

    def Close(self, *args):
        r"""Close(ImageReader self)"""
        return _openshot.ImageReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(ImageReader self) -> CacheMemory"""
        return _openshot.ImageReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(ImageReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.ImageReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(ImageReader self) -> bool"""
        return _openshot.ImageReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(ImageReader self) -> std::string"""
        return _openshot.ImageReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(ImageReader self) -> std::string"""
        return _openshot.ImageReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(ImageReader self, std::string const value)"""
        return _openshot.ImageReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(ImageReader self) -> Json::Value"""
        return _openshot.ImageReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(ImageReader self, Json::Value const root)"""
        return _openshot.ImageReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(ImageReader self)"""
        return _openshot.ImageReader_Open(self, *args)
    __swig_destroy__ = _openshot.delete_ImageReader

# Register ImageReader in _openshot:
_openshot.ImageReader_swigregister(ImageReader)

class ImageWriter(WriterBase):
    r"""Proxy of C++ openshot::ImageWriter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(ImageWriter self, std::string path) -> ImageWriter"""
        _openshot.ImageWriter_swiginit(self, _openshot.new_ImageWriter(*args))

    def Close(self, *args):
        r"""Close(ImageWriter self)"""
        return _openshot.ImageWriter_Close(self, *args)

    def GetCacheSize(self, *args):
        r"""GetCacheSize(ImageWriter self) -> int"""
        return _openshot.ImageWriter_GetCacheSize(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(ImageWriter self) -> bool"""
        return _openshot.ImageWriter_IsOpen(self, *args)

    def Open(self, *args):
        r"""Open(ImageWriter self)"""
        return _openshot.ImageWriter_Open(self, *args)

    def SetCacheSize(self, *args):
        r"""SetCacheSize(ImageWriter self, int new_size)"""
        return _openshot.ImageWriter_SetCacheSize(self, *args)

    def SetVideoOptions(self, *args):
        r"""SetVideoOptions(ImageWriter self, std::string format, Fraction fps, int width, int height, int quality, int loops, bool combine)"""
        return _openshot.ImageWriter_SetVideoOptions(self, *args)

    def WriteFrame(self, *args):
        r"""
        WriteFrame(ImageWriter self, std::shared_ptr< openshot::Frame > frame)
        WriteFrame(ImageWriter self, ReaderBase reader, int64_t start, int64_t length)
        """
        return _openshot.ImageWriter_WriteFrame(self, *args)
    __swig_destroy__ = _openshot.delete_ImageWriter

# Register ImageWriter in _openshot:
_openshot.ImageWriter_swigregister(ImageWriter)

class TextReader(ReaderBase):
    r"""Proxy of C++ openshot::TextReader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(TextReader self) -> TextReader
        __init__(TextReader self, int width, int height, int x_offset, int y_offset, openshot::GravityType gravity, std::string text, std::string font, double size, std::string text_color, std::string background_color) -> TextReader
        """
        _openshot.TextReader_swiginit(self, _openshot.new_TextReader(*args))

    def SetTextBackgroundColor(self, *args):
        r"""SetTextBackgroundColor(TextReader self, std::string color)"""
        return _openshot.TextReader_SetTextBackgroundColor(self, *args)

    def Close(self, *args):
        r"""Close(TextReader self)"""
        return _openshot.TextReader_Close(self, *args)

    def GetCache(self, *args):
        r"""GetCache(TextReader self) -> CacheMemory"""
        return _openshot.TextReader_GetCache(self, *args)

    def GetFrame(self, *args):
        r"""GetFrame(TextReader self, int64_t requested_frame) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.TextReader_GetFrame(self, *args)

    def IsOpen(self, *args):
        r"""IsOpen(TextReader self) -> bool"""
        return _openshot.TextReader_IsOpen(self, *args)

    def Name(self, *args):
        r"""Name(TextReader self) -> std::string"""
        return _openshot.TextReader_Name(self, *args)

    def Json(self, *args):
        r"""Json(TextReader self) -> std::string"""
        return _openshot.TextReader_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(TextReader self, std::string const value)"""
        return _openshot.TextReader_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(TextReader self) -> Json::Value"""
        return _openshot.TextReader_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(TextReader self, Json::Value const root)"""
        return _openshot.TextReader_SetJsonValue(self, *args)

    def Open(self, *args):
        r"""Open(TextReader self)"""
        return _openshot.TextReader_Open(self, *args)
    __swig_destroy__ = _openshot.delete_TextReader

# Register TextReader in _openshot:
_openshot.TextReader_swigregister(TextReader)

class Bars(EffectBase):
    r"""Proxy of C++ openshot::Bars class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    color = property(_openshot.Bars_color_get, _openshot.Bars_color_set, doc=r"""color : openshot::Color""")
    left = property(_openshot.Bars_left_get, _openshot.Bars_left_set, doc=r"""left : openshot::Keyframe""")
    top = property(_openshot.Bars_top_get, _openshot.Bars_top_set, doc=r"""top : openshot::Keyframe""")
    right = property(_openshot.Bars_right_get, _openshot.Bars_right_set, doc=r"""right : openshot::Keyframe""")
    bottom = property(_openshot.Bars_bottom_get, _openshot.Bars_bottom_set, doc=r"""bottom : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Bars self) -> Bars
        __init__(Bars self, Color color, Keyframe left, Keyframe top, Keyframe right, Keyframe bottom) -> Bars
        """
        _openshot.Bars_swiginit(self, _openshot.new_Bars(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Bars self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Bars_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Bars self) -> std::string"""
        return _openshot.Bars_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Bars self, std::string const value)"""
        return _openshot.Bars_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Bars self) -> Json::Value"""
        return _openshot.Bars_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Bars self, Json::Value const root)"""
        return _openshot.Bars_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Bars self, int64_t requested_frame) -> std::string"""
        return _openshot.Bars_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Bars

# Register Bars in _openshot:
_openshot.Bars_swigregister(Bars)

class Blur(EffectBase):
    r"""Proxy of C++ openshot::Blur class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    horizontal_radius = property(_openshot.Blur_horizontal_radius_get, _openshot.Blur_horizontal_radius_set, doc=r"""horizontal_radius : openshot::Keyframe""")
    vertical_radius = property(_openshot.Blur_vertical_radius_get, _openshot.Blur_vertical_radius_set, doc=r"""vertical_radius : openshot::Keyframe""")
    sigma = property(_openshot.Blur_sigma_get, _openshot.Blur_sigma_set, doc=r"""sigma : openshot::Keyframe""")
    iterations = property(_openshot.Blur_iterations_get, _openshot.Blur_iterations_set, doc=r"""iterations : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Blur self) -> Blur
        __init__(Blur self, Keyframe new_horizontal_radius, Keyframe new_vertical_radius, Keyframe new_sigma, Keyframe new_iterations) -> Blur
        """
        _openshot.Blur_swiginit(self, _openshot.new_Blur(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Blur self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Blur_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Blur self) -> std::string"""
        return _openshot.Blur_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Blur self, std::string const value)"""
        return _openshot.Blur_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Blur self) -> Json::Value"""
        return _openshot.Blur_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Blur self, Json::Value const root)"""
        return _openshot.Blur_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Blur self, int64_t requested_frame) -> std::string"""
        return _openshot.Blur_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Blur

# Register Blur in _openshot:
_openshot.Blur_swigregister(Blur)

class Brightness(EffectBase):
    r"""Proxy of C++ openshot::Brightness class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    brightness = property(_openshot.Brightness_brightness_get, _openshot.Brightness_brightness_set, doc=r"""brightness : openshot::Keyframe""")
    contrast = property(_openshot.Brightness_contrast_get, _openshot.Brightness_contrast_set, doc=r"""contrast : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Brightness self) -> Brightness
        __init__(Brightness self, Keyframe new_brightness, Keyframe new_contrast) -> Brightness
        """
        _openshot.Brightness_swiginit(self, _openshot.new_Brightness(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Brightness self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Brightness_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Brightness self) -> std::string"""
        return _openshot.Brightness_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Brightness self, std::string const value)"""
        return _openshot.Brightness_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Brightness self) -> Json::Value"""
        return _openshot.Brightness_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Brightness self, Json::Value const root)"""
        return _openshot.Brightness_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Brightness self, int64_t requested_frame) -> std::string"""
        return _openshot.Brightness_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Brightness

# Register Brightness in _openshot:
_openshot.Brightness_swigregister(Brightness)

class ChromaKey(EffectBase):
    r"""Proxy of C++ openshot::ChromaKey class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ChromaKey self) -> ChromaKey
        __init__(ChromaKey self, Color color, Keyframe fuzz) -> ChromaKey
        """
        _openshot.ChromaKey_swiginit(self, _openshot.new_ChromaKey(*args))

    def GetFrame(self, *args):
        r"""GetFrame(ChromaKey self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.ChromaKey_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(ChromaKey self) -> std::string"""
        return _openshot.ChromaKey_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(ChromaKey self, std::string const value)"""
        return _openshot.ChromaKey_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(ChromaKey self) -> Json::Value"""
        return _openshot.ChromaKey_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(ChromaKey self, Json::Value const root)"""
        return _openshot.ChromaKey_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(ChromaKey self, int64_t requested_frame) -> std::string"""
        return _openshot.ChromaKey_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_ChromaKey

# Register ChromaKey in _openshot:
_openshot.ChromaKey_swigregister(ChromaKey)

class ColorShift(EffectBase):
    r"""Proxy of C++ openshot::ColorShift class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    red_x = property(_openshot.ColorShift_red_x_get, _openshot.ColorShift_red_x_set, doc=r"""red_x : openshot::Keyframe""")
    red_y = property(_openshot.ColorShift_red_y_get, _openshot.ColorShift_red_y_set, doc=r"""red_y : openshot::Keyframe""")
    green_x = property(_openshot.ColorShift_green_x_get, _openshot.ColorShift_green_x_set, doc=r"""green_x : openshot::Keyframe""")
    green_y = property(_openshot.ColorShift_green_y_get, _openshot.ColorShift_green_y_set, doc=r"""green_y : openshot::Keyframe""")
    blue_x = property(_openshot.ColorShift_blue_x_get, _openshot.ColorShift_blue_x_set, doc=r"""blue_x : openshot::Keyframe""")
    blue_y = property(_openshot.ColorShift_blue_y_get, _openshot.ColorShift_blue_y_set, doc=r"""blue_y : openshot::Keyframe""")
    alpha_x = property(_openshot.ColorShift_alpha_x_get, _openshot.ColorShift_alpha_x_set, doc=r"""alpha_x : openshot::Keyframe""")
    alpha_y = property(_openshot.ColorShift_alpha_y_get, _openshot.ColorShift_alpha_y_set, doc=r"""alpha_y : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(ColorShift self) -> ColorShift
        __init__(ColorShift self, Keyframe red_x, Keyframe red_y, Keyframe green_x, Keyframe green_y, Keyframe blue_x, Keyframe blue_y, Keyframe alpha_x, Keyframe alpha_y) -> ColorShift
        """
        _openshot.ColorShift_swiginit(self, _openshot.new_ColorShift(*args))

    def GetFrame(self, *args):
        r"""GetFrame(ColorShift self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.ColorShift_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(ColorShift self) -> std::string"""
        return _openshot.ColorShift_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(ColorShift self, std::string const value)"""
        return _openshot.ColorShift_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(ColorShift self) -> Json::Value"""
        return _openshot.ColorShift_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(ColorShift self, Json::Value const root)"""
        return _openshot.ColorShift_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(ColorShift self, int64_t requested_frame) -> std::string"""
        return _openshot.ColorShift_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_ColorShift

# Register ColorShift in _openshot:
_openshot.ColorShift_swigregister(ColorShift)

class Crop(EffectBase):
    r"""Proxy of C++ openshot::Crop class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    color = property(_openshot.Crop_color_get, _openshot.Crop_color_set, doc=r"""color : openshot::Color""")
    left = property(_openshot.Crop_left_get, _openshot.Crop_left_set, doc=r"""left : openshot::Keyframe""")
    top = property(_openshot.Crop_top_get, _openshot.Crop_top_set, doc=r"""top : openshot::Keyframe""")
    right = property(_openshot.Crop_right_get, _openshot.Crop_right_set, doc=r"""right : openshot::Keyframe""")
    bottom = property(_openshot.Crop_bottom_get, _openshot.Crop_bottom_set, doc=r"""bottom : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Crop self) -> Crop
        __init__(Crop self, Keyframe left, Keyframe top, Keyframe right, Keyframe bottom) -> Crop
        """
        _openshot.Crop_swiginit(self, _openshot.new_Crop(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Crop self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Crop_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Crop self) -> std::string"""
        return _openshot.Crop_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Crop self, std::string const value)"""
        return _openshot.Crop_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Crop self) -> Json::Value"""
        return _openshot.Crop_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Crop self, Json::Value const root)"""
        return _openshot.Crop_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Crop self, int64_t requested_frame) -> std::string"""
        return _openshot.Crop_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Crop

# Register Crop in _openshot:
_openshot.Crop_swigregister(Crop)

class Deinterlace(EffectBase):
    r"""Proxy of C++ openshot::Deinterlace class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(Deinterlace self) -> Deinterlace
        __init__(Deinterlace self, bool isOdd) -> Deinterlace
        """
        _openshot.Deinterlace_swiginit(self, _openshot.new_Deinterlace(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Deinterlace self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Deinterlace_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Deinterlace self) -> std::string"""
        return _openshot.Deinterlace_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Deinterlace self, std::string const value)"""
        return _openshot.Deinterlace_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Deinterlace self) -> Json::Value"""
        return _openshot.Deinterlace_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Deinterlace self, Json::Value const root)"""
        return _openshot.Deinterlace_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Deinterlace self, int64_t requested_frame) -> std::string"""
        return _openshot.Deinterlace_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Deinterlace

# Register Deinterlace in _openshot:
_openshot.Deinterlace_swigregister(Deinterlace)

class Hue(EffectBase):
    r"""Proxy of C++ openshot::Hue class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    hue = property(_openshot.Hue_hue_get, _openshot.Hue_hue_set, doc=r"""hue : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Hue self) -> Hue
        __init__(Hue self, Keyframe hue) -> Hue
        """
        _openshot.Hue_swiginit(self, _openshot.new_Hue(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Hue self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Hue_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Hue self) -> std::string"""
        return _openshot.Hue_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Hue self, std::string const value)"""
        return _openshot.Hue_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Hue self) -> Json::Value"""
        return _openshot.Hue_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Hue self, Json::Value const root)"""
        return _openshot.Hue_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Hue self, int64_t requested_frame) -> std::string"""
        return _openshot.Hue_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Hue

# Register Hue in _openshot:
_openshot.Hue_swigregister(Hue)

class Mask(EffectBase):
    r"""Proxy of C++ openshot::Mask class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    replace_image = property(_openshot.Mask_replace_image_get, _openshot.Mask_replace_image_set, doc=r"""replace_image : bool""")
    brightness = property(_openshot.Mask_brightness_get, _openshot.Mask_brightness_set, doc=r"""brightness : openshot::Keyframe""")
    contrast = property(_openshot.Mask_contrast_get, _openshot.Mask_contrast_set, doc=r"""contrast : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Mask self) -> Mask
        __init__(Mask self, ReaderBase mask_reader, Keyframe mask_brightness, Keyframe mask_contrast) -> Mask
        """
        _openshot.Mask_swiginit(self, _openshot.new_Mask(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Mask self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Mask_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Mask self) -> std::string"""
        return _openshot.Mask_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Mask self, std::string const value)"""
        return _openshot.Mask_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Mask self) -> Json::Value"""
        return _openshot.Mask_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Mask self, Json::Value const root)"""
        return _openshot.Mask_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Mask self, int64_t requested_frame) -> std::string"""
        return _openshot.Mask_PropertiesJSON(self, *args)

    def Reader(self, *args):
        r"""
        Reader(Mask self) -> ReaderBase
        Reader(Mask self, ReaderBase new_reader)
        """
        return _openshot.Mask_Reader(self, *args)
    __swig_destroy__ = _openshot.delete_Mask

# Register Mask in _openshot:
_openshot.Mask_swigregister(Mask)

class Negate(EffectBase):
    r"""Proxy of C++ openshot::Negate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(Negate self) -> Negate"""
        _openshot.Negate_swiginit(self, _openshot.new_Negate(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Negate self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Negate_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Negate self) -> std::string"""
        return _openshot.Negate_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Negate self, std::string const value)"""
        return _openshot.Negate_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Negate self) -> Json::Value"""
        return _openshot.Negate_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Negate self, Json::Value const root)"""
        return _openshot.Negate_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Negate self, int64_t requested_frame) -> std::string"""
        return _openshot.Negate_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Negate

# Register Negate in _openshot:
_openshot.Negate_swigregister(Negate)

class Pixelate(EffectBase):
    r"""Proxy of C++ openshot::Pixelate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    pixelization = property(_openshot.Pixelate_pixelization_get, _openshot.Pixelate_pixelization_set, doc=r"""pixelization : openshot::Keyframe""")
    left = property(_openshot.Pixelate_left_get, _openshot.Pixelate_left_set, doc=r"""left : openshot::Keyframe""")
    top = property(_openshot.Pixelate_top_get, _openshot.Pixelate_top_set, doc=r"""top : openshot::Keyframe""")
    right = property(_openshot.Pixelate_right_get, _openshot.Pixelate_right_set, doc=r"""right : openshot::Keyframe""")
    bottom = property(_openshot.Pixelate_bottom_get, _openshot.Pixelate_bottom_set, doc=r"""bottom : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Pixelate self) -> Pixelate
        __init__(Pixelate self, Keyframe pixelization, Keyframe left, Keyframe top, Keyframe right, Keyframe bottom) -> Pixelate
        """
        _openshot.Pixelate_swiginit(self, _openshot.new_Pixelate(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Pixelate self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Pixelate_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Pixelate self) -> std::string"""
        return _openshot.Pixelate_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Pixelate self, std::string const value)"""
        return _openshot.Pixelate_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Pixelate self) -> Json::Value"""
        return _openshot.Pixelate_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Pixelate self, Json::Value const root)"""
        return _openshot.Pixelate_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Pixelate self, int64_t requested_frame) -> std::string"""
        return _openshot.Pixelate_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Pixelate

# Register Pixelate in _openshot:
_openshot.Pixelate_swigregister(Pixelate)

class Saturation(EffectBase):
    r"""Proxy of C++ openshot::Saturation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    saturation = property(_openshot.Saturation_saturation_get, _openshot.Saturation_saturation_set, doc=r"""saturation : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Saturation self) -> Saturation
        __init__(Saturation self, Keyframe new_saturation) -> Saturation
        """
        _openshot.Saturation_swiginit(self, _openshot.new_Saturation(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Saturation self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Saturation_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Saturation self) -> std::string"""
        return _openshot.Saturation_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Saturation self, std::string const value)"""
        return _openshot.Saturation_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Saturation self) -> Json::Value"""
        return _openshot.Saturation_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Saturation self, Json::Value const root)"""
        return _openshot.Saturation_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Saturation self, int64_t requested_frame) -> std::string"""
        return _openshot.Saturation_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Saturation

# Register Saturation in _openshot:
_openshot.Saturation_swigregister(Saturation)

class Shift(EffectBase):
    r"""Proxy of C++ openshot::Shift class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_openshot.Shift_x_get, _openshot.Shift_x_set, doc=r"""x : openshot::Keyframe""")
    y = property(_openshot.Shift_y_get, _openshot.Shift_y_set, doc=r"""y : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Shift self) -> Shift
        __init__(Shift self, Keyframe x, Keyframe y) -> Shift
        """
        _openshot.Shift_swiginit(self, _openshot.new_Shift(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Shift self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Shift_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Shift self) -> std::string"""
        return _openshot.Shift_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Shift self, std::string const value)"""
        return _openshot.Shift_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Shift self) -> Json::Value"""
        return _openshot.Shift_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Shift self, Json::Value const root)"""
        return _openshot.Shift_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Shift self, int64_t requested_frame) -> std::string"""
        return _openshot.Shift_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Shift

# Register Shift in _openshot:
_openshot.Shift_swigregister(Shift)

class Wave(EffectBase):
    r"""Proxy of C++ openshot::Wave class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    wavelength = property(_openshot.Wave_wavelength_get, _openshot.Wave_wavelength_set, doc=r"""wavelength : openshot::Keyframe""")
    amplitude = property(_openshot.Wave_amplitude_get, _openshot.Wave_amplitude_set, doc=r"""amplitude : openshot::Keyframe""")
    multiplier = property(_openshot.Wave_multiplier_get, _openshot.Wave_multiplier_set, doc=r"""multiplier : openshot::Keyframe""")
    shift_x = property(_openshot.Wave_shift_x_get, _openshot.Wave_shift_x_set, doc=r"""shift_x : openshot::Keyframe""")
    speed_y = property(_openshot.Wave_speed_y_get, _openshot.Wave_speed_y_set, doc=r"""speed_y : openshot::Keyframe""")

    def __init__(self, *args):
        r"""
        __init__(Wave self) -> Wave
        __init__(Wave self, Keyframe wavelength, Keyframe amplitude, Keyframe multiplier, Keyframe shift_x, Keyframe speed_y) -> Wave
        """
        _openshot.Wave_swiginit(self, _openshot.new_Wave(*args))

    def GetFrame(self, *args):
        r"""GetFrame(Wave self, std::shared_ptr< openshot::Frame > frame, int64_t frame_number) -> std::shared_ptr< openshot::Frame >"""
        return _openshot.Wave_GetFrame(self, *args)

    def Json(self, *args):
        r"""Json(Wave self) -> std::string"""
        return _openshot.Wave_Json(self, *args)

    def SetJson(self, *args):
        r"""SetJson(Wave self, std::string const value)"""
        return _openshot.Wave_SetJson(self, *args)

    def JsonValue(self, *args):
        r"""JsonValue(Wave self) -> Json::Value"""
        return _openshot.Wave_JsonValue(self, *args)

    def SetJsonValue(self, *args):
        r"""SetJsonValue(Wave self, Json::Value const root)"""
        return _openshot.Wave_SetJsonValue(self, *args)

    def PropertiesJSON(self, *args):
        r"""PropertiesJSON(Wave self, int64_t requested_frame) -> std::string"""
        return _openshot.Wave_PropertiesJSON(self, *args)
    __swig_destroy__ = _openshot.delete_Wave

# Register Wave in _openshot:
_openshot.Wave_swigregister(Wave)

class ClipList(object):
    r"""Proxy of C++ std::list< openshot::Clip * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(ClipList self) -> SwigPyIterator"""
        return _openshot.ClipList_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(ClipList self) -> bool"""
        return _openshot.ClipList___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(ClipList self) -> bool"""
        return _openshot.ClipList___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(ClipList self) -> std::list< openshot::Clip * >::size_type"""
        return _openshot.ClipList___len__(self, *args)

    def __getslice__(self, *args):
        r"""__getslice__(ClipList self, std::list< openshot::Clip * >::difference_type i, std::list< openshot::Clip * >::difference_type j) -> ClipList"""
        return _openshot.ClipList___getslice__(self, *args)

    def __setslice__(self, *args):
        r"""
        __setslice__(ClipList self, std::list< openshot::Clip * >::difference_type i, std::list< openshot::Clip * >::difference_type j)
        __setslice__(ClipList self, std::list< openshot::Clip * >::difference_type i, std::list< openshot::Clip * >::difference_type j, ClipList v)
        """
        return _openshot.ClipList___setslice__(self, *args)

    def __delslice__(self, *args):
        r"""__delslice__(ClipList self, std::list< openshot::Clip * >::difference_type i, std::list< openshot::Clip * >::difference_type j)"""
        return _openshot.ClipList___delslice__(self, *args)

    def __delitem__(self, *args):
        r"""
        __delitem__(ClipList self, std::list< openshot::Clip * >::difference_type i)
        __delitem__(ClipList self, PySliceObject * slice)
        """
        return _openshot.ClipList___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(ClipList self, PySliceObject * slice) -> ClipList
        __getitem__(ClipList self, std::list< openshot::Clip * >::difference_type i) -> Clip
        """
        return _openshot.ClipList___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(ClipList self, PySliceObject * slice, ClipList v)
        __setitem__(ClipList self, PySliceObject * slice)
        __setitem__(ClipList self, std::list< openshot::Clip * >::difference_type i, Clip x)
        """
        return _openshot.ClipList___setitem__(self, *args)

    def pop(self, *args):
        r"""pop(ClipList self) -> Clip"""
        return _openshot.ClipList_pop(self, *args)

    def append(self, *args):
        r"""append(ClipList self, Clip x)"""
        return _openshot.ClipList_append(self, *args)

    def empty(self, *args):
        r"""empty(ClipList self) -> bool"""
        return _openshot.ClipList_empty(self, *args)

    def size(self, *args):
        r"""size(ClipList self) -> std::list< openshot::Clip * >::size_type"""
        return _openshot.ClipList_size(self, *args)

    def swap(self, *args):
        r"""swap(ClipList self, ClipList v)"""
        return _openshot.ClipList_swap(self, *args)

    def begin(self, *args):
        r"""begin(ClipList self) -> std::list< openshot::Clip * >::iterator"""
        return _openshot.ClipList_begin(self, *args)

    def end(self, *args):
        r"""end(ClipList self) -> std::list< openshot::Clip * >::iterator"""
        return _openshot.ClipList_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(ClipList self) -> std::list< openshot::Clip * >::reverse_iterator"""
        return _openshot.ClipList_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(ClipList self) -> std::list< openshot::Clip * >::reverse_iterator"""
        return _openshot.ClipList_rend(self, *args)

    def clear(self, *args):
        r"""clear(ClipList self)"""
        return _openshot.ClipList_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(ClipList self) -> std::list< openshot::Clip * >::allocator_type"""
        return _openshot.ClipList_get_allocator(self, *args)

    def pop_back(self, *args):
        r"""pop_back(ClipList self)"""
        return _openshot.ClipList_pop_back(self, *args)

    def erase(self, *args):
        r"""
        erase(ClipList self, std::list< openshot::Clip * >::iterator pos) -> std::list< openshot::Clip * >::iterator
        erase(ClipList self, std::list< openshot::Clip * >::iterator first, std::list< openshot::Clip * >::iterator last) -> std::list< openshot::Clip * >::iterator
        """
        return _openshot.ClipList_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(ClipList self) -> ClipList
        __init__(ClipList self, ClipList other) -> ClipList
        __init__(ClipList self, std::list< openshot::Clip * >::size_type size) -> ClipList
        __init__(ClipList self, std::list< openshot::Clip * >::size_type size, Clip value) -> ClipList
        """
        _openshot.ClipList_swiginit(self, _openshot.new_ClipList(*args))

    def push_back(self, *args):
        r"""push_back(ClipList self, Clip x)"""
        return _openshot.ClipList_push_back(self, *args)

    def front(self, *args):
        r"""front(ClipList self) -> Clip"""
        return _openshot.ClipList_front(self, *args)

    def back(self, *args):
        r"""back(ClipList self) -> Clip"""
        return _openshot.ClipList_back(self, *args)

    def assign(self, *args):
        r"""assign(ClipList self, std::list< openshot::Clip * >::size_type n, Clip x)"""
        return _openshot.ClipList_assign(self, *args)

    def resize(self, *args):
        r"""
        resize(ClipList self, std::list< openshot::Clip * >::size_type new_size)
        resize(ClipList self, std::list< openshot::Clip * >::size_type new_size, Clip x)
        """
        return _openshot.ClipList_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(ClipList self, std::list< openshot::Clip * >::iterator pos, Clip x) -> std::list< openshot::Clip * >::iterator
        insert(ClipList self, std::list< openshot::Clip * >::iterator pos, std::list< openshot::Clip * >::size_type n, Clip x)
        """
        return _openshot.ClipList_insert(self, *args)

    def pop_front(self, *args):
        r"""pop_front(ClipList self)"""
        return _openshot.ClipList_pop_front(self, *args)

    def push_front(self, *args):
        r"""push_front(ClipList self, Clip x)"""
        return _openshot.ClipList_push_front(self, *args)

    def remove(self, *args):
        r"""remove(ClipList self, Clip x)"""
        return _openshot.ClipList_remove(self, *args)

    def unique(self, *args):
        r"""unique(ClipList self)"""
        return _openshot.ClipList_unique(self, *args)

    def reverse(self, *args):
        r"""reverse(ClipList self)"""
        return _openshot.ClipList_reverse(self, *args)

    def sort(self, *args):
        r"""sort(ClipList self)"""
        return _openshot.ClipList_sort(self, *args)

    def merge(self, *args):
        r"""merge(ClipList self, ClipList x)"""
        return _openshot.ClipList_merge(self, *args)
    __swig_destroy__ = _openshot.delete_ClipList

# Register ClipList in _openshot:
_openshot.ClipList_swigregister(ClipList)

class EffectBaseList(object):
    r"""Proxy of C++ std::list< openshot::EffectBase * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(EffectBaseList self) -> SwigPyIterator"""
        return _openshot.EffectBaseList_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(EffectBaseList self) -> bool"""
        return _openshot.EffectBaseList___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(EffectBaseList self) -> bool"""
        return _openshot.EffectBaseList___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(EffectBaseList self) -> std::list< openshot::EffectBase * >::size_type"""
        return _openshot.EffectBaseList___len__(self, *args)

    def __getslice__(self, *args):
        r"""__getslice__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i, std::list< openshot::EffectBase * >::difference_type j) -> EffectBaseList"""
        return _openshot.EffectBaseList___getslice__(self, *args)

    def __setslice__(self, *args):
        r"""
        __setslice__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i, std::list< openshot::EffectBase * >::difference_type j)
        __setslice__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i, std::list< openshot::EffectBase * >::difference_type j, EffectBaseList v)
        """
        return _openshot.EffectBaseList___setslice__(self, *args)

    def __delslice__(self, *args):
        r"""__delslice__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i, std::list< openshot::EffectBase * >::difference_type j)"""
        return _openshot.EffectBaseList___delslice__(self, *args)

    def __delitem__(self, *args):
        r"""
        __delitem__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i)
        __delitem__(EffectBaseList self, PySliceObject * slice)
        """
        return _openshot.EffectBaseList___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(EffectBaseList self, PySliceObject * slice) -> EffectBaseList
        __getitem__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i) -> EffectBase
        """
        return _openshot.EffectBaseList___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(EffectBaseList self, PySliceObject * slice, EffectBaseList v)
        __setitem__(EffectBaseList self, PySliceObject * slice)
        __setitem__(EffectBaseList self, std::list< openshot::EffectBase * >::difference_type i, EffectBase x)
        """
        return _openshot.EffectBaseList___setitem__(self, *args)

    def pop(self, *args):
        r"""pop(EffectBaseList self) -> EffectBase"""
        return _openshot.EffectBaseList_pop(self, *args)

    def append(self, *args):
        r"""append(EffectBaseList self, EffectBase x)"""
        return _openshot.EffectBaseList_append(self, *args)

    def empty(self, *args):
        r"""empty(EffectBaseList self) -> bool"""
        return _openshot.EffectBaseList_empty(self, *args)

    def size(self, *args):
        r"""size(EffectBaseList self) -> std::list< openshot::EffectBase * >::size_type"""
        return _openshot.EffectBaseList_size(self, *args)

    def swap(self, *args):
        r"""swap(EffectBaseList self, EffectBaseList v)"""
        return _openshot.EffectBaseList_swap(self, *args)

    def begin(self, *args):
        r"""begin(EffectBaseList self) -> std::list< openshot::EffectBase * >::iterator"""
        return _openshot.EffectBaseList_begin(self, *args)

    def end(self, *args):
        r"""end(EffectBaseList self) -> std::list< openshot::EffectBase * >::iterator"""
        return _openshot.EffectBaseList_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(EffectBaseList self) -> std::list< openshot::EffectBase * >::reverse_iterator"""
        return _openshot.EffectBaseList_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(EffectBaseList self) -> std::list< openshot::EffectBase * >::reverse_iterator"""
        return _openshot.EffectBaseList_rend(self, *args)

    def clear(self, *args):
        r"""clear(EffectBaseList self)"""
        return _openshot.EffectBaseList_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(EffectBaseList self) -> std::list< openshot::EffectBase * >::allocator_type"""
        return _openshot.EffectBaseList_get_allocator(self, *args)

    def pop_back(self, *args):
        r"""pop_back(EffectBaseList self)"""
        return _openshot.EffectBaseList_pop_back(self, *args)

    def erase(self, *args):
        r"""
        erase(EffectBaseList self, std::list< openshot::EffectBase * >::iterator pos) -> std::list< openshot::EffectBase * >::iterator
        erase(EffectBaseList self, std::list< openshot::EffectBase * >::iterator first, std::list< openshot::EffectBase * >::iterator last) -> std::list< openshot::EffectBase * >::iterator
        """
        return _openshot.EffectBaseList_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(EffectBaseList self) -> EffectBaseList
        __init__(EffectBaseList self, EffectBaseList other) -> EffectBaseList
        __init__(EffectBaseList self, std::list< openshot::EffectBase * >::size_type size) -> EffectBaseList
        __init__(EffectBaseList self, std::list< openshot::EffectBase * >::size_type size, EffectBase value) -> EffectBaseList
        """
        _openshot.EffectBaseList_swiginit(self, _openshot.new_EffectBaseList(*args))

    def push_back(self, *args):
        r"""push_back(EffectBaseList self, EffectBase x)"""
        return _openshot.EffectBaseList_push_back(self, *args)

    def front(self, *args):
        r"""front(EffectBaseList self) -> EffectBase"""
        return _openshot.EffectBaseList_front(self, *args)

    def back(self, *args):
        r"""back(EffectBaseList self) -> EffectBase"""
        return _openshot.EffectBaseList_back(self, *args)

    def assign(self, *args):
        r"""assign(EffectBaseList self, std::list< openshot::EffectBase * >::size_type n, EffectBase x)"""
        return _openshot.EffectBaseList_assign(self, *args)

    def resize(self, *args):
        r"""
        resize(EffectBaseList self, std::list< openshot::EffectBase * >::size_type new_size)
        resize(EffectBaseList self, std::list< openshot::EffectBase * >::size_type new_size, EffectBase x)
        """
        return _openshot.EffectBaseList_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(EffectBaseList self, std::list< openshot::EffectBase * >::iterator pos, EffectBase x) -> std::list< openshot::EffectBase * >::iterator
        insert(EffectBaseList self, std::list< openshot::EffectBase * >::iterator pos, std::list< openshot::EffectBase * >::size_type n, EffectBase x)
        """
        return _openshot.EffectBaseList_insert(self, *args)

    def pop_front(self, *args):
        r"""pop_front(EffectBaseList self)"""
        return _openshot.EffectBaseList_pop_front(self, *args)

    def push_front(self, *args):
        r"""push_front(EffectBaseList self, EffectBase x)"""
        return _openshot.EffectBaseList_push_front(self, *args)

    def remove(self, *args):
        r"""remove(EffectBaseList self, EffectBase x)"""
        return _openshot.EffectBaseList_remove(self, *args)

    def unique(self, *args):
        r"""unique(EffectBaseList self)"""
        return _openshot.EffectBaseList_unique(self, *args)

    def reverse(self, *args):
        r"""reverse(EffectBaseList self)"""
        return _openshot.EffectBaseList_reverse(self, *args)

    def sort(self, *args):
        r"""sort(EffectBaseList self)"""
        return _openshot.EffectBaseList_sort(self, *args)

    def merge(self, *args):
        r"""merge(EffectBaseList self, EffectBaseList x)"""
        return _openshot.EffectBaseList_merge(self, *args)
    __swig_destroy__ = _openshot.delete_EffectBaseList

# Register EffectBaseList in _openshot:
_openshot.EffectBaseList_swigregister(EffectBaseList)

class CoordinateVector(object):
    r"""Proxy of C++ std::vector< openshot::Coordinate > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(CoordinateVector self) -> SwigPyIterator"""
        return _openshot.CoordinateVector_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(CoordinateVector self) -> bool"""
        return _openshot.CoordinateVector___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(CoordinateVector self) -> bool"""
        return _openshot.CoordinateVector___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(CoordinateVector self) -> std::vector< openshot::Coordinate >::size_type"""
        return _openshot.CoordinateVector___len__(self, *args)

    def __getslice__(self, *args):
        r"""__getslice__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i, std::vector< openshot::Coordinate >::difference_type j) -> CoordinateVector"""
        return _openshot.CoordinateVector___getslice__(self, *args)

    def __setslice__(self, *args):
        r"""
        __setslice__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i, std::vector< openshot::Coordinate >::difference_type j)
        __setslice__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i, std::vector< openshot::Coordinate >::difference_type j, CoordinateVector v)
        """
        return _openshot.CoordinateVector___setslice__(self, *args)

    def __delslice__(self, *args):
        r"""__delslice__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i, std::vector< openshot::Coordinate >::difference_type j)"""
        return _openshot.CoordinateVector___delslice__(self, *args)

    def __delitem__(self, *args):
        r"""
        __delitem__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i)
        __delitem__(CoordinateVector self, PySliceObject * slice)
        """
        return _openshot.CoordinateVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(CoordinateVector self, PySliceObject * slice) -> CoordinateVector
        __getitem__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i) -> Coordinate
        """
        return _openshot.CoordinateVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(CoordinateVector self, PySliceObject * slice, CoordinateVector v)
        __setitem__(CoordinateVector self, PySliceObject * slice)
        __setitem__(CoordinateVector self, std::vector< openshot::Coordinate >::difference_type i, Coordinate x)
        """
        return _openshot.CoordinateVector___setitem__(self, *args)

    def pop(self, *args):
        r"""pop(CoordinateVector self) -> Coordinate"""
        return _openshot.CoordinateVector_pop(self, *args)

    def append(self, *args):
        r"""append(CoordinateVector self, Coordinate x)"""
        return _openshot.CoordinateVector_append(self, *args)

    def empty(self, *args):
        r"""empty(CoordinateVector self) -> bool"""
        return _openshot.CoordinateVector_empty(self, *args)

    def size(self, *args):
        r"""size(CoordinateVector self) -> std::vector< openshot::Coordinate >::size_type"""
        return _openshot.CoordinateVector_size(self, *args)

    def swap(self, *args):
        r"""swap(CoordinateVector self, CoordinateVector v)"""
        return _openshot.CoordinateVector_swap(self, *args)

    def begin(self, *args):
        r"""begin(CoordinateVector self) -> std::vector< openshot::Coordinate >::iterator"""
        return _openshot.CoordinateVector_begin(self, *args)

    def end(self, *args):
        r"""end(CoordinateVector self) -> std::vector< openshot::Coordinate >::iterator"""
        return _openshot.CoordinateVector_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(CoordinateVector self) -> std::vector< openshot::Coordinate >::reverse_iterator"""
        return _openshot.CoordinateVector_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(CoordinateVector self) -> std::vector< openshot::Coordinate >::reverse_iterator"""
        return _openshot.CoordinateVector_rend(self, *args)

    def clear(self, *args):
        r"""clear(CoordinateVector self)"""
        return _openshot.CoordinateVector_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(CoordinateVector self) -> std::vector< openshot::Coordinate >::allocator_type"""
        return _openshot.CoordinateVector_get_allocator(self, *args)

    def pop_back(self, *args):
        r"""pop_back(CoordinateVector self)"""
        return _openshot.CoordinateVector_pop_back(self, *args)

    def erase(self, *args):
        r"""
        erase(CoordinateVector self, std::vector< openshot::Coordinate >::iterator pos) -> std::vector< openshot::Coordinate >::iterator
        erase(CoordinateVector self, std::vector< openshot::Coordinate >::iterator first, std::vector< openshot::Coordinate >::iterator last) -> std::vector< openshot::Coordinate >::iterator
        """
        return _openshot.CoordinateVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(CoordinateVector self) -> CoordinateVector
        __init__(CoordinateVector self, CoordinateVector other) -> CoordinateVector
        __init__(CoordinateVector self, std::vector< openshot::Coordinate >::size_type size) -> CoordinateVector
        __init__(CoordinateVector self, std::vector< openshot::Coordinate >::size_type size, Coordinate value) -> CoordinateVector
        """
        _openshot.CoordinateVector_swiginit(self, _openshot.new_CoordinateVector(*args))

    def push_back(self, *args):
        r"""push_back(CoordinateVector self, Coordinate x)"""
        return _openshot.CoordinateVector_push_back(self, *args)

    def front(self, *args):
        r"""front(CoordinateVector self) -> Coordinate"""
        return _openshot.CoordinateVector_front(self, *args)

    def back(self, *args):
        r"""back(CoordinateVector self) -> Coordinate"""
        return _openshot.CoordinateVector_back(self, *args)

    def assign(self, *args):
        r"""assign(CoordinateVector self, std::vector< openshot::Coordinate >::size_type n, Coordinate x)"""
        return _openshot.CoordinateVector_assign(self, *args)

    def resize(self, *args):
        r"""
        resize(CoordinateVector self, std::vector< openshot::Coordinate >::size_type new_size)
        resize(CoordinateVector self, std::vector< openshot::Coordinate >::size_type new_size, Coordinate x)
        """
        return _openshot.CoordinateVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(CoordinateVector self, std::vector< openshot::Coordinate >::iterator pos, Coordinate x) -> std::vector< openshot::Coordinate >::iterator
        insert(CoordinateVector self, std::vector< openshot::Coordinate >::iterator pos, std::vector< openshot::Coordinate >::size_type n, Coordinate x)
        """
        return _openshot.CoordinateVector_insert(self, *args)

    def reserve(self, *args):
        r"""reserve(CoordinateVector self, std::vector< openshot::Coordinate >::size_type n)"""
        return _openshot.CoordinateVector_reserve(self, *args)

    def capacity(self, *args):
        r"""capacity(CoordinateVector self) -> std::vector< openshot::Coordinate >::size_type"""
        return _openshot.CoordinateVector_capacity(self, *args)
    __swig_destroy__ = _openshot.delete_CoordinateVector

# Register CoordinateVector in _openshot:
_openshot.CoordinateVector_swigregister(CoordinateVector)

class PointsVector(object):
    r"""Proxy of C++ std::vector< openshot::Point > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(PointsVector self) -> SwigPyIterator"""
        return _openshot.PointsVector_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(PointsVector self) -> bool"""
        return _openshot.PointsVector___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(PointsVector self) -> bool"""
        return _openshot.PointsVector___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(PointsVector self) -> std::vector< openshot::Point >::size_type"""
        return _openshot.PointsVector___len__(self, *args)

    def __getslice__(self, *args):
        r"""__getslice__(PointsVector self, std::vector< openshot::Point >::difference_type i, std::vector< openshot::Point >::difference_type j) -> PointsVector"""
        return _openshot.PointsVector___getslice__(self, *args)

    def __setslice__(self, *args):
        r"""
        __setslice__(PointsVector self, std::vector< openshot::Point >::difference_type i, std::vector< openshot::Point >::difference_type j)
        __setslice__(PointsVector self, std::vector< openshot::Point >::difference_type i, std::vector< openshot::Point >::difference_type j, PointsVector v)
        """
        return _openshot.PointsVector___setslice__(self, *args)

    def __delslice__(self, *args):
        r"""__delslice__(PointsVector self, std::vector< openshot::Point >::difference_type i, std::vector< openshot::Point >::difference_type j)"""
        return _openshot.PointsVector___delslice__(self, *args)

    def __delitem__(self, *args):
        r"""
        __delitem__(PointsVector self, std::vector< openshot::Point >::difference_type i)
        __delitem__(PointsVector self, PySliceObject * slice)
        """
        return _openshot.PointsVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(PointsVector self, PySliceObject * slice) -> PointsVector
        __getitem__(PointsVector self, std::vector< openshot::Point >::difference_type i) -> Point
        """
        return _openshot.PointsVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(PointsVector self, PySliceObject * slice, PointsVector v)
        __setitem__(PointsVector self, PySliceObject * slice)
        __setitem__(PointsVector self, std::vector< openshot::Point >::difference_type i, Point x)
        """
        return _openshot.PointsVector___setitem__(self, *args)

    def pop(self, *args):
        r"""pop(PointsVector self) -> Point"""
        return _openshot.PointsVector_pop(self, *args)

    def append(self, *args):
        r"""append(PointsVector self, Point x)"""
        return _openshot.PointsVector_append(self, *args)

    def empty(self, *args):
        r"""empty(PointsVector self) -> bool"""
        return _openshot.PointsVector_empty(self, *args)

    def size(self, *args):
        r"""size(PointsVector self) -> std::vector< openshot::Point >::size_type"""
        return _openshot.PointsVector_size(self, *args)

    def swap(self, *args):
        r"""swap(PointsVector self, PointsVector v)"""
        return _openshot.PointsVector_swap(self, *args)

    def begin(self, *args):
        r"""begin(PointsVector self) -> std::vector< openshot::Point >::iterator"""
        return _openshot.PointsVector_begin(self, *args)

    def end(self, *args):
        r"""end(PointsVector self) -> std::vector< openshot::Point >::iterator"""
        return _openshot.PointsVector_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(PointsVector self) -> std::vector< openshot::Point >::reverse_iterator"""
        return _openshot.PointsVector_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(PointsVector self) -> std::vector< openshot::Point >::reverse_iterator"""
        return _openshot.PointsVector_rend(self, *args)

    def clear(self, *args):
        r"""clear(PointsVector self)"""
        return _openshot.PointsVector_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(PointsVector self) -> std::vector< openshot::Point >::allocator_type"""
        return _openshot.PointsVector_get_allocator(self, *args)

    def pop_back(self, *args):
        r"""pop_back(PointsVector self)"""
        return _openshot.PointsVector_pop_back(self, *args)

    def erase(self, *args):
        r"""
        erase(PointsVector self, std::vector< openshot::Point >::iterator pos) -> std::vector< openshot::Point >::iterator
        erase(PointsVector self, std::vector< openshot::Point >::iterator first, std::vector< openshot::Point >::iterator last) -> std::vector< openshot::Point >::iterator
        """
        return _openshot.PointsVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(PointsVector self) -> PointsVector
        __init__(PointsVector self, PointsVector other) -> PointsVector
        __init__(PointsVector self, std::vector< openshot::Point >::size_type size) -> PointsVector
        __init__(PointsVector self, std::vector< openshot::Point >::size_type size, Point value) -> PointsVector
        """
        _openshot.PointsVector_swiginit(self, _openshot.new_PointsVector(*args))

    def push_back(self, *args):
        r"""push_back(PointsVector self, Point x)"""
        return _openshot.PointsVector_push_back(self, *args)

    def front(self, *args):
        r"""front(PointsVector self) -> Point"""
        return _openshot.PointsVector_front(self, *args)

    def back(self, *args):
        r"""back(PointsVector self) -> Point"""
        return _openshot.PointsVector_back(self, *args)

    def assign(self, *args):
        r"""assign(PointsVector self, std::vector< openshot::Point >::size_type n, Point x)"""
        return _openshot.PointsVector_assign(self, *args)

    def resize(self, *args):
        r"""
        resize(PointsVector self, std::vector< openshot::Point >::size_type new_size)
        resize(PointsVector self, std::vector< openshot::Point >::size_type new_size, Point x)
        """
        return _openshot.PointsVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(PointsVector self, std::vector< openshot::Point >::iterator pos, Point x) -> std::vector< openshot::Point >::iterator
        insert(PointsVector self, std::vector< openshot::Point >::iterator pos, std::vector< openshot::Point >::size_type n, Point x)
        """
        return _openshot.PointsVector_insert(self, *args)

    def reserve(self, *args):
        r"""reserve(PointsVector self, std::vector< openshot::Point >::size_type n)"""
        return _openshot.PointsVector_reserve(self, *args)

    def capacity(self, *args):
        r"""capacity(PointsVector self) -> std::vector< openshot::Point >::size_type"""
        return _openshot.PointsVector_capacity(self, *args)
    __swig_destroy__ = _openshot.delete_PointsVector

# Register PointsVector in _openshot:
_openshot.PointsVector_swigregister(PointsVector)

class FieldVector(object):
    r"""Proxy of C++ std::vector< openshot::Field > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(FieldVector self) -> SwigPyIterator"""
        return _openshot.FieldVector_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(FieldVector self) -> bool"""
        return _openshot.FieldVector___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(FieldVector self) -> bool"""
        return _openshot.FieldVector___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(FieldVector self) -> std::vector< openshot::Field >::size_type"""
        return _openshot.FieldVector___len__(self, *args)

    def __getslice__(self, *args):
        r"""__getslice__(FieldVector self, std::vector< openshot::Field >::difference_type i, std::vector< openshot::Field >::difference_type j) -> FieldVector"""
        return _openshot.FieldVector___getslice__(self, *args)

    def __setslice__(self, *args):
        r"""
        __setslice__(FieldVector self, std::vector< openshot::Field >::difference_type i, std::vector< openshot::Field >::difference_type j)
        __setslice__(FieldVector self, std::vector< openshot::Field >::difference_type i, std::vector< openshot::Field >::difference_type j, FieldVector v)
        """
        return _openshot.FieldVector___setslice__(self, *args)

    def __delslice__(self, *args):
        r"""__delslice__(FieldVector self, std::vector< openshot::Field >::difference_type i, std::vector< openshot::Field >::difference_type j)"""
        return _openshot.FieldVector___delslice__(self, *args)

    def __delitem__(self, *args):
        r"""
        __delitem__(FieldVector self, std::vector< openshot::Field >::difference_type i)
        __delitem__(FieldVector self, PySliceObject * slice)
        """
        return _openshot.FieldVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(FieldVector self, PySliceObject * slice) -> FieldVector
        __getitem__(FieldVector self, std::vector< openshot::Field >::difference_type i) -> Field
        """
        return _openshot.FieldVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(FieldVector self, PySliceObject * slice, FieldVector v)
        __setitem__(FieldVector self, PySliceObject * slice)
        __setitem__(FieldVector self, std::vector< openshot::Field >::difference_type i, Field x)
        """
        return _openshot.FieldVector___setitem__(self, *args)

    def pop(self, *args):
        r"""pop(FieldVector self) -> Field"""
        return _openshot.FieldVector_pop(self, *args)

    def append(self, *args):
        r"""append(FieldVector self, Field x)"""
        return _openshot.FieldVector_append(self, *args)

    def empty(self, *args):
        r"""empty(FieldVector self) -> bool"""
        return _openshot.FieldVector_empty(self, *args)

    def size(self, *args):
        r"""size(FieldVector self) -> std::vector< openshot::Field >::size_type"""
        return _openshot.FieldVector_size(self, *args)

    def swap(self, *args):
        r"""swap(FieldVector self, FieldVector v)"""
        return _openshot.FieldVector_swap(self, *args)

    def begin(self, *args):
        r"""begin(FieldVector self) -> std::vector< openshot::Field >::iterator"""
        return _openshot.FieldVector_begin(self, *args)

    def end(self, *args):
        r"""end(FieldVector self) -> std::vector< openshot::Field >::iterator"""
        return _openshot.FieldVector_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(FieldVector self) -> std::vector< openshot::Field >::reverse_iterator"""
        return _openshot.FieldVector_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(FieldVector self) -> std::vector< openshot::Field >::reverse_iterator"""
        return _openshot.FieldVector_rend(self, *args)

    def clear(self, *args):
        r"""clear(FieldVector self)"""
        return _openshot.FieldVector_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(FieldVector self) -> std::vector< openshot::Field >::allocator_type"""
        return _openshot.FieldVector_get_allocator(self, *args)

    def pop_back(self, *args):
        r"""pop_back(FieldVector self)"""
        return _openshot.FieldVector_pop_back(self, *args)

    def erase(self, *args):
        r"""
        erase(FieldVector self, std::vector< openshot::Field >::iterator pos) -> std::vector< openshot::Field >::iterator
        erase(FieldVector self, std::vector< openshot::Field >::iterator first, std::vector< openshot::Field >::iterator last) -> std::vector< openshot::Field >::iterator
        """
        return _openshot.FieldVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(FieldVector self) -> FieldVector
        __init__(FieldVector self, FieldVector other) -> FieldVector
        __init__(FieldVector self, std::vector< openshot::Field >::size_type size) -> FieldVector
        __init__(FieldVector self, std::vector< openshot::Field >::size_type size, Field value) -> FieldVector
        """
        _openshot.FieldVector_swiginit(self, _openshot.new_FieldVector(*args))

    def push_back(self, *args):
        r"""push_back(FieldVector self, Field x)"""
        return _openshot.FieldVector_push_back(self, *args)

    def front(self, *args):
        r"""front(FieldVector self) -> Field"""
        return _openshot.FieldVector_front(self, *args)

    def back(self, *args):
        r"""back(FieldVector self) -> Field"""
        return _openshot.FieldVector_back(self, *args)

    def assign(self, *args):
        r"""assign(FieldVector self, std::vector< openshot::Field >::size_type n, Field x)"""
        return _openshot.FieldVector_assign(self, *args)

    def resize(self, *args):
        r"""
        resize(FieldVector self, std::vector< openshot::Field >::size_type new_size)
        resize(FieldVector self, std::vector< openshot::Field >::size_type new_size, Field x)
        """
        return _openshot.FieldVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(FieldVector self, std::vector< openshot::Field >::iterator pos, Field x) -> std::vector< openshot::Field >::iterator
        insert(FieldVector self, std::vector< openshot::Field >::iterator pos, std::vector< openshot::Field >::size_type n, Field x)
        """
        return _openshot.FieldVector_insert(self, *args)

    def reserve(self, *args):
        r"""reserve(FieldVector self, std::vector< openshot::Field >::size_type n)"""
        return _openshot.FieldVector_reserve(self, *args)

    def capacity(self, *args):
        r"""capacity(FieldVector self) -> std::vector< openshot::Field >::size_type"""
        return _openshot.FieldVector_capacity(self, *args)
    __swig_destroy__ = _openshot.delete_FieldVector

# Register FieldVector in _openshot:
_openshot.FieldVector_swigregister(FieldVector)

class MappedFrameVector(object):
    r"""Proxy of C++ std::vector< openshot::MappedFrame > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(MappedFrameVector self) -> SwigPyIterator"""
        return _openshot.MappedFrameVector_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(MappedFrameVector self) -> bool"""
        return _openshot.MappedFrameVector___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(MappedFrameVector self) -> bool"""
        return _openshot.MappedFrameVector___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::size_type"""
        return _openshot.MappedFrameVector___len__(self, *args)

    def __getslice__(self, *args):
        r"""__getslice__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, std::vector< openshot::MappedFrame >::difference_type j) -> MappedFrameVector"""
        return _openshot.MappedFrameVector___getslice__(self, *args)

    def __setslice__(self, *args):
        r"""
        __setslice__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, std::vector< openshot::MappedFrame >::difference_type j)
        __setslice__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, std::vector< openshot::MappedFrame >::difference_type j, MappedFrameVector v)
        """
        return _openshot.MappedFrameVector___setslice__(self, *args)

    def __delslice__(self, *args):
        r"""__delslice__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, std::vector< openshot::MappedFrame >::difference_type j)"""
        return _openshot.MappedFrameVector___delslice__(self, *args)

    def __delitem__(self, *args):
        r"""
        __delitem__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i)
        __delitem__(MappedFrameVector self, PySliceObject * slice)
        """
        return _openshot.MappedFrameVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(MappedFrameVector self, PySliceObject * slice) -> MappedFrameVector
        __getitem__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i) -> MappedFrame
        """
        return _openshot.MappedFrameVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(MappedFrameVector self, PySliceObject * slice, MappedFrameVector v)
        __setitem__(MappedFrameVector self, PySliceObject * slice)
        __setitem__(MappedFrameVector self, std::vector< openshot::MappedFrame >::difference_type i, MappedFrame x)
        """
        return _openshot.MappedFrameVector___setitem__(self, *args)

    def pop(self, *args):
        r"""pop(MappedFrameVector self) -> MappedFrame"""
        return _openshot.MappedFrameVector_pop(self, *args)

    def append(self, *args):
        r"""append(MappedFrameVector self, MappedFrame x)"""
        return _openshot.MappedFrameVector_append(self, *args)

    def empty(self, *args):
        r"""empty(MappedFrameVector self) -> bool"""
        return _openshot.MappedFrameVector_empty(self, *args)

    def size(self, *args):
        r"""size(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::size_type"""
        return _openshot.MappedFrameVector_size(self, *args)

    def swap(self, *args):
        r"""swap(MappedFrameVector self, MappedFrameVector v)"""
        return _openshot.MappedFrameVector_swap(self, *args)

    def begin(self, *args):
        r"""begin(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::iterator"""
        return _openshot.MappedFrameVector_begin(self, *args)

    def end(self, *args):
        r"""end(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::iterator"""
        return _openshot.MappedFrameVector_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::reverse_iterator"""
        return _openshot.MappedFrameVector_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::reverse_iterator"""
        return _openshot.MappedFrameVector_rend(self, *args)

    def clear(self, *args):
        r"""clear(MappedFrameVector self)"""
        return _openshot.MappedFrameVector_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::allocator_type"""
        return _openshot.MappedFrameVector_get_allocator(self, *args)

    def pop_back(self, *args):
        r"""pop_back(MappedFrameVector self)"""
        return _openshot.MappedFrameVector_pop_back(self, *args)

    def erase(self, *args):
        r"""
        erase(MappedFrameVector self, std::vector< openshot::MappedFrame >::iterator pos) -> std::vector< openshot::MappedFrame >::iterator
        erase(MappedFrameVector self, std::vector< openshot::MappedFrame >::iterator first, std::vector< openshot::MappedFrame >::iterator last) -> std::vector< openshot::MappedFrame >::iterator
        """
        return _openshot.MappedFrameVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(MappedFrameVector self) -> MappedFrameVector
        __init__(MappedFrameVector self, MappedFrameVector other) -> MappedFrameVector
        __init__(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type size) -> MappedFrameVector
        __init__(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type size, MappedFrame value) -> MappedFrameVector
        """
        _openshot.MappedFrameVector_swiginit(self, _openshot.new_MappedFrameVector(*args))

    def push_back(self, *args):
        r"""push_back(MappedFrameVector self, MappedFrame x)"""
        return _openshot.MappedFrameVector_push_back(self, *args)

    def front(self, *args):
        r"""front(MappedFrameVector self) -> MappedFrame"""
        return _openshot.MappedFrameVector_front(self, *args)

    def back(self, *args):
        r"""back(MappedFrameVector self) -> MappedFrame"""
        return _openshot.MappedFrameVector_back(self, *args)

    def assign(self, *args):
        r"""assign(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type n, MappedFrame x)"""
        return _openshot.MappedFrameVector_assign(self, *args)

    def resize(self, *args):
        r"""
        resize(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type new_size)
        resize(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type new_size, MappedFrame x)
        """
        return _openshot.MappedFrameVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(MappedFrameVector self, std::vector< openshot::MappedFrame >::iterator pos, MappedFrame x) -> std::vector< openshot::MappedFrame >::iterator
        insert(MappedFrameVector self, std::vector< openshot::MappedFrame >::iterator pos, std::vector< openshot::MappedFrame >::size_type n, MappedFrame x)
        """
        return _openshot.MappedFrameVector_insert(self, *args)

    def reserve(self, *args):
        r"""reserve(MappedFrameVector self, std::vector< openshot::MappedFrame >::size_type n)"""
        return _openshot.MappedFrameVector_reserve(self, *args)

    def capacity(self, *args):
        r"""capacity(MappedFrameVector self) -> std::vector< openshot::MappedFrame >::size_type"""
        return _openshot.MappedFrameVector_capacity(self, *args)
    __swig_destroy__ = _openshot.delete_MappedFrameVector

# Register MappedFrameVector in _openshot:
_openshot.MappedFrameVector_swigregister(MappedFrameVector)

class MappedMetadata(object):
    r"""Proxy of C++ std::map< std::string,std::string > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(MappedMetadata self) -> SwigPyIterator"""
        return _openshot.MappedMetadata_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(MappedMetadata self) -> bool"""
        return _openshot.MappedMetadata___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(MappedMetadata self) -> bool"""
        return _openshot.MappedMetadata___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(MappedMetadata self) -> std::map< std::string,std::string >::size_type"""
        return _openshot.MappedMetadata___len__(self, *args)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, *args):
        r"""__getitem__(MappedMetadata self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &"""
        return _openshot.MappedMetadata___getitem__(self, *args)

    def __delitem__(self, *args):
        r"""__delitem__(MappedMetadata self, std::map< std::string,std::string >::key_type const & key)"""
        return _openshot.MappedMetadata___delitem__(self, *args)

    def has_key(self, *args):
        r"""has_key(MappedMetadata self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _openshot.MappedMetadata_has_key(self, *args)

    def keys(self, *args):
        r"""keys(MappedMetadata self) -> PyObject *"""
        return _openshot.MappedMetadata_keys(self, *args)

    def values(self, *args):
        r"""values(MappedMetadata self) -> PyObject *"""
        return _openshot.MappedMetadata_values(self, *args)

    def items(self, *args):
        r"""items(MappedMetadata self) -> PyObject *"""
        return _openshot.MappedMetadata_items(self, *args)

    def __contains__(self, *args):
        r"""__contains__(MappedMetadata self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _openshot.MappedMetadata___contains__(self, *args)

    def key_iterator(self, *args):
        r"""key_iterator(MappedMetadata self) -> SwigPyIterator"""
        return _openshot.MappedMetadata_key_iterator(self, *args)

    def value_iterator(self, *args):
        r"""value_iterator(MappedMetadata self) -> SwigPyIterator"""
        return _openshot.MappedMetadata_value_iterator(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(MappedMetadata self, std::map< std::string,std::string >::key_type const & key)
        __setitem__(MappedMetadata self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)
        """
        return _openshot.MappedMetadata___setitem__(self, *args)

    def asdict(self, *args):
        r"""asdict(MappedMetadata self) -> PyObject *"""
        return _openshot.MappedMetadata_asdict(self, *args)

    def __init__(self, *args):
        r"""
        __init__(MappedMetadata self, std::less< std::string > const & other) -> MappedMetadata
        __init__(MappedMetadata self) -> MappedMetadata
        __init__(MappedMetadata self, MappedMetadata other) -> MappedMetadata
        """
        _openshot.MappedMetadata_swiginit(self, _openshot.new_MappedMetadata(*args))

    def empty(self, *args):
        r"""empty(MappedMetadata self) -> bool"""
        return _openshot.MappedMetadata_empty(self, *args)

    def size(self, *args):
        r"""size(MappedMetadata self) -> std::map< std::string,std::string >::size_type"""
        return _openshot.MappedMetadata_size(self, *args)

    def swap(self, *args):
        r"""swap(MappedMetadata self, MappedMetadata v)"""
        return _openshot.MappedMetadata_swap(self, *args)

    def begin(self, *args):
        r"""begin(MappedMetadata self) -> std::map< std::string,std::string >::iterator"""
        return _openshot.MappedMetadata_begin(self, *args)

    def end(self, *args):
        r"""end(MappedMetadata self) -> std::map< std::string,std::string >::iterator"""
        return _openshot.MappedMetadata_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(MappedMetadata self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _openshot.MappedMetadata_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(MappedMetadata self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _openshot.MappedMetadata_rend(self, *args)

    def clear(self, *args):
        r"""clear(MappedMetadata self)"""
        return _openshot.MappedMetadata_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(MappedMetadata self) -> std::map< std::string,std::string >::allocator_type"""
        return _openshot.MappedMetadata_get_allocator(self, *args)

    def count(self, *args):
        r"""count(MappedMetadata self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type"""
        return _openshot.MappedMetadata_count(self, *args)

    def erase(self, *args):
        r"""
        erase(MappedMetadata self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type
        erase(MappedMetadata self, std::map< std::string,std::string >::iterator position)
        erase(MappedMetadata self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)
        """
        return _openshot.MappedMetadata_erase(self, *args)

    def find(self, *args):
        r"""find(MappedMetadata self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _openshot.MappedMetadata_find(self, *args)

    def lower_bound(self, *args):
        r"""lower_bound(MappedMetadata self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _openshot.MappedMetadata_lower_bound(self, *args)

    def upper_bound(self, *args):
        r"""upper_bound(MappedMetadata self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _openshot.MappedMetadata_upper_bound(self, *args)
    __swig_destroy__ = _openshot.delete_MappedMetadata

# Register MappedMetadata in _openshot:
_openshot.MappedMetadata_swigregister(MappedMetadata)

class AudioDeviceInfoVector(object):
    r"""Proxy of C++ std::vector< openshot::AudioDeviceInfo > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self, *args):
        r"""iterator(AudioDeviceInfoVector self) -> SwigPyIterator"""
        return _openshot.AudioDeviceInfoVector_iterator(self, *args)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self, *args):
        r"""__nonzero__(AudioDeviceInfoVector self) -> bool"""
        return _openshot.AudioDeviceInfoVector___nonzero__(self, *args)

    def __bool__(self, *args):
        r"""__bool__(AudioDeviceInfoVector self) -> bool"""
        return _openshot.AudioDeviceInfoVector___bool__(self, *args)

    def __len__(self, *args):
        r"""__len__(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::size_type"""
        return _openshot.AudioDeviceInfoVector___len__(self, *args)

    def __getslice__(self, *args):
        r"""__getslice__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i, std::vector< openshot::AudioDeviceInfo >::difference_type j) -> AudioDeviceInfoVector"""
        return _openshot.AudioDeviceInfoVector___getslice__(self, *args)

    def __setslice__(self, *args):
        r"""
        __setslice__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i, std::vector< openshot::AudioDeviceInfo >::difference_type j)
        __setslice__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i, std::vector< openshot::AudioDeviceInfo >::difference_type j, AudioDeviceInfoVector v)
        """
        return _openshot.AudioDeviceInfoVector___setslice__(self, *args)

    def __delslice__(self, *args):
        r"""__delslice__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i, std::vector< openshot::AudioDeviceInfo >::difference_type j)"""
        return _openshot.AudioDeviceInfoVector___delslice__(self, *args)

    def __delitem__(self, *args):
        r"""
        __delitem__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i)
        __delitem__(AudioDeviceInfoVector self, PySliceObject * slice)
        """
        return _openshot.AudioDeviceInfoVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(AudioDeviceInfoVector self, PySliceObject * slice) -> AudioDeviceInfoVector
        __getitem__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i) -> AudioDeviceInfo
        """
        return _openshot.AudioDeviceInfoVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(AudioDeviceInfoVector self, PySliceObject * slice, AudioDeviceInfoVector v)
        __setitem__(AudioDeviceInfoVector self, PySliceObject * slice)
        __setitem__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::difference_type i, AudioDeviceInfo x)
        """
        return _openshot.AudioDeviceInfoVector___setitem__(self, *args)

    def pop(self, *args):
        r"""pop(AudioDeviceInfoVector self) -> AudioDeviceInfo"""
        return _openshot.AudioDeviceInfoVector_pop(self, *args)

    def append(self, *args):
        r"""append(AudioDeviceInfoVector self, AudioDeviceInfo x)"""
        return _openshot.AudioDeviceInfoVector_append(self, *args)

    def empty(self, *args):
        r"""empty(AudioDeviceInfoVector self) -> bool"""
        return _openshot.AudioDeviceInfoVector_empty(self, *args)

    def size(self, *args):
        r"""size(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::size_type"""
        return _openshot.AudioDeviceInfoVector_size(self, *args)

    def swap(self, *args):
        r"""swap(AudioDeviceInfoVector self, AudioDeviceInfoVector v)"""
        return _openshot.AudioDeviceInfoVector_swap(self, *args)

    def begin(self, *args):
        r"""begin(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::iterator"""
        return _openshot.AudioDeviceInfoVector_begin(self, *args)

    def end(self, *args):
        r"""end(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::iterator"""
        return _openshot.AudioDeviceInfoVector_end(self, *args)

    def rbegin(self, *args):
        r"""rbegin(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::reverse_iterator"""
        return _openshot.AudioDeviceInfoVector_rbegin(self, *args)

    def rend(self, *args):
        r"""rend(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::reverse_iterator"""
        return _openshot.AudioDeviceInfoVector_rend(self, *args)

    def clear(self, *args):
        r"""clear(AudioDeviceInfoVector self)"""
        return _openshot.AudioDeviceInfoVector_clear(self, *args)

    def get_allocator(self, *args):
        r"""get_allocator(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::allocator_type"""
        return _openshot.AudioDeviceInfoVector_get_allocator(self, *args)

    def pop_back(self, *args):
        r"""pop_back(AudioDeviceInfoVector self)"""
        return _openshot.AudioDeviceInfoVector_pop_back(self, *args)

    def erase(self, *args):
        r"""
        erase(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::iterator pos) -> std::vector< openshot::AudioDeviceInfo >::iterator
        erase(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::iterator first, std::vector< openshot::AudioDeviceInfo >::iterator last) -> std::vector< openshot::AudioDeviceInfo >::iterator
        """
        return _openshot.AudioDeviceInfoVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(AudioDeviceInfoVector self) -> AudioDeviceInfoVector
        __init__(AudioDeviceInfoVector self, AudioDeviceInfoVector other) -> AudioDeviceInfoVector
        __init__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type size) -> AudioDeviceInfoVector
        __init__(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type size, AudioDeviceInfo value) -> AudioDeviceInfoVector
        """
        _openshot.AudioDeviceInfoVector_swiginit(self, _openshot.new_AudioDeviceInfoVector(*args))

    def push_back(self, *args):
        r"""push_back(AudioDeviceInfoVector self, AudioDeviceInfo x)"""
        return _openshot.AudioDeviceInfoVector_push_back(self, *args)

    def front(self, *args):
        r"""front(AudioDeviceInfoVector self) -> AudioDeviceInfo"""
        return _openshot.AudioDeviceInfoVector_front(self, *args)

    def back(self, *args):
        r"""back(AudioDeviceInfoVector self) -> AudioDeviceInfo"""
        return _openshot.AudioDeviceInfoVector_back(self, *args)

    def assign(self, *args):
        r"""assign(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type n, AudioDeviceInfo x)"""
        return _openshot.AudioDeviceInfoVector_assign(self, *args)

    def resize(self, *args):
        r"""
        resize(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type new_size)
        resize(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type new_size, AudioDeviceInfo x)
        """
        return _openshot.AudioDeviceInfoVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::iterator pos, AudioDeviceInfo x) -> std::vector< openshot::AudioDeviceInfo >::iterator
        insert(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::iterator pos, std::vector< openshot::AudioDeviceInfo >::size_type n, AudioDeviceInfo x)
        """
        return _openshot.AudioDeviceInfoVector_insert(self, *args)

    def reserve(self, *args):
        r"""reserve(AudioDeviceInfoVector self, std::vector< openshot::AudioDeviceInfo >::size_type n)"""
        return _openshot.AudioDeviceInfoVector_reserve(self, *args)

    def capacity(self, *args):
        r"""capacity(AudioDeviceInfoVector self) -> std::vector< openshot::AudioDeviceInfo >::size_type"""
        return _openshot.AudioDeviceInfoVector_capacity(self, *args)
    __swig_destroy__ = _openshot.delete_AudioDeviceInfoVector

# Register AudioDeviceInfoVector in _openshot:
_openshot.AudioDeviceInfoVector_swigregister(AudioDeviceInfoVector)



