# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_obspython')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_obspython')
    _obspython = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_obspython', [dirname(__file__)])
        except ImportError:
            import _obspython
            return _obspython
        try:
            _mod = imp.load_module('_obspython', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _obspython = swig_import_helper()
    del swig_import_helper
else:
    import _obspython
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0


def blog(log_level: 'int', message: 'char const *') -> "void":
    return _obspython.blog(log_level, message)
blog = _obspython.blog
GS_MAX_TEXTURES = _obspython.GS_MAX_TEXTURES
GS_POINTS = _obspython.GS_POINTS
GS_LINES = _obspython.GS_LINES
GS_LINESTRIP = _obspython.GS_LINESTRIP
GS_TRIS = _obspython.GS_TRIS
GS_TRISTRIP = _obspython.GS_TRISTRIP
GS_UNKNOWN = _obspython.GS_UNKNOWN
GS_A8 = _obspython.GS_A8
GS_R8 = _obspython.GS_R8
GS_RGBA = _obspython.GS_RGBA
GS_BGRX = _obspython.GS_BGRX
GS_BGRA = _obspython.GS_BGRA
GS_R10G10B10A2 = _obspython.GS_R10G10B10A2
GS_RGBA16 = _obspython.GS_RGBA16
GS_R16 = _obspython.GS_R16
GS_RGBA16F = _obspython.GS_RGBA16F
GS_RGBA32F = _obspython.GS_RGBA32F
GS_RG16F = _obspython.GS_RG16F
GS_RG32F = _obspython.GS_RG32F
GS_R16F = _obspython.GS_R16F
GS_R32F = _obspython.GS_R32F
GS_DXT1 = _obspython.GS_DXT1
GS_DXT3 = _obspython.GS_DXT3
GS_DXT5 = _obspython.GS_DXT5
GS_R8G8 = _obspython.GS_R8G8
GS_ZS_NONE = _obspython.GS_ZS_NONE
GS_Z16 = _obspython.GS_Z16
GS_Z24_S8 = _obspython.GS_Z24_S8
GS_Z32F = _obspython.GS_Z32F
GS_Z32F_S8X24 = _obspython.GS_Z32F_S8X24
GS_UNSIGNED_SHORT = _obspython.GS_UNSIGNED_SHORT
GS_UNSIGNED_LONG = _obspython.GS_UNSIGNED_LONG
GS_BACK = _obspython.GS_BACK
GS_FRONT = _obspython.GS_FRONT
GS_NEITHER = _obspython.GS_NEITHER
GS_BLEND_ZERO = _obspython.GS_BLEND_ZERO
GS_BLEND_ONE = _obspython.GS_BLEND_ONE
GS_BLEND_SRCCOLOR = _obspython.GS_BLEND_SRCCOLOR
GS_BLEND_INVSRCCOLOR = _obspython.GS_BLEND_INVSRCCOLOR
GS_BLEND_SRCALPHA = _obspython.GS_BLEND_SRCALPHA
GS_BLEND_INVSRCALPHA = _obspython.GS_BLEND_INVSRCALPHA
GS_BLEND_DSTCOLOR = _obspython.GS_BLEND_DSTCOLOR
GS_BLEND_INVDSTCOLOR = _obspython.GS_BLEND_INVDSTCOLOR
GS_BLEND_DSTALPHA = _obspython.GS_BLEND_DSTALPHA
GS_BLEND_INVDSTALPHA = _obspython.GS_BLEND_INVDSTALPHA
GS_BLEND_SRCALPHASAT = _obspython.GS_BLEND_SRCALPHASAT
GS_NEVER = _obspython.GS_NEVER
GS_LESS = _obspython.GS_LESS
GS_LEQUAL = _obspython.GS_LEQUAL
GS_EQUAL = _obspython.GS_EQUAL
GS_GEQUAL = _obspython.GS_GEQUAL
GS_GREATER = _obspython.GS_GREATER
GS_NOTEQUAL = _obspython.GS_NOTEQUAL
GS_ALWAYS = _obspython.GS_ALWAYS
GS_STENCIL_FRONT = _obspython.GS_STENCIL_FRONT
GS_STENCIL_BACK = _obspython.GS_STENCIL_BACK
GS_STENCIL_BOTH = _obspython.GS_STENCIL_BOTH
GS_KEEP = _obspython.GS_KEEP
GS_ZERO = _obspython.GS_ZERO
GS_REPLACE = _obspython.GS_REPLACE
GS_INCR = _obspython.GS_INCR
GS_DECR = _obspython.GS_DECR
GS_INVERT = _obspython.GS_INVERT
GS_POSITIVE_X = _obspython.GS_POSITIVE_X
GS_NEGATIVE_X = _obspython.GS_NEGATIVE_X
GS_POSITIVE_Y = _obspython.GS_POSITIVE_Y
GS_NEGATIVE_Y = _obspython.GS_NEGATIVE_Y
GS_POSITIVE_Z = _obspython.GS_POSITIVE_Z
GS_NEGATIVE_Z = _obspython.GS_NEGATIVE_Z
GS_FILTER_POINT = _obspython.GS_FILTER_POINT
GS_FILTER_LINEAR = _obspython.GS_FILTER_LINEAR
GS_FILTER_ANISOTROPIC = _obspython.GS_FILTER_ANISOTROPIC
GS_FILTER_MIN_MAG_POINT_MIP_LINEAR = _obspython.GS_FILTER_MIN_MAG_POINT_MIP_LINEAR
GS_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = _obspython.GS_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT
GS_FILTER_MIN_POINT_MAG_MIP_LINEAR = _obspython.GS_FILTER_MIN_POINT_MAG_MIP_LINEAR
GS_FILTER_MIN_LINEAR_MAG_MIP_POINT = _obspython.GS_FILTER_MIN_LINEAR_MAG_MIP_POINT
GS_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = _obspython.GS_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR
GS_FILTER_MIN_MAG_LINEAR_MIP_POINT = _obspython.GS_FILTER_MIN_MAG_LINEAR_MIP_POINT
GS_ADDRESS_CLAMP = _obspython.GS_ADDRESS_CLAMP
GS_ADDRESS_WRAP = _obspython.GS_ADDRESS_WRAP
GS_ADDRESS_MIRROR = _obspython.GS_ADDRESS_MIRROR
GS_ADDRESS_BORDER = _obspython.GS_ADDRESS_BORDER
GS_ADDRESS_MIRRORONCE = _obspython.GS_ADDRESS_MIRRORONCE
GS_TEXTURE_2D = _obspython.GS_TEXTURE_2D
GS_TEXTURE_3D = _obspython.GS_TEXTURE_3D
GS_TEXTURE_CUBE = _obspython.GS_TEXTURE_CUBE
class gs_monitor_info(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gs_monitor_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gs_monitor_info, name)
    __repr__ = _swig_repr
    __swig_setmethods__["rotation_degrees"] = _obspython.gs_monitor_info_rotation_degrees_set
    __swig_getmethods__["rotation_degrees"] = _obspython.gs_monitor_info_rotation_degrees_get
    if _newclass:
        rotation_degrees = _swig_property(_obspython.gs_monitor_info_rotation_degrees_get, _obspython.gs_monitor_info_rotation_degrees_set)
    __swig_setmethods__["x"] = _obspython.gs_monitor_info_x_set
    __swig_getmethods__["x"] = _obspython.gs_monitor_info_x_get
    if _newclass:
        x = _swig_property(_obspython.gs_monitor_info_x_get, _obspython.gs_monitor_info_x_set)
    __swig_setmethods__["y"] = _obspython.gs_monitor_info_y_set
    __swig_getmethods__["y"] = _obspython.gs_monitor_info_y_get
    if _newclass:
        y = _swig_property(_obspython.gs_monitor_info_y_get, _obspython.gs_monitor_info_y_set)
    __swig_setmethods__["cx"] = _obspython.gs_monitor_info_cx_set
    __swig_getmethods__["cx"] = _obspython.gs_monitor_info_cx_get
    if _newclass:
        cx = _swig_property(_obspython.gs_monitor_info_cx_get, _obspython.gs_monitor_info_cx_set)
    __swig_setmethods__["cy"] = _obspython.gs_monitor_info_cy_set
    __swig_getmethods__["cy"] = _obspython.gs_monitor_info_cy_get
    if _newclass:
        cy = _swig_property(_obspython.gs_monitor_info_cy_get, _obspython.gs_monitor_info_cy_set)

    def __init__(self):
        this = _obspython.new_gs_monitor_info()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_gs_monitor_info
    __del__ = lambda self: None
gs_monitor_info_swigregister = _obspython.gs_monitor_info_swigregister
gs_monitor_info_swigregister(gs_monitor_info)

class gs_tvertarray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gs_tvertarray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gs_tvertarray, name)
    __repr__ = _swig_repr
    __swig_setmethods__["width"] = _obspython.gs_tvertarray_width_set
    __swig_getmethods__["width"] = _obspython.gs_tvertarray_width_get
    if _newclass:
        width = _swig_property(_obspython.gs_tvertarray_width_get, _obspython.gs_tvertarray_width_set)
    __swig_setmethods__["array"] = _obspython.gs_tvertarray_array_set
    __swig_getmethods__["array"] = _obspython.gs_tvertarray_array_get
    if _newclass:
        array = _swig_property(_obspython.gs_tvertarray_array_get, _obspython.gs_tvertarray_array_set)

    def __init__(self):
        this = _obspython.new_gs_tvertarray()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_gs_tvertarray
    __del__ = lambda self: None
gs_tvertarray_swigregister = _obspython.gs_tvertarray_swigregister
gs_tvertarray_swigregister(gs_tvertarray)

class gs_vb_data(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gs_vb_data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gs_vb_data, name)
    __repr__ = _swig_repr
    __swig_setmethods__["num"] = _obspython.gs_vb_data_num_set
    __swig_getmethods__["num"] = _obspython.gs_vb_data_num_get
    if _newclass:
        num = _swig_property(_obspython.gs_vb_data_num_get, _obspython.gs_vb_data_num_set)
    __swig_setmethods__["points"] = _obspython.gs_vb_data_points_set
    __swig_getmethods__["points"] = _obspython.gs_vb_data_points_get
    if _newclass:
        points = _swig_property(_obspython.gs_vb_data_points_get, _obspython.gs_vb_data_points_set)
    __swig_setmethods__["normals"] = _obspython.gs_vb_data_normals_set
    __swig_getmethods__["normals"] = _obspython.gs_vb_data_normals_get
    if _newclass:
        normals = _swig_property(_obspython.gs_vb_data_normals_get, _obspython.gs_vb_data_normals_set)
    __swig_setmethods__["tangents"] = _obspython.gs_vb_data_tangents_set
    __swig_getmethods__["tangents"] = _obspython.gs_vb_data_tangents_get
    if _newclass:
        tangents = _swig_property(_obspython.gs_vb_data_tangents_get, _obspython.gs_vb_data_tangents_set)
    __swig_setmethods__["colors"] = _obspython.gs_vb_data_colors_set
    __swig_getmethods__["colors"] = _obspython.gs_vb_data_colors_get
    if _newclass:
        colors = _swig_property(_obspython.gs_vb_data_colors_get, _obspython.gs_vb_data_colors_set)
    __swig_setmethods__["num_tex"] = _obspython.gs_vb_data_num_tex_set
    __swig_getmethods__["num_tex"] = _obspython.gs_vb_data_num_tex_get
    if _newclass:
        num_tex = _swig_property(_obspython.gs_vb_data_num_tex_get, _obspython.gs_vb_data_num_tex_set)
    __swig_setmethods__["tvarray"] = _obspython.gs_vb_data_tvarray_set
    __swig_getmethods__["tvarray"] = _obspython.gs_vb_data_tvarray_get
    if _newclass:
        tvarray = _swig_property(_obspython.gs_vb_data_tvarray_get, _obspython.gs_vb_data_tvarray_set)

    def __init__(self):
        this = _obspython.new_gs_vb_data()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_gs_vb_data
    __del__ = lambda self: None
gs_vb_data_swigregister = _obspython.gs_vb_data_swigregister
gs_vb_data_swigregister(gs_vb_data)


def gs_vbdata_create() -> "struct gs_vb_data *":
    return _obspython.gs_vbdata_create()
gs_vbdata_create = _obspython.gs_vbdata_create

def gs_vbdata_destroy(data: 'gs_vb_data') -> "void":
    return _obspython.gs_vbdata_destroy(data)
gs_vbdata_destroy = _obspython.gs_vbdata_destroy
class gs_sampler_info(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gs_sampler_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gs_sampler_info, name)
    __repr__ = _swig_repr
    __swig_setmethods__["filter"] = _obspython.gs_sampler_info_filter_set
    __swig_getmethods__["filter"] = _obspython.gs_sampler_info_filter_get
    if _newclass:
        filter = _swig_property(_obspython.gs_sampler_info_filter_get, _obspython.gs_sampler_info_filter_set)
    __swig_setmethods__["address_u"] = _obspython.gs_sampler_info_address_u_set
    __swig_getmethods__["address_u"] = _obspython.gs_sampler_info_address_u_get
    if _newclass:
        address_u = _swig_property(_obspython.gs_sampler_info_address_u_get, _obspython.gs_sampler_info_address_u_set)
    __swig_setmethods__["address_v"] = _obspython.gs_sampler_info_address_v_set
    __swig_getmethods__["address_v"] = _obspython.gs_sampler_info_address_v_get
    if _newclass:
        address_v = _swig_property(_obspython.gs_sampler_info_address_v_get, _obspython.gs_sampler_info_address_v_set)
    __swig_setmethods__["address_w"] = _obspython.gs_sampler_info_address_w_set
    __swig_getmethods__["address_w"] = _obspython.gs_sampler_info_address_w_get
    if _newclass:
        address_w = _swig_property(_obspython.gs_sampler_info_address_w_get, _obspython.gs_sampler_info_address_w_set)
    __swig_setmethods__["max_anisotropy"] = _obspython.gs_sampler_info_max_anisotropy_set
    __swig_getmethods__["max_anisotropy"] = _obspython.gs_sampler_info_max_anisotropy_get
    if _newclass:
        max_anisotropy = _swig_property(_obspython.gs_sampler_info_max_anisotropy_get, _obspython.gs_sampler_info_max_anisotropy_set)
    __swig_setmethods__["border_color"] = _obspython.gs_sampler_info_border_color_set
    __swig_getmethods__["border_color"] = _obspython.gs_sampler_info_border_color_get
    if _newclass:
        border_color = _swig_property(_obspython.gs_sampler_info_border_color_get, _obspython.gs_sampler_info_border_color_set)

    def __init__(self):
        this = _obspython.new_gs_sampler_info()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_gs_sampler_info
    __del__ = lambda self: None
gs_sampler_info_swigregister = _obspython.gs_sampler_info_swigregister
gs_sampler_info_swigregister(gs_sampler_info)

class gs_display_mode(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gs_display_mode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gs_display_mode, name)
    __repr__ = _swig_repr
    __swig_setmethods__["width"] = _obspython.gs_display_mode_width_set
    __swig_getmethods__["width"] = _obspython.gs_display_mode_width_get
    if _newclass:
        width = _swig_property(_obspython.gs_display_mode_width_get, _obspython.gs_display_mode_width_set)
    __swig_setmethods__["height"] = _obspython.gs_display_mode_height_set
    __swig_getmethods__["height"] = _obspython.gs_display_mode_height_get
    if _newclass:
        height = _swig_property(_obspython.gs_display_mode_height_get, _obspython.gs_display_mode_height_set)
    __swig_setmethods__["bits"] = _obspython.gs_display_mode_bits_set
    __swig_getmethods__["bits"] = _obspython.gs_display_mode_bits_get
    if _newclass:
        bits = _swig_property(_obspython.gs_display_mode_bits_get, _obspython.gs_display_mode_bits_set)
    __swig_setmethods__["freq"] = _obspython.gs_display_mode_freq_set
    __swig_getmethods__["freq"] = _obspython.gs_display_mode_freq_get
    if _newclass:
        freq = _swig_property(_obspython.gs_display_mode_freq_get, _obspython.gs_display_mode_freq_set)

    def __init__(self):
        this = _obspython.new_gs_display_mode()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_gs_display_mode
    __del__ = lambda self: None
gs_display_mode_swigregister = _obspython.gs_display_mode_swigregister
gs_display_mode_swigregister(gs_display_mode)

class gs_rect(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gs_rect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gs_rect, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _obspython.gs_rect_x_set
    __swig_getmethods__["x"] = _obspython.gs_rect_x_get
    if _newclass:
        x = _swig_property(_obspython.gs_rect_x_get, _obspython.gs_rect_x_set)
    __swig_setmethods__["y"] = _obspython.gs_rect_y_set
    __swig_getmethods__["y"] = _obspython.gs_rect_y_get
    if _newclass:
        y = _swig_property(_obspython.gs_rect_y_get, _obspython.gs_rect_y_set)
    __swig_setmethods__["cx"] = _obspython.gs_rect_cx_set
    __swig_getmethods__["cx"] = _obspython.gs_rect_cx_get
    if _newclass:
        cx = _swig_property(_obspython.gs_rect_cx_get, _obspython.gs_rect_cx_set)
    __swig_setmethods__["cy"] = _obspython.gs_rect_cy_set
    __swig_getmethods__["cy"] = _obspython.gs_rect_cy_get
    if _newclass:
        cy = _swig_property(_obspython.gs_rect_cy_get, _obspython.gs_rect_cy_set)

    def __init__(self):
        this = _obspython.new_gs_rect()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_gs_rect
    __del__ = lambda self: None
gs_rect_swigregister = _obspython.gs_rect_swigregister
gs_rect_swigregister(gs_rect)

GS_SHADER_PARAM_UNKNOWN = _obspython.GS_SHADER_PARAM_UNKNOWN
GS_SHADER_PARAM_BOOL = _obspython.GS_SHADER_PARAM_BOOL
GS_SHADER_PARAM_FLOAT = _obspython.GS_SHADER_PARAM_FLOAT
GS_SHADER_PARAM_INT = _obspython.GS_SHADER_PARAM_INT
GS_SHADER_PARAM_STRING = _obspython.GS_SHADER_PARAM_STRING
GS_SHADER_PARAM_VEC2 = _obspython.GS_SHADER_PARAM_VEC2
GS_SHADER_PARAM_VEC3 = _obspython.GS_SHADER_PARAM_VEC3
GS_SHADER_PARAM_VEC4 = _obspython.GS_SHADER_PARAM_VEC4
GS_SHADER_PARAM_INT2 = _obspython.GS_SHADER_PARAM_INT2
GS_SHADER_PARAM_INT3 = _obspython.GS_SHADER_PARAM_INT3
GS_SHADER_PARAM_INT4 = _obspython.GS_SHADER_PARAM_INT4
GS_SHADER_PARAM_MATRIX4X4 = _obspython.GS_SHADER_PARAM_MATRIX4X4
GS_SHADER_PARAM_TEXTURE = _obspython.GS_SHADER_PARAM_TEXTURE

def gs_effect_destroy(effect: 'gs_effect_t *') -> "void":
    return _obspython.gs_effect_destroy(effect)
gs_effect_destroy = _obspython.gs_effect_destroy

def gs_effect_get_technique(effect: 'gs_effect_t const *', name: 'char const *') -> "gs_technique_t *":
    return _obspython.gs_effect_get_technique(effect, name)
gs_effect_get_technique = _obspython.gs_effect_get_technique

def gs_effect_get_current_technique(effect: 'gs_effect_t const *') -> "gs_technique_t *":
    return _obspython.gs_effect_get_current_technique(effect)
gs_effect_get_current_technique = _obspython.gs_effect_get_current_technique

def gs_technique_begin(technique: 'gs_technique_t *') -> "size_t":
    return _obspython.gs_technique_begin(technique)
gs_technique_begin = _obspython.gs_technique_begin

def gs_technique_end(technique: 'gs_technique_t *') -> "void":
    return _obspython.gs_technique_end(technique)
gs_technique_end = _obspython.gs_technique_end

def gs_technique_begin_pass(technique: 'gs_technique_t *', arg2: 'size_t') -> "bool":
    return _obspython.gs_technique_begin_pass(technique, arg2)
gs_technique_begin_pass = _obspython.gs_technique_begin_pass

def gs_technique_begin_pass_by_name(technique: 'gs_technique_t *', name: 'char const *') -> "bool":
    return _obspython.gs_technique_begin_pass_by_name(technique, name)
gs_technique_begin_pass_by_name = _obspython.gs_technique_begin_pass_by_name

def gs_technique_end_pass(technique: 'gs_technique_t *') -> "void":
    return _obspython.gs_technique_end_pass(technique)
gs_technique_end_pass = _obspython.gs_technique_end_pass

def gs_technique_get_pass_by_idx(technique: 'gs_technique_t const *', arg2: 'size_t') -> "gs_epass_t *":
    return _obspython.gs_technique_get_pass_by_idx(technique, arg2)
gs_technique_get_pass_by_idx = _obspython.gs_technique_get_pass_by_idx

def gs_technique_get_pass_by_name(technique: 'gs_technique_t const *', name: 'char const *') -> "gs_epass_t *":
    return _obspython.gs_technique_get_pass_by_name(technique, name)
gs_technique_get_pass_by_name = _obspython.gs_technique_get_pass_by_name

def gs_effect_get_num_params(effect: 'gs_effect_t const *') -> "size_t":
    return _obspython.gs_effect_get_num_params(effect)
gs_effect_get_num_params = _obspython.gs_effect_get_num_params

def gs_effect_get_param_by_idx(effect: 'gs_effect_t const *', param: 'size_t') -> "gs_eparam_t *":
    return _obspython.gs_effect_get_param_by_idx(effect, param)
gs_effect_get_param_by_idx = _obspython.gs_effect_get_param_by_idx

def gs_effect_get_param_by_name(effect: 'gs_effect_t const *', name: 'char const *') -> "gs_eparam_t *":
    return _obspython.gs_effect_get_param_by_name(effect, name)
gs_effect_get_param_by_name = _obspython.gs_effect_get_param_by_name

def gs_param_get_num_annotations(param: 'gs_eparam_t const *') -> "size_t":
    return _obspython.gs_param_get_num_annotations(param)
gs_param_get_num_annotations = _obspython.gs_param_get_num_annotations

def gs_param_get_annotation_by_idx(param: 'gs_eparam_t const *', annotation: 'size_t') -> "gs_eparam_t *":
    return _obspython.gs_param_get_annotation_by_idx(param, annotation)
gs_param_get_annotation_by_idx = _obspython.gs_param_get_annotation_by_idx

def gs_param_get_annotation_by_name(param: 'gs_eparam_t const *', name: 'char const *') -> "gs_eparam_t *":
    return _obspython.gs_param_get_annotation_by_name(param, name)
gs_param_get_annotation_by_name = _obspython.gs_param_get_annotation_by_name

def gs_effect_loop(effect: 'gs_effect_t *', name: 'char const *') -> "bool":
    return _obspython.gs_effect_loop(effect, name)
gs_effect_loop = _obspython.gs_effect_loop

def gs_effect_update_params(effect: 'gs_effect_t *') -> "void":
    return _obspython.gs_effect_update_params(effect)
gs_effect_update_params = _obspython.gs_effect_update_params

def gs_effect_get_viewproj_matrix(effect: 'gs_effect_t const *') -> "gs_eparam_t *":
    return _obspython.gs_effect_get_viewproj_matrix(effect)
gs_effect_get_viewproj_matrix = _obspython.gs_effect_get_viewproj_matrix

def gs_effect_get_world_matrix(effect: 'gs_effect_t const *') -> "gs_eparam_t *":
    return _obspython.gs_effect_get_world_matrix(effect)
gs_effect_get_world_matrix = _obspython.gs_effect_get_world_matrix

def gs_effect_set_bool(param: 'gs_eparam_t *', val: 'bool') -> "void":
    return _obspython.gs_effect_set_bool(param, val)
gs_effect_set_bool = _obspython.gs_effect_set_bool

def gs_effect_set_float(param: 'gs_eparam_t *', val: 'float') -> "void":
    return _obspython.gs_effect_set_float(param, val)
gs_effect_set_float = _obspython.gs_effect_set_float

def gs_effect_set_int(param: 'gs_eparam_t *', val: 'int') -> "void":
    return _obspython.gs_effect_set_int(param, val)
gs_effect_set_int = _obspython.gs_effect_set_int

def gs_effect_set_matrix4(param: 'gs_eparam_t *', val: 'struct matrix4 const *') -> "void":
    return _obspython.gs_effect_set_matrix4(param, val)
gs_effect_set_matrix4 = _obspython.gs_effect_set_matrix4

def gs_effect_set_vec2(param: 'gs_eparam_t *', val: 'vec2') -> "void":
    return _obspython.gs_effect_set_vec2(param, val)
gs_effect_set_vec2 = _obspython.gs_effect_set_vec2

def gs_effect_set_vec3(param: 'gs_eparam_t *', val: 'vec3') -> "void":
    return _obspython.gs_effect_set_vec3(param, val)
gs_effect_set_vec3 = _obspython.gs_effect_set_vec3

def gs_effect_set_vec4(param: 'gs_eparam_t *', val: 'vec4') -> "void":
    return _obspython.gs_effect_set_vec4(param, val)
gs_effect_set_vec4 = _obspython.gs_effect_set_vec4

def gs_effect_set_texture(param: 'gs_eparam_t *', val: 'gs_texture_t *') -> "void":
    return _obspython.gs_effect_set_texture(param, val)
gs_effect_set_texture = _obspython.gs_effect_set_texture

def gs_effect_set_val(param: 'gs_eparam_t *', val: 'void const *', size: 'size_t') -> "void":
    return _obspython.gs_effect_set_val(param, val, size)
gs_effect_set_val = _obspython.gs_effect_set_val

def gs_effect_set_default(param: 'gs_eparam_t *') -> "void":
    return _obspython.gs_effect_set_default(param)
gs_effect_set_default = _obspython.gs_effect_set_default

def gs_effect_get_val_size(param: 'gs_eparam_t *') -> "size_t":
    return _obspython.gs_effect_get_val_size(param)
gs_effect_get_val_size = _obspython.gs_effect_get_val_size

def gs_effect_get_val(param: 'gs_eparam_t *') -> "void *":
    return _obspython.gs_effect_get_val(param)
gs_effect_get_val = _obspython.gs_effect_get_val

def gs_effect_get_default_val_size(param: 'gs_eparam_t *') -> "size_t":
    return _obspython.gs_effect_get_default_val_size(param)
gs_effect_get_default_val_size = _obspython.gs_effect_get_default_val_size

def gs_effect_get_default_val(param: 'gs_eparam_t *') -> "void *":
    return _obspython.gs_effect_get_default_val(param)
gs_effect_get_default_val = _obspython.gs_effect_get_default_val

def gs_effect_set_next_sampler(param: 'gs_eparam_t *', sampler: 'gs_samplerstate_t *') -> "void":
    return _obspython.gs_effect_set_next_sampler(param, sampler)
gs_effect_set_next_sampler = _obspython.gs_effect_set_next_sampler

def gs_effect_set_color(param: 'gs_eparam_t *', argb: 'uint32_t') -> "void":
    return _obspython.gs_effect_set_color(param, argb)
gs_effect_set_color = _obspython.gs_effect_set_color

def gs_texrender_create(format: 'enum gs_color_format', zsformat: 'enum gs_zstencil_format') -> "gs_texrender_t *":
    return _obspython.gs_texrender_create(format, zsformat)
gs_texrender_create = _obspython.gs_texrender_create

def gs_texrender_destroy(texrender: 'gs_texrender_t *') -> "void":
    return _obspython.gs_texrender_destroy(texrender)
gs_texrender_destroy = _obspython.gs_texrender_destroy

def gs_texrender_begin(texrender: 'gs_texrender_t *', cx: 'uint32_t', cy: 'uint32_t') -> "bool":
    return _obspython.gs_texrender_begin(texrender, cx, cy)
gs_texrender_begin = _obspython.gs_texrender_begin

def gs_texrender_end(texrender: 'gs_texrender_t *') -> "void":
    return _obspython.gs_texrender_end(texrender)
gs_texrender_end = _obspython.gs_texrender_end

def gs_texrender_reset(texrender: 'gs_texrender_t *') -> "void":
    return _obspython.gs_texrender_reset(texrender)
gs_texrender_reset = _obspython.gs_texrender_reset

def gs_texrender_get_texture(texrender: 'gs_texrender_t const *') -> "gs_texture_t *":
    return _obspython.gs_texrender_get_texture(texrender)
gs_texrender_get_texture = _obspython.gs_texrender_get_texture
GS_BUILD_MIPMAPS = _obspython.GS_BUILD_MIPMAPS
GS_DYNAMIC = _obspython.GS_DYNAMIC
GS_RENDER_TARGET = _obspython.GS_RENDER_TARGET
GS_GL_DUMMYTEX = _obspython.GS_GL_DUMMYTEX
GS_DUP_BUFFER = _obspython.GS_DUP_BUFFER
GS_SHARED_TEX = _obspython.GS_SHARED_TEX
GS_SHARED_KM_TEX = _obspython.GS_SHARED_KM_TEX
GS_SUCCESS = _obspython.GS_SUCCESS
GS_ERROR_FAIL = _obspython.GS_ERROR_FAIL
GS_ERROR_MODULE_NOT_FOUND = _obspython.GS_ERROR_MODULE_NOT_FOUND
GS_ERROR_NOT_SUPPORTED = _obspython.GS_ERROR_NOT_SUPPORTED
class gs_window(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gs_window, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gs_window, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _obspython.new_gs_window()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_gs_window
    __del__ = lambda self: None
gs_window_swigregister = _obspython.gs_window_swigregister
gs_window_swigregister(gs_window)

class gs_init_data(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gs_init_data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gs_init_data, name)
    __repr__ = _swig_repr
    __swig_setmethods__["window"] = _obspython.gs_init_data_window_set
    __swig_getmethods__["window"] = _obspython.gs_init_data_window_get
    if _newclass:
        window = _swig_property(_obspython.gs_init_data_window_get, _obspython.gs_init_data_window_set)
    __swig_setmethods__["cx"] = _obspython.gs_init_data_cx_set
    __swig_getmethods__["cx"] = _obspython.gs_init_data_cx_get
    if _newclass:
        cx = _swig_property(_obspython.gs_init_data_cx_get, _obspython.gs_init_data_cx_set)
    __swig_setmethods__["cy"] = _obspython.gs_init_data_cy_set
    __swig_getmethods__["cy"] = _obspython.gs_init_data_cy_get
    if _newclass:
        cy = _swig_property(_obspython.gs_init_data_cy_get, _obspython.gs_init_data_cy_set)
    __swig_setmethods__["num_backbuffers"] = _obspython.gs_init_data_num_backbuffers_set
    __swig_getmethods__["num_backbuffers"] = _obspython.gs_init_data_num_backbuffers_get
    if _newclass:
        num_backbuffers = _swig_property(_obspython.gs_init_data_num_backbuffers_get, _obspython.gs_init_data_num_backbuffers_set)
    __swig_setmethods__["format"] = _obspython.gs_init_data_format_set
    __swig_getmethods__["format"] = _obspython.gs_init_data_format_get
    if _newclass:
        format = _swig_property(_obspython.gs_init_data_format_get, _obspython.gs_init_data_format_set)
    __swig_setmethods__["zsformat"] = _obspython.gs_init_data_zsformat_set
    __swig_getmethods__["zsformat"] = _obspython.gs_init_data_zsformat_get
    if _newclass:
        zsformat = _swig_property(_obspython.gs_init_data_zsformat_get, _obspython.gs_init_data_zsformat_set)
    __swig_setmethods__["adapter"] = _obspython.gs_init_data_adapter_set
    __swig_getmethods__["adapter"] = _obspython.gs_init_data_adapter_get
    if _newclass:
        adapter = _swig_property(_obspython.gs_init_data_adapter_get, _obspython.gs_init_data_adapter_set)

    def __init__(self):
        this = _obspython.new_gs_init_data()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_gs_init_data
    __del__ = lambda self: None
gs_init_data_swigregister = _obspython.gs_init_data_swigregister
gs_init_data_swigregister(gs_init_data)

GS_DEVICE_OPENGL = _obspython.GS_DEVICE_OPENGL
GS_DEVICE_DIRECT3D_11 = _obspython.GS_DEVICE_DIRECT3D_11

def gs_get_device_name() -> "char const *":
    return _obspython.gs_get_device_name()
gs_get_device_name = _obspython.gs_get_device_name

def gs_get_device_type() -> "int":
    return _obspython.gs_get_device_type()
gs_get_device_type = _obspython.gs_get_device_type

def gs_enum_adapters(callback: 'bool (*)(void *,char const *,uint32_t)', param: 'void *') -> "void":
    return _obspython.gs_enum_adapters(callback, param)
gs_enum_adapters = _obspython.gs_enum_adapters

def gs_create(graphics: 'graphics_t **', module: 'char const *', adapter: 'uint32_t') -> "int":
    return _obspython.gs_create(graphics, module, adapter)
gs_create = _obspython.gs_create

def gs_destroy(graphics: 'graphics_t *') -> "void":
    return _obspython.gs_destroy(graphics)
gs_destroy = _obspython.gs_destroy

def gs_enter_context(graphics: 'graphics_t *') -> "void":
    return _obspython.gs_enter_context(graphics)
gs_enter_context = _obspython.gs_enter_context

def gs_leave_context() -> "void":
    return _obspython.gs_leave_context()
gs_leave_context = _obspython.gs_leave_context

def gs_get_context() -> "graphics_t *":
    return _obspython.gs_get_context()
gs_get_context = _obspython.gs_get_context

def gs_matrix_push() -> "void":
    return _obspython.gs_matrix_push()
gs_matrix_push = _obspython.gs_matrix_push

def gs_matrix_pop() -> "void":
    return _obspython.gs_matrix_pop()
gs_matrix_pop = _obspython.gs_matrix_pop

def gs_matrix_identity() -> "void":
    return _obspython.gs_matrix_identity()
gs_matrix_identity = _obspython.gs_matrix_identity

def gs_matrix_transpose() -> "void":
    return _obspython.gs_matrix_transpose()
gs_matrix_transpose = _obspython.gs_matrix_transpose

def gs_matrix_set(matrix: 'struct matrix4 const *') -> "void":
    return _obspython.gs_matrix_set(matrix)
gs_matrix_set = _obspython.gs_matrix_set

def gs_matrix_get(dst: 'struct matrix4 *') -> "void":
    return _obspython.gs_matrix_get(dst)
gs_matrix_get = _obspython.gs_matrix_get

def gs_matrix_mul(matrix: 'struct matrix4 const *') -> "void":
    return _obspython.gs_matrix_mul(matrix)
gs_matrix_mul = _obspython.gs_matrix_mul

def gs_matrix_rotquat(rot: 'quat') -> "void":
    return _obspython.gs_matrix_rotquat(rot)
gs_matrix_rotquat = _obspython.gs_matrix_rotquat

def gs_matrix_rotaa(rot: 'struct axisang const *') -> "void":
    return _obspython.gs_matrix_rotaa(rot)
gs_matrix_rotaa = _obspython.gs_matrix_rotaa

def gs_matrix_translate(pos: 'vec3') -> "void":
    return _obspython.gs_matrix_translate(pos)
gs_matrix_translate = _obspython.gs_matrix_translate

def gs_matrix_scale(scale: 'vec3') -> "void":
    return _obspython.gs_matrix_scale(scale)
gs_matrix_scale = _obspython.gs_matrix_scale

def gs_matrix_rotaa4f(x: 'float', y: 'float', z: 'float', angle: 'float') -> "void":
    return _obspython.gs_matrix_rotaa4f(x, y, z, angle)
gs_matrix_rotaa4f = _obspython.gs_matrix_rotaa4f

def gs_matrix_translate3f(x: 'float', y: 'float', z: 'float') -> "void":
    return _obspython.gs_matrix_translate3f(x, y, z)
gs_matrix_translate3f = _obspython.gs_matrix_translate3f

def gs_matrix_scale3f(x: 'float', y: 'float', z: 'float') -> "void":
    return _obspython.gs_matrix_scale3f(x, y, z)
gs_matrix_scale3f = _obspython.gs_matrix_scale3f

def gs_render_start(b_new: 'bool') -> "void":
    return _obspython.gs_render_start(b_new)
gs_render_start = _obspython.gs_render_start

def gs_render_stop(mode: 'enum gs_draw_mode') -> "void":
    return _obspython.gs_render_stop(mode)
gs_render_stop = _obspython.gs_render_stop

def gs_render_save() -> "gs_vertbuffer_t *":
    return _obspython.gs_render_save()
gs_render_save = _obspython.gs_render_save

def gs_vertex2f(x: 'float', y: 'float') -> "void":
    return _obspython.gs_vertex2f(x, y)
gs_vertex2f = _obspython.gs_vertex2f

def gs_vertex3f(x: 'float', y: 'float', z: 'float') -> "void":
    return _obspython.gs_vertex3f(x, y, z)
gs_vertex3f = _obspython.gs_vertex3f

def gs_normal3f(x: 'float', y: 'float', z: 'float') -> "void":
    return _obspython.gs_normal3f(x, y, z)
gs_normal3f = _obspython.gs_normal3f

def gs_color(color: 'uint32_t') -> "void":
    return _obspython.gs_color(color)
gs_color = _obspython.gs_color

def gs_texcoord(x: 'float', y: 'float', unit: 'int') -> "void":
    return _obspython.gs_texcoord(x, y, unit)
gs_texcoord = _obspython.gs_texcoord

def gs_vertex2v(v: 'vec2') -> "void":
    return _obspython.gs_vertex2v(v)
gs_vertex2v = _obspython.gs_vertex2v

def gs_vertex3v(v: 'vec3') -> "void":
    return _obspython.gs_vertex3v(v)
gs_vertex3v = _obspython.gs_vertex3v

def gs_normal3v(v: 'vec3') -> "void":
    return _obspython.gs_normal3v(v)
gs_normal3v = _obspython.gs_normal3v

def gs_color4v(v: 'vec4') -> "void":
    return _obspython.gs_color4v(v)
gs_color4v = _obspython.gs_color4v

def gs_texcoord2v(v: 'vec2', unit: 'int') -> "void":
    return _obspython.gs_texcoord2v(v, unit)
gs_texcoord2v = _obspython.gs_texcoord2v

def gs_get_input() -> "input_t *":
    return _obspython.gs_get_input()
gs_get_input = _obspython.gs_get_input

def gs_get_effect() -> "gs_effect_t *":
    return _obspython.gs_get_effect()
gs_get_effect = _obspython.gs_get_effect

def gs_effect_create_from_file(file: 'char const *', error_string: 'char **') -> "gs_effect_t *":
    return _obspython.gs_effect_create_from_file(file, error_string)
gs_effect_create_from_file = _obspython.gs_effect_create_from_file

def gs_effect_create(effect_string: 'char const *', filename: 'char const *', error_string: 'char **') -> "gs_effect_t *":
    return _obspython.gs_effect_create(effect_string, filename, error_string)
gs_effect_create = _obspython.gs_effect_create

def gs_vertexshader_create_from_file(file: 'char const *', error_string: 'char **') -> "gs_shader_t *":
    return _obspython.gs_vertexshader_create_from_file(file, error_string)
gs_vertexshader_create_from_file = _obspython.gs_vertexshader_create_from_file

def gs_pixelshader_create_from_file(file: 'char const *', error_string: 'char **') -> "gs_shader_t *":
    return _obspython.gs_pixelshader_create_from_file(file, error_string)
gs_pixelshader_create_from_file = _obspython.gs_pixelshader_create_from_file

def gs_texture_create_from_file(file: 'char const *') -> "gs_texture_t *":
    return _obspython.gs_texture_create_from_file(file)
gs_texture_create_from_file = _obspython.gs_texture_create_from_file

def gs_create_texture_file_data(file: 'char const *', format: 'enum gs_color_format *', cx: 'uint32_t *', cy: 'uint32_t *') -> "uint8_t *":
    return _obspython.gs_create_texture_file_data(file, format, cx, cy)
gs_create_texture_file_data = _obspython.gs_create_texture_file_data
GS_FLIP_U = _obspython.GS_FLIP_U
GS_FLIP_V = _obspython.GS_FLIP_V

def gs_draw_sprite(tex: 'gs_texture_t *', flip: 'uint32_t', width: 'uint32_t', height: 'uint32_t') -> "void":
    return _obspython.gs_draw_sprite(tex, flip, width, height)
gs_draw_sprite = _obspython.gs_draw_sprite

def gs_draw_sprite_subregion(tex: 'gs_texture_t *', flip: 'uint32_t', x: 'uint32_t', y: 'uint32_t', cx: 'uint32_t', cy: 'uint32_t') -> "void":
    return _obspython.gs_draw_sprite_subregion(tex, flip, x, y, cx, cy)
gs_draw_sprite_subregion = _obspython.gs_draw_sprite_subregion

def gs_draw_cube_backdrop(cubetex: 'gs_texture_t *', rot: 'quat', left: 'float', right: 'float', top: 'float', bottom: 'float', znear: 'float') -> "void":
    return _obspython.gs_draw_cube_backdrop(cubetex, rot, left, right, top, bottom, znear)
gs_draw_cube_backdrop = _obspython.gs_draw_cube_backdrop

def gs_reset_viewport() -> "void":
    return _obspython.gs_reset_viewport()
gs_reset_viewport = _obspython.gs_reset_viewport

def gs_set_2d_mode() -> "void":
    return _obspython.gs_set_2d_mode()
gs_set_2d_mode = _obspython.gs_set_2d_mode

def gs_set_3d_mode(fovy: 'double', znear: 'double', zvar: 'double') -> "void":
    return _obspython.gs_set_3d_mode(fovy, znear, zvar)
gs_set_3d_mode = _obspython.gs_set_3d_mode

def gs_viewport_push() -> "void":
    return _obspython.gs_viewport_push()
gs_viewport_push = _obspython.gs_viewport_push

def gs_viewport_pop() -> "void":
    return _obspython.gs_viewport_pop()
gs_viewport_pop = _obspython.gs_viewport_pop

def gs_texture_set_image(tex: 'gs_texture_t *', data: 'uint8_t const *', linesize: 'uint32_t', invert: 'bool') -> "void":
    return _obspython.gs_texture_set_image(tex, data, linesize, invert)
gs_texture_set_image = _obspython.gs_texture_set_image

def gs_cubetexture_set_image(cubetex: 'gs_texture_t *', side: 'uint32_t', data: 'void const *', linesize: 'uint32_t', invert: 'bool') -> "void":
    return _obspython.gs_cubetexture_set_image(cubetex, side, data, linesize, invert)
gs_cubetexture_set_image = _obspython.gs_cubetexture_set_image

def gs_perspective(fovy: 'float', aspect: 'float', znear: 'float', zfar: 'float') -> "void":
    return _obspython.gs_perspective(fovy, aspect, znear, zfar)
gs_perspective = _obspython.gs_perspective

def gs_blend_state_push() -> "void":
    return _obspython.gs_blend_state_push()
gs_blend_state_push = _obspython.gs_blend_state_push

def gs_blend_state_pop() -> "void":
    return _obspython.gs_blend_state_pop()
gs_blend_state_pop = _obspython.gs_blend_state_pop

def gs_reset_blend_state() -> "void":
    return _obspython.gs_reset_blend_state()
gs_reset_blend_state = _obspython.gs_reset_blend_state

def gs_swapchain_create(data: 'gs_init_data') -> "gs_swapchain_t *":
    return _obspython.gs_swapchain_create(data)
gs_swapchain_create = _obspython.gs_swapchain_create

def gs_resize(x: 'uint32_t', y: 'uint32_t') -> "void":
    return _obspython.gs_resize(x, y)
gs_resize = _obspython.gs_resize

def gs_get_size(x: 'uint32_t *', y: 'uint32_t *') -> "void":
    return _obspython.gs_get_size(x, y)
gs_get_size = _obspython.gs_get_size

def gs_get_width() -> "uint32_t":
    return _obspython.gs_get_width()
gs_get_width = _obspython.gs_get_width

def gs_get_height() -> "uint32_t":
    return _obspython.gs_get_height()
gs_get_height = _obspython.gs_get_height

def gs_texture_create(width: 'uint32_t', height: 'uint32_t', color_format: 'enum gs_color_format', levels: 'uint32_t', data: 'uint8_t const **', flags: 'uint32_t') -> "gs_texture_t *":
    return _obspython.gs_texture_create(width, height, color_format, levels, data, flags)
gs_texture_create = _obspython.gs_texture_create

def gs_cubetexture_create(size: 'uint32_t', color_format: 'enum gs_color_format', levels: 'uint32_t', data: 'uint8_t const **', flags: 'uint32_t') -> "gs_texture_t *":
    return _obspython.gs_cubetexture_create(size, color_format, levels, data, flags)
gs_cubetexture_create = _obspython.gs_cubetexture_create

def gs_voltexture_create(width: 'uint32_t', height: 'uint32_t', depth: 'uint32_t', color_format: 'enum gs_color_format', levels: 'uint32_t', data: 'uint8_t const **', flags: 'uint32_t') -> "gs_texture_t *":
    return _obspython.gs_voltexture_create(width, height, depth, color_format, levels, data, flags)
gs_voltexture_create = _obspython.gs_voltexture_create

def gs_zstencil_create(width: 'uint32_t', height: 'uint32_t', format: 'enum gs_zstencil_format') -> "gs_zstencil_t *":
    return _obspython.gs_zstencil_create(width, height, format)
gs_zstencil_create = _obspython.gs_zstencil_create

def gs_stagesurface_create(width: 'uint32_t', height: 'uint32_t', color_format: 'enum gs_color_format') -> "gs_stagesurf_t *":
    return _obspython.gs_stagesurface_create(width, height, color_format)
gs_stagesurface_create = _obspython.gs_stagesurface_create

def gs_samplerstate_create(info: 'gs_sampler_info') -> "gs_samplerstate_t *":
    return _obspython.gs_samplerstate_create(info)
gs_samplerstate_create = _obspython.gs_samplerstate_create

def gs_vertexshader_create(shader: 'char const *', file: 'char const *', error_string: 'char **') -> "gs_shader_t *":
    return _obspython.gs_vertexshader_create(shader, file, error_string)
gs_vertexshader_create = _obspython.gs_vertexshader_create

def gs_pixelshader_create(shader: 'char const *', file: 'char const *', error_string: 'char **') -> "gs_shader_t *":
    return _obspython.gs_pixelshader_create(shader, file, error_string)
gs_pixelshader_create = _obspython.gs_pixelshader_create

def gs_vertexbuffer_create(data: 'gs_vb_data', flags: 'uint32_t') -> "gs_vertbuffer_t *":
    return _obspython.gs_vertexbuffer_create(data, flags)
gs_vertexbuffer_create = _obspython.gs_vertexbuffer_create

def gs_indexbuffer_create(type: 'enum gs_index_type', indices: 'void *', num: 'size_t', flags: 'uint32_t') -> "gs_indexbuffer_t *":
    return _obspython.gs_indexbuffer_create(type, indices, num, flags)
gs_indexbuffer_create = _obspython.gs_indexbuffer_create

def gs_get_texture_type(texture: 'gs_texture_t const *') -> "enum gs_texture_type":
    return _obspython.gs_get_texture_type(texture)
gs_get_texture_type = _obspython.gs_get_texture_type

def gs_load_vertexbuffer(vertbuffer: 'gs_vertbuffer_t *') -> "void":
    return _obspython.gs_load_vertexbuffer(vertbuffer)
gs_load_vertexbuffer = _obspython.gs_load_vertexbuffer

def gs_load_indexbuffer(indexbuffer: 'gs_indexbuffer_t *') -> "void":
    return _obspython.gs_load_indexbuffer(indexbuffer)
gs_load_indexbuffer = _obspython.gs_load_indexbuffer

def gs_load_texture(tex: 'gs_texture_t *', unit: 'int') -> "void":
    return _obspython.gs_load_texture(tex, unit)
gs_load_texture = _obspython.gs_load_texture

def gs_load_samplerstate(samplerstate: 'gs_samplerstate_t *', unit: 'int') -> "void":
    return _obspython.gs_load_samplerstate(samplerstate, unit)
gs_load_samplerstate = _obspython.gs_load_samplerstate

def gs_load_vertexshader(vertshader: 'gs_shader_t *') -> "void":
    return _obspython.gs_load_vertexshader(vertshader)
gs_load_vertexshader = _obspython.gs_load_vertexshader

def gs_load_pixelshader(pixelshader: 'gs_shader_t *') -> "void":
    return _obspython.gs_load_pixelshader(pixelshader)
gs_load_pixelshader = _obspython.gs_load_pixelshader

def gs_load_default_samplerstate(b_3d: 'bool', unit: 'int') -> "void":
    return _obspython.gs_load_default_samplerstate(b_3d, unit)
gs_load_default_samplerstate = _obspython.gs_load_default_samplerstate

def gs_get_vertex_shader() -> "gs_shader_t *":
    return _obspython.gs_get_vertex_shader()
gs_get_vertex_shader = _obspython.gs_get_vertex_shader

def gs_get_pixel_shader() -> "gs_shader_t *":
    return _obspython.gs_get_pixel_shader()
gs_get_pixel_shader = _obspython.gs_get_pixel_shader

def gs_get_render_target() -> "gs_texture_t *":
    return _obspython.gs_get_render_target()
gs_get_render_target = _obspython.gs_get_render_target

def gs_get_zstencil_target() -> "gs_zstencil_t *":
    return _obspython.gs_get_zstencil_target()
gs_get_zstencil_target = _obspython.gs_get_zstencil_target

def gs_set_render_target(tex: 'gs_texture_t *', zstencil: 'gs_zstencil_t *') -> "void":
    return _obspython.gs_set_render_target(tex, zstencil)
gs_set_render_target = _obspython.gs_set_render_target

def gs_set_cube_render_target(cubetex: 'gs_texture_t *', side: 'int', zstencil: 'gs_zstencil_t *') -> "void":
    return _obspython.gs_set_cube_render_target(cubetex, side, zstencil)
gs_set_cube_render_target = _obspython.gs_set_cube_render_target

def gs_copy_texture(dst: 'gs_texture_t *', src: 'gs_texture_t *') -> "void":
    return _obspython.gs_copy_texture(dst, src)
gs_copy_texture = _obspython.gs_copy_texture

def gs_copy_texture_region(dst: 'gs_texture_t *', dst_x: 'uint32_t', dst_y: 'uint32_t', src: 'gs_texture_t *', src_x: 'uint32_t', src_y: 'uint32_t', src_w: 'uint32_t', src_h: 'uint32_t') -> "void":
    return _obspython.gs_copy_texture_region(dst, dst_x, dst_y, src, src_x, src_y, src_w, src_h)
gs_copy_texture_region = _obspython.gs_copy_texture_region

def gs_stage_texture(dst: 'gs_stagesurf_t *', src: 'gs_texture_t *') -> "void":
    return _obspython.gs_stage_texture(dst, src)
gs_stage_texture = _obspython.gs_stage_texture

def gs_begin_scene() -> "void":
    return _obspython.gs_begin_scene()
gs_begin_scene = _obspython.gs_begin_scene

def gs_draw(draw_mode: 'enum gs_draw_mode', start_vert: 'uint32_t', num_verts: 'uint32_t') -> "void":
    return _obspython.gs_draw(draw_mode, start_vert, num_verts)
gs_draw = _obspython.gs_draw

def gs_end_scene() -> "void":
    return _obspython.gs_end_scene()
gs_end_scene = _obspython.gs_end_scene
GS_CLEAR_COLOR = _obspython.GS_CLEAR_COLOR
GS_CLEAR_DEPTH = _obspython.GS_CLEAR_DEPTH
GS_CLEAR_STENCIL = _obspython.GS_CLEAR_STENCIL

def gs_load_swapchain(swapchain: 'gs_swapchain_t *') -> "void":
    return _obspython.gs_load_swapchain(swapchain)
gs_load_swapchain = _obspython.gs_load_swapchain

def gs_clear(clear_flags: 'uint32_t', color: 'vec4', depth: 'float', stencil: 'uint8_t') -> "void":
    return _obspython.gs_clear(clear_flags, color, depth, stencil)
gs_clear = _obspython.gs_clear

def gs_present() -> "void":
    return _obspython.gs_present()
gs_present = _obspython.gs_present

def gs_flush() -> "void":
    return _obspython.gs_flush()
gs_flush = _obspython.gs_flush

def gs_set_cull_mode(mode: 'enum gs_cull_mode') -> "void":
    return _obspython.gs_set_cull_mode(mode)
gs_set_cull_mode = _obspython.gs_set_cull_mode

def gs_get_cull_mode() -> "enum gs_cull_mode":
    return _obspython.gs_get_cull_mode()
gs_get_cull_mode = _obspython.gs_get_cull_mode

def gs_enable_blending(enable: 'bool') -> "void":
    return _obspython.gs_enable_blending(enable)
gs_enable_blending = _obspython.gs_enable_blending

def gs_enable_depth_test(enable: 'bool') -> "void":
    return _obspython.gs_enable_depth_test(enable)
gs_enable_depth_test = _obspython.gs_enable_depth_test

def gs_enable_stencil_test(enable: 'bool') -> "void":
    return _obspython.gs_enable_stencil_test(enable)
gs_enable_stencil_test = _obspython.gs_enable_stencil_test

def gs_enable_stencil_write(enable: 'bool') -> "void":
    return _obspython.gs_enable_stencil_write(enable)
gs_enable_stencil_write = _obspython.gs_enable_stencil_write

def gs_enable_color(red: 'bool', green: 'bool', blue: 'bool', alpha: 'bool') -> "void":
    return _obspython.gs_enable_color(red, green, blue, alpha)
gs_enable_color = _obspython.gs_enable_color

def gs_blend_function(src: 'enum gs_blend_type', dest: 'enum gs_blend_type') -> "void":
    return _obspython.gs_blend_function(src, dest)
gs_blend_function = _obspython.gs_blend_function

def gs_blend_function_separate(src_c: 'enum gs_blend_type', dest_c: 'enum gs_blend_type', src_a: 'enum gs_blend_type', dest_a: 'enum gs_blend_type') -> "void":
    return _obspython.gs_blend_function_separate(src_c, dest_c, src_a, dest_a)
gs_blend_function_separate = _obspython.gs_blend_function_separate

def gs_depth_function(test: 'enum gs_depth_test') -> "void":
    return _obspython.gs_depth_function(test)
gs_depth_function = _obspython.gs_depth_function

def gs_stencil_function(side: 'enum gs_stencil_side', test: 'enum gs_depth_test') -> "void":
    return _obspython.gs_stencil_function(side, test)
gs_stencil_function = _obspython.gs_stencil_function

def gs_stencil_op(side: 'enum gs_stencil_side', fail: 'enum gs_stencil_op_type', zfail: 'enum gs_stencil_op_type', zpass: 'enum gs_stencil_op_type') -> "void":
    return _obspython.gs_stencil_op(side, fail, zfail, zpass)
gs_stencil_op = _obspython.gs_stencil_op

def gs_set_viewport(x: 'int', y: 'int', width: 'int', height: 'int') -> "void":
    return _obspython.gs_set_viewport(x, y, width, height)
gs_set_viewport = _obspython.gs_set_viewport

def gs_get_viewport(rect: 'gs_rect') -> "void":
    return _obspython.gs_get_viewport(rect)
gs_get_viewport = _obspython.gs_get_viewport

def gs_set_scissor_rect(rect: 'gs_rect') -> "void":
    return _obspython.gs_set_scissor_rect(rect)
gs_set_scissor_rect = _obspython.gs_set_scissor_rect

def gs_ortho(left: 'float', right: 'float', top: 'float', bottom: 'float', znear: 'float', zfar: 'float') -> "void":
    return _obspython.gs_ortho(left, right, top, bottom, znear, zfar)
gs_ortho = _obspython.gs_ortho

def gs_frustum(left: 'float', right: 'float', top: 'float', bottom: 'float', znear: 'float', zfar: 'float') -> "void":
    return _obspython.gs_frustum(left, right, top, bottom, znear, zfar)
gs_frustum = _obspython.gs_frustum

def gs_projection_push() -> "void":
    return _obspython.gs_projection_push()
gs_projection_push = _obspython.gs_projection_push

def gs_projection_pop() -> "void":
    return _obspython.gs_projection_pop()
gs_projection_pop = _obspython.gs_projection_pop

def gs_swapchain_destroy(swapchain: 'gs_swapchain_t *') -> "void":
    return _obspython.gs_swapchain_destroy(swapchain)
gs_swapchain_destroy = _obspython.gs_swapchain_destroy

def gs_texture_destroy(tex: 'gs_texture_t *') -> "void":
    return _obspython.gs_texture_destroy(tex)
gs_texture_destroy = _obspython.gs_texture_destroy

def gs_texture_get_width(tex: 'gs_texture_t const *') -> "uint32_t":
    return _obspython.gs_texture_get_width(tex)
gs_texture_get_width = _obspython.gs_texture_get_width

def gs_texture_get_height(tex: 'gs_texture_t const *') -> "uint32_t":
    return _obspython.gs_texture_get_height(tex)
gs_texture_get_height = _obspython.gs_texture_get_height

def gs_texture_get_color_format(tex: 'gs_texture_t const *') -> "enum gs_color_format":
    return _obspython.gs_texture_get_color_format(tex)
gs_texture_get_color_format = _obspython.gs_texture_get_color_format

def gs_texture_map(tex: 'gs_texture_t *', ptr: 'uint8_t **', linesize: 'uint32_t *') -> "bool":
    return _obspython.gs_texture_map(tex, ptr, linesize)
gs_texture_map = _obspython.gs_texture_map

def gs_texture_unmap(tex: 'gs_texture_t *') -> "void":
    return _obspython.gs_texture_unmap(tex)
gs_texture_unmap = _obspython.gs_texture_unmap

def gs_texture_is_rect(tex: 'gs_texture_t const *') -> "bool":
    return _obspython.gs_texture_is_rect(tex)
gs_texture_is_rect = _obspython.gs_texture_is_rect

def gs_texture_get_obj(tex: 'gs_texture_t *') -> "void *":
    return _obspython.gs_texture_get_obj(tex)
gs_texture_get_obj = _obspython.gs_texture_get_obj

def gs_cubetexture_destroy(cubetex: 'gs_texture_t *') -> "void":
    return _obspython.gs_cubetexture_destroy(cubetex)
gs_cubetexture_destroy = _obspython.gs_cubetexture_destroy

def gs_cubetexture_get_size(cubetex: 'gs_texture_t const *') -> "uint32_t":
    return _obspython.gs_cubetexture_get_size(cubetex)
gs_cubetexture_get_size = _obspython.gs_cubetexture_get_size

def gs_cubetexture_get_color_format(cubetex: 'gs_texture_t const *') -> "enum gs_color_format":
    return _obspython.gs_cubetexture_get_color_format(cubetex)
gs_cubetexture_get_color_format = _obspython.gs_cubetexture_get_color_format

def gs_voltexture_destroy(voltex: 'gs_texture_t *') -> "void":
    return _obspython.gs_voltexture_destroy(voltex)
gs_voltexture_destroy = _obspython.gs_voltexture_destroy

def gs_voltexture_get_width(voltex: 'gs_texture_t const *') -> "uint32_t":
    return _obspython.gs_voltexture_get_width(voltex)
gs_voltexture_get_width = _obspython.gs_voltexture_get_width

def gs_voltexture_get_height(voltex: 'gs_texture_t const *') -> "uint32_t":
    return _obspython.gs_voltexture_get_height(voltex)
gs_voltexture_get_height = _obspython.gs_voltexture_get_height

def gs_voltexture_get_depth(voltex: 'gs_texture_t const *') -> "uint32_t":
    return _obspython.gs_voltexture_get_depth(voltex)
gs_voltexture_get_depth = _obspython.gs_voltexture_get_depth

def gs_voltexture_get_color_format(voltex: 'gs_texture_t const *') -> "enum gs_color_format":
    return _obspython.gs_voltexture_get_color_format(voltex)
gs_voltexture_get_color_format = _obspython.gs_voltexture_get_color_format

def gs_stagesurface_destroy(stagesurf: 'gs_stagesurf_t *') -> "void":
    return _obspython.gs_stagesurface_destroy(stagesurf)
gs_stagesurface_destroy = _obspython.gs_stagesurface_destroy

def gs_stagesurface_get_width(stagesurf: 'gs_stagesurf_t const *') -> "uint32_t":
    return _obspython.gs_stagesurface_get_width(stagesurf)
gs_stagesurface_get_width = _obspython.gs_stagesurface_get_width

def gs_stagesurface_get_height(stagesurf: 'gs_stagesurf_t const *') -> "uint32_t":
    return _obspython.gs_stagesurface_get_height(stagesurf)
gs_stagesurface_get_height = _obspython.gs_stagesurface_get_height

def gs_stagesurface_get_color_format(stagesurf: 'gs_stagesurf_t const *') -> "enum gs_color_format":
    return _obspython.gs_stagesurface_get_color_format(stagesurf)
gs_stagesurface_get_color_format = _obspython.gs_stagesurface_get_color_format

def gs_stagesurface_map(stagesurf: 'gs_stagesurf_t *', data: 'uint8_t **', linesize: 'uint32_t *') -> "bool":
    return _obspython.gs_stagesurface_map(stagesurf, data, linesize)
gs_stagesurface_map = _obspython.gs_stagesurface_map

def gs_stagesurface_unmap(stagesurf: 'gs_stagesurf_t *') -> "void":
    return _obspython.gs_stagesurface_unmap(stagesurf)
gs_stagesurface_unmap = _obspython.gs_stagesurface_unmap

def gs_zstencil_destroy(zstencil: 'gs_zstencil_t *') -> "void":
    return _obspython.gs_zstencil_destroy(zstencil)
gs_zstencil_destroy = _obspython.gs_zstencil_destroy

def gs_samplerstate_destroy(samplerstate: 'gs_samplerstate_t *') -> "void":
    return _obspython.gs_samplerstate_destroy(samplerstate)
gs_samplerstate_destroy = _obspython.gs_samplerstate_destroy

def gs_vertexbuffer_destroy(vertbuffer: 'gs_vertbuffer_t *') -> "void":
    return _obspython.gs_vertexbuffer_destroy(vertbuffer)
gs_vertexbuffer_destroy = _obspython.gs_vertexbuffer_destroy

def gs_vertexbuffer_flush(vertbuffer: 'gs_vertbuffer_t *') -> "void":
    return _obspython.gs_vertexbuffer_flush(vertbuffer)
gs_vertexbuffer_flush = _obspython.gs_vertexbuffer_flush

def gs_vertexbuffer_flush_direct(vertbuffer: 'gs_vertbuffer_t *', data: 'gs_vb_data') -> "void":
    return _obspython.gs_vertexbuffer_flush_direct(vertbuffer, data)
gs_vertexbuffer_flush_direct = _obspython.gs_vertexbuffer_flush_direct

def gs_vertexbuffer_get_data(vertbuffer: 'gs_vertbuffer_t const *') -> "struct gs_vb_data *":
    return _obspython.gs_vertexbuffer_get_data(vertbuffer)
gs_vertexbuffer_get_data = _obspython.gs_vertexbuffer_get_data

def gs_indexbuffer_destroy(indexbuffer: 'gs_indexbuffer_t *') -> "void":
    return _obspython.gs_indexbuffer_destroy(indexbuffer)
gs_indexbuffer_destroy = _obspython.gs_indexbuffer_destroy

def gs_indexbuffer_flush(indexbuffer: 'gs_indexbuffer_t *') -> "void":
    return _obspython.gs_indexbuffer_flush(indexbuffer)
gs_indexbuffer_flush = _obspython.gs_indexbuffer_flush

def gs_indexbuffer_flush_direct(indexbuffer: 'gs_indexbuffer_t *', data: 'void const *') -> "void":
    return _obspython.gs_indexbuffer_flush_direct(indexbuffer, data)
gs_indexbuffer_flush_direct = _obspython.gs_indexbuffer_flush_direct

def gs_indexbuffer_get_data(indexbuffer: 'gs_indexbuffer_t const *') -> "void *":
    return _obspython.gs_indexbuffer_get_data(indexbuffer)
gs_indexbuffer_get_data = _obspython.gs_indexbuffer_get_data

def gs_indexbuffer_get_num_indices(indexbuffer: 'gs_indexbuffer_t const *') -> "size_t":
    return _obspython.gs_indexbuffer_get_num_indices(indexbuffer)
gs_indexbuffer_get_num_indices = _obspython.gs_indexbuffer_get_num_indices

def gs_indexbuffer_get_type(indexbuffer: 'gs_indexbuffer_t const *') -> "enum gs_index_type":
    return _obspython.gs_indexbuffer_get_type(indexbuffer)
gs_indexbuffer_get_type = _obspython.gs_indexbuffer_get_type

def gs_nv12_available() -> "bool":
    return _obspython.gs_nv12_available()
gs_nv12_available = _obspython.gs_nv12_available

def gs_get_format_bpp(format: 'enum gs_color_format') -> "uint32_t":
    return _obspython.gs_get_format_bpp(format)
gs_get_format_bpp = _obspython.gs_get_format_bpp

def gs_is_compressed_format(format: 'enum gs_color_format') -> "bool":
    return _obspython.gs_is_compressed_format(format)
gs_is_compressed_format = _obspython.gs_is_compressed_format

def gs_get_total_levels(width: 'uint32_t', height: 'uint32_t') -> "uint32_t":
    return _obspython.gs_get_total_levels(width, height)
gs_get_total_levels = _obspython.gs_get_total_levels
class vec4(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vec4, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vec4, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _obspython.vec4_x_set
    __swig_getmethods__["x"] = _obspython.vec4_x_get
    if _newclass:
        x = _swig_property(_obspython.vec4_x_get, _obspython.vec4_x_set)
    __swig_setmethods__["y"] = _obspython.vec4_y_set
    __swig_getmethods__["y"] = _obspython.vec4_y_get
    if _newclass:
        y = _swig_property(_obspython.vec4_y_get, _obspython.vec4_y_set)
    __swig_setmethods__["z"] = _obspython.vec4_z_set
    __swig_getmethods__["z"] = _obspython.vec4_z_get
    if _newclass:
        z = _swig_property(_obspython.vec4_z_get, _obspython.vec4_z_set)
    __swig_setmethods__["w"] = _obspython.vec4_w_set
    __swig_getmethods__["w"] = _obspython.vec4_w_get
    if _newclass:
        w = _swig_property(_obspython.vec4_w_get, _obspython.vec4_w_set)
    __swig_setmethods__["ptr"] = _obspython.vec4_ptr_set
    __swig_getmethods__["ptr"] = _obspython.vec4_ptr_get
    if _newclass:
        ptr = _swig_property(_obspython.vec4_ptr_get, _obspython.vec4_ptr_set)
    __swig_setmethods__["m"] = _obspython.vec4_m_set
    __swig_getmethods__["m"] = _obspython.vec4_m_get
    if _newclass:
        m = _swig_property(_obspython.vec4_m_get, _obspython.vec4_m_set)

    def __init__(self):
        this = _obspython.new_vec4()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_vec4
    __del__ = lambda self: None
vec4_swigregister = _obspython.vec4_swigregister
vec4_swigregister(vec4)


def vec4_zero(v: 'vec4') -> "void":
    return _obspython.vec4_zero(v)
vec4_zero = _obspython.vec4_zero

def vec4_set(dst: 'vec4', x: 'float', y: 'float', z: 'float', w: 'float') -> "void":
    return _obspython.vec4_set(dst, x, y, z, w)
vec4_set = _obspython.vec4_set

def vec4_copy(dst: 'vec4', v: 'vec4') -> "void":
    return _obspython.vec4_copy(dst, v)
vec4_copy = _obspython.vec4_copy

def vec4_from_vec3(dst: 'vec4', v: 'vec3') -> "void":
    return _obspython.vec4_from_vec3(dst, v)
vec4_from_vec3 = _obspython.vec4_from_vec3

def vec4_add(dst: 'vec4', v1: 'vec4', v2: 'vec4') -> "void":
    return _obspython.vec4_add(dst, v1, v2)
vec4_add = _obspython.vec4_add

def vec4_sub(dst: 'vec4', v1: 'vec4', v2: 'vec4') -> "void":
    return _obspython.vec4_sub(dst, v1, v2)
vec4_sub = _obspython.vec4_sub

def vec4_mul(dst: 'vec4', v1: 'vec4', v2: 'vec4') -> "void":
    return _obspython.vec4_mul(dst, v1, v2)
vec4_mul = _obspython.vec4_mul

def vec4_div(dst: 'vec4', v1: 'vec4', v2: 'vec4') -> "void":
    return _obspython.vec4_div(dst, v1, v2)
vec4_div = _obspython.vec4_div

def vec4_addf(dst: 'vec4', v: 'vec4', f: 'float') -> "void":
    return _obspython.vec4_addf(dst, v, f)
vec4_addf = _obspython.vec4_addf

def vec4_subf(dst: 'vec4', v: 'vec4', f: 'float') -> "void":
    return _obspython.vec4_subf(dst, v, f)
vec4_subf = _obspython.vec4_subf

def vec4_mulf(dst: 'vec4', v: 'vec4', f: 'float') -> "void":
    return _obspython.vec4_mulf(dst, v, f)
vec4_mulf = _obspython.vec4_mulf

def vec4_divf(dst: 'vec4', v: 'vec4', f: 'float') -> "void":
    return _obspython.vec4_divf(dst, v, f)
vec4_divf = _obspython.vec4_divf

def vec4_dot(v1: 'vec4', v2: 'vec4') -> "float":
    return _obspython.vec4_dot(v1, v2)
vec4_dot = _obspython.vec4_dot

def vec4_neg(dst: 'vec4', v: 'vec4') -> "void":
    return _obspython.vec4_neg(dst, v)
vec4_neg = _obspython.vec4_neg

def vec4_len(v: 'vec4') -> "float":
    return _obspython.vec4_len(v)
vec4_len = _obspython.vec4_len

def vec4_dist(v1: 'vec4', v2: 'vec4') -> "float":
    return _obspython.vec4_dist(v1, v2)
vec4_dist = _obspython.vec4_dist

def vec4_norm(dst: 'vec4', v: 'vec4') -> "void":
    return _obspython.vec4_norm(dst, v)
vec4_norm = _obspython.vec4_norm

def vec4_close(v1: 'vec4', v2: 'vec4', epsilon: 'float') -> "int":
    return _obspython.vec4_close(v1, v2, epsilon)
vec4_close = _obspython.vec4_close

def vec4_min(dst: 'vec4', v1: 'vec4', v2: 'vec4') -> "void":
    return _obspython.vec4_min(dst, v1, v2)
vec4_min = _obspython.vec4_min

def vec4_minf(dst: 'vec4', v: 'vec4', f: 'float') -> "void":
    return _obspython.vec4_minf(dst, v, f)
vec4_minf = _obspython.vec4_minf

def vec4_max(dst: 'vec4', v1: 'vec4', v2: 'vec4') -> "void":
    return _obspython.vec4_max(dst, v1, v2)
vec4_max = _obspython.vec4_max

def vec4_maxf(dst: 'vec4', v: 'vec4', f: 'float') -> "void":
    return _obspython.vec4_maxf(dst, v, f)
vec4_maxf = _obspython.vec4_maxf

def vec4_abs(dst: 'vec4', v: 'vec4') -> "void":
    return _obspython.vec4_abs(dst, v)
vec4_abs = _obspython.vec4_abs

def vec4_floor(dst: 'vec4', v: 'vec4') -> "void":
    return _obspython.vec4_floor(dst, v)
vec4_floor = _obspython.vec4_floor

def vec4_ceil(dst: 'vec4', v: 'vec4') -> "void":
    return _obspython.vec4_ceil(dst, v)
vec4_ceil = _obspython.vec4_ceil

def vec4_to_rgba(src: 'vec4') -> "uint32_t":
    return _obspython.vec4_to_rgba(src)
vec4_to_rgba = _obspython.vec4_to_rgba

def vec4_to_bgra(src: 'vec4') -> "uint32_t":
    return _obspython.vec4_to_bgra(src)
vec4_to_bgra = _obspython.vec4_to_bgra

def vec4_from_rgba(dst: 'vec4', rgba: 'uint32_t') -> "void":
    return _obspython.vec4_from_rgba(dst, rgba)
vec4_from_rgba = _obspython.vec4_from_rgba

def vec4_from_bgra(dst: 'vec4', bgra: 'uint32_t') -> "void":
    return _obspython.vec4_from_bgra(dst, bgra)
vec4_from_bgra = _obspython.vec4_from_bgra

def vec4_transform(dst: 'vec4', v: 'vec4', m: 'struct matrix4 const *') -> "void":
    return _obspython.vec4_transform(dst, v, m)
vec4_transform = _obspython.vec4_transform
class vec3(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vec3, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vec3, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _obspython.vec3_x_set
    __swig_getmethods__["x"] = _obspython.vec3_x_get
    if _newclass:
        x = _swig_property(_obspython.vec3_x_get, _obspython.vec3_x_set)
    __swig_setmethods__["y"] = _obspython.vec3_y_set
    __swig_getmethods__["y"] = _obspython.vec3_y_get
    if _newclass:
        y = _swig_property(_obspython.vec3_y_get, _obspython.vec3_y_set)
    __swig_setmethods__["z"] = _obspython.vec3_z_set
    __swig_getmethods__["z"] = _obspython.vec3_z_get
    if _newclass:
        z = _swig_property(_obspython.vec3_z_get, _obspython.vec3_z_set)
    __swig_setmethods__["w"] = _obspython.vec3_w_set
    __swig_getmethods__["w"] = _obspython.vec3_w_get
    if _newclass:
        w = _swig_property(_obspython.vec3_w_get, _obspython.vec3_w_set)
    __swig_setmethods__["ptr"] = _obspython.vec3_ptr_set
    __swig_getmethods__["ptr"] = _obspython.vec3_ptr_get
    if _newclass:
        ptr = _swig_property(_obspython.vec3_ptr_get, _obspython.vec3_ptr_set)
    __swig_setmethods__["m"] = _obspython.vec3_m_set
    __swig_getmethods__["m"] = _obspython.vec3_m_get
    if _newclass:
        m = _swig_property(_obspython.vec3_m_get, _obspython.vec3_m_set)

    def __init__(self):
        this = _obspython.new_vec3()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_vec3
    __del__ = lambda self: None
vec3_swigregister = _obspython.vec3_swigregister
vec3_swigregister(vec3)


def vec3_zero(v: 'vec3') -> "void":
    return _obspython.vec3_zero(v)
vec3_zero = _obspython.vec3_zero

def vec3_set(dst: 'vec3', x: 'float', y: 'float', z: 'float') -> "void":
    return _obspython.vec3_set(dst, x, y, z)
vec3_set = _obspython.vec3_set

def vec3_copy(dst: 'vec3', v: 'vec3') -> "void":
    return _obspython.vec3_copy(dst, v)
vec3_copy = _obspython.vec3_copy

def vec3_from_vec4(dst: 'vec3', v: 'vec4') -> "void":
    return _obspython.vec3_from_vec4(dst, v)
vec3_from_vec4 = _obspython.vec3_from_vec4

def vec3_add(dst: 'vec3', v1: 'vec3', v2: 'vec3') -> "void":
    return _obspython.vec3_add(dst, v1, v2)
vec3_add = _obspython.vec3_add

def vec3_sub(dst: 'vec3', v1: 'vec3', v2: 'vec3') -> "void":
    return _obspython.vec3_sub(dst, v1, v2)
vec3_sub = _obspython.vec3_sub

def vec3_mul(dst: 'vec3', v1: 'vec3', v2: 'vec3') -> "void":
    return _obspython.vec3_mul(dst, v1, v2)
vec3_mul = _obspython.vec3_mul

def vec3_div(dst: 'vec3', v1: 'vec3', v2: 'vec3') -> "void":
    return _obspython.vec3_div(dst, v1, v2)
vec3_div = _obspython.vec3_div

def vec3_addf(dst: 'vec3', v: 'vec3', f: 'float') -> "void":
    return _obspython.vec3_addf(dst, v, f)
vec3_addf = _obspython.vec3_addf

def vec3_subf(dst: 'vec3', v: 'vec3', f: 'float') -> "void":
    return _obspython.vec3_subf(dst, v, f)
vec3_subf = _obspython.vec3_subf

def vec3_mulf(dst: 'vec3', v: 'vec3', f: 'float') -> "void":
    return _obspython.vec3_mulf(dst, v, f)
vec3_mulf = _obspython.vec3_mulf

def vec3_divf(dst: 'vec3', v: 'vec3', f: 'float') -> "void":
    return _obspython.vec3_divf(dst, v, f)
vec3_divf = _obspython.vec3_divf

def vec3_dot(v1: 'vec3', v2: 'vec3') -> "float":
    return _obspython.vec3_dot(v1, v2)
vec3_dot = _obspython.vec3_dot

def vec3_cross(dst: 'vec3', v1: 'vec3', v2: 'vec3') -> "void":
    return _obspython.vec3_cross(dst, v1, v2)
vec3_cross = _obspython.vec3_cross

def vec3_neg(dst: 'vec3', v: 'vec3') -> "void":
    return _obspython.vec3_neg(dst, v)
vec3_neg = _obspython.vec3_neg

def vec3_len(v: 'vec3') -> "float":
    return _obspython.vec3_len(v)
vec3_len = _obspython.vec3_len

def vec3_dist(v1: 'vec3', v2: 'vec3') -> "float":
    return _obspython.vec3_dist(v1, v2)
vec3_dist = _obspython.vec3_dist

def vec3_norm(dst: 'vec3', v: 'vec3') -> "void":
    return _obspython.vec3_norm(dst, v)
vec3_norm = _obspython.vec3_norm

def vec3_close(v1: 'vec3', v2: 'vec3', epsilon: 'float') -> "bool":
    return _obspython.vec3_close(v1, v2, epsilon)
vec3_close = _obspython.vec3_close

def vec3_min(dst: 'vec3', v1: 'vec3', v2: 'vec3') -> "void":
    return _obspython.vec3_min(dst, v1, v2)
vec3_min = _obspython.vec3_min

def vec3_minf(dst: 'vec3', v: 'vec3', f: 'float') -> "void":
    return _obspython.vec3_minf(dst, v, f)
vec3_minf = _obspython.vec3_minf

def vec3_max(dst: 'vec3', v1: 'vec3', v2: 'vec3') -> "void":
    return _obspython.vec3_max(dst, v1, v2)
vec3_max = _obspython.vec3_max

def vec3_maxf(dst: 'vec3', v: 'vec3', f: 'float') -> "void":
    return _obspython.vec3_maxf(dst, v, f)
vec3_maxf = _obspython.vec3_maxf

def vec3_abs(dst: 'vec3', v: 'vec3') -> "void":
    return _obspython.vec3_abs(dst, v)
vec3_abs = _obspython.vec3_abs

def vec3_floor(dst: 'vec3', v: 'vec3') -> "void":
    return _obspython.vec3_floor(dst, v)
vec3_floor = _obspython.vec3_floor

def vec3_ceil(dst: 'vec3', v: 'vec3') -> "void":
    return _obspython.vec3_ceil(dst, v)
vec3_ceil = _obspython.vec3_ceil

def vec3_plane_dist(v: 'vec3', p: 'struct plane const *') -> "float":
    return _obspython.vec3_plane_dist(v, p)
vec3_plane_dist = _obspython.vec3_plane_dist

def vec3_transform(dst: 'vec3', v: 'vec3', m: 'struct matrix4 const *') -> "void":
    return _obspython.vec3_transform(dst, v, m)
vec3_transform = _obspython.vec3_transform

def vec3_rotate(dst: 'vec3', v: 'vec3', m: 'struct matrix3 const *') -> "void":
    return _obspython.vec3_rotate(dst, v, m)
vec3_rotate = _obspython.vec3_rotate

def vec3_transform3x4(dst: 'vec3', v: 'vec3', m: 'struct matrix3 const *') -> "void":
    return _obspython.vec3_transform3x4(dst, v, m)
vec3_transform3x4 = _obspython.vec3_transform3x4

def vec3_mirror(dst: 'vec3', v: 'vec3', p: 'struct plane const *') -> "void":
    return _obspython.vec3_mirror(dst, v, p)
vec3_mirror = _obspython.vec3_mirror

def vec3_mirrorv(dst: 'vec3', v: 'vec3', vec: 'vec3') -> "void":
    return _obspython.vec3_mirrorv(dst, v, vec)
vec3_mirrorv = _obspython.vec3_mirrorv

def vec3_rand(dst: 'vec3', positive_only: 'int') -> "void":
    return _obspython.vec3_rand(dst, positive_only)
vec3_rand = _obspython.vec3_rand
class vec2(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vec2, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vec2, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _obspython.vec2_x_set
    __swig_getmethods__["x"] = _obspython.vec2_x_get
    if _newclass:
        x = _swig_property(_obspython.vec2_x_get, _obspython.vec2_x_set)
    __swig_setmethods__["y"] = _obspython.vec2_y_set
    __swig_getmethods__["y"] = _obspython.vec2_y_get
    if _newclass:
        y = _swig_property(_obspython.vec2_y_get, _obspython.vec2_y_set)
    __swig_setmethods__["ptr"] = _obspython.vec2_ptr_set
    __swig_getmethods__["ptr"] = _obspython.vec2_ptr_get
    if _newclass:
        ptr = _swig_property(_obspython.vec2_ptr_get, _obspython.vec2_ptr_set)

    def __init__(self):
        this = _obspython.new_vec2()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_vec2
    __del__ = lambda self: None
vec2_swigregister = _obspython.vec2_swigregister
vec2_swigregister(vec2)


def vec2_zero(dst: 'vec2') -> "void":
    return _obspython.vec2_zero(dst)
vec2_zero = _obspython.vec2_zero

def vec2_set(dst: 'vec2', x: 'float', y: 'float') -> "void":
    return _obspython.vec2_set(dst, x, y)
vec2_set = _obspython.vec2_set

def vec2_copy(dst: 'vec2', v: 'vec2') -> "void":
    return _obspython.vec2_copy(dst, v)
vec2_copy = _obspython.vec2_copy

def vec2_add(dst: 'vec2', v1: 'vec2', v2: 'vec2') -> "void":
    return _obspython.vec2_add(dst, v1, v2)
vec2_add = _obspython.vec2_add

def vec2_sub(dst: 'vec2', v1: 'vec2', v2: 'vec2') -> "void":
    return _obspython.vec2_sub(dst, v1, v2)
vec2_sub = _obspython.vec2_sub

def vec2_mul(dst: 'vec2', v1: 'vec2', v2: 'vec2') -> "void":
    return _obspython.vec2_mul(dst, v1, v2)
vec2_mul = _obspython.vec2_mul

def vec2_div(dst: 'vec2', v1: 'vec2', v2: 'vec2') -> "void":
    return _obspython.vec2_div(dst, v1, v2)
vec2_div = _obspython.vec2_div

def vec2_addf(dst: 'vec2', v: 'vec2', f: 'float') -> "void":
    return _obspython.vec2_addf(dst, v, f)
vec2_addf = _obspython.vec2_addf

def vec2_subf(dst: 'vec2', v: 'vec2', f: 'float') -> "void":
    return _obspython.vec2_subf(dst, v, f)
vec2_subf = _obspython.vec2_subf

def vec2_mulf(dst: 'vec2', v: 'vec2', f: 'float') -> "void":
    return _obspython.vec2_mulf(dst, v, f)
vec2_mulf = _obspython.vec2_mulf

def vec2_divf(dst: 'vec2', v: 'vec2', f: 'float') -> "void":
    return _obspython.vec2_divf(dst, v, f)
vec2_divf = _obspython.vec2_divf

def vec2_neg(dst: 'vec2', v: 'vec2') -> "void":
    return _obspython.vec2_neg(dst, v)
vec2_neg = _obspython.vec2_neg

def vec2_dot(v1: 'vec2', v2: 'vec2') -> "float":
    return _obspython.vec2_dot(v1, v2)
vec2_dot = _obspython.vec2_dot

def vec2_len(v: 'vec2') -> "float":
    return _obspython.vec2_len(v)
vec2_len = _obspython.vec2_len

def vec2_dist(v1: 'vec2', v2: 'vec2') -> "float":
    return _obspython.vec2_dist(v1, v2)
vec2_dist = _obspython.vec2_dist

def vec2_minf(dst: 'vec2', v: 'vec2', val: 'float') -> "void":
    return _obspython.vec2_minf(dst, v, val)
vec2_minf = _obspython.vec2_minf

def vec2_min(dst: 'vec2', v: 'vec2', min_v: 'vec2') -> "void":
    return _obspython.vec2_min(dst, v, min_v)
vec2_min = _obspython.vec2_min

def vec2_maxf(dst: 'vec2', v: 'vec2', val: 'float') -> "void":
    return _obspython.vec2_maxf(dst, v, val)
vec2_maxf = _obspython.vec2_maxf

def vec2_max(dst: 'vec2', v: 'vec2', max_v: 'vec2') -> "void":
    return _obspython.vec2_max(dst, v, max_v)
vec2_max = _obspython.vec2_max

def vec2_abs(dst: 'vec2', v: 'vec2') -> "void":
    return _obspython.vec2_abs(dst, v)
vec2_abs = _obspython.vec2_abs

def vec2_floor(dst: 'vec2', v: 'vec2') -> "void":
    return _obspython.vec2_floor(dst, v)
vec2_floor = _obspython.vec2_floor

def vec2_ceil(dst: 'vec2', v: 'vec2') -> "void":
    return _obspython.vec2_ceil(dst, v)
vec2_ceil = _obspython.vec2_ceil

def vec2_close(v1: 'vec2', v2: 'vec2', epsilon: 'float') -> "int":
    return _obspython.vec2_close(v1, v2, epsilon)
vec2_close = _obspython.vec2_close

def vec2_norm(dst: 'vec2', v: 'vec2') -> "void":
    return _obspython.vec2_norm(dst, v)
vec2_norm = _obspython.vec2_norm
class quat(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, quat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, quat, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _obspython.quat_x_set
    __swig_getmethods__["x"] = _obspython.quat_x_get
    if _newclass:
        x = _swig_property(_obspython.quat_x_get, _obspython.quat_x_set)
    __swig_setmethods__["y"] = _obspython.quat_y_set
    __swig_getmethods__["y"] = _obspython.quat_y_get
    if _newclass:
        y = _swig_property(_obspython.quat_y_get, _obspython.quat_y_set)
    __swig_setmethods__["z"] = _obspython.quat_z_set
    __swig_getmethods__["z"] = _obspython.quat_z_get
    if _newclass:
        z = _swig_property(_obspython.quat_z_get, _obspython.quat_z_set)
    __swig_setmethods__["w"] = _obspython.quat_w_set
    __swig_getmethods__["w"] = _obspython.quat_w_get
    if _newclass:
        w = _swig_property(_obspython.quat_w_get, _obspython.quat_w_set)
    __swig_setmethods__["ptr"] = _obspython.quat_ptr_set
    __swig_getmethods__["ptr"] = _obspython.quat_ptr_get
    if _newclass:
        ptr = _swig_property(_obspython.quat_ptr_get, _obspython.quat_ptr_set)
    __swig_setmethods__["m"] = _obspython.quat_m_set
    __swig_getmethods__["m"] = _obspython.quat_m_get
    if _newclass:
        m = _swig_property(_obspython.quat_m_get, _obspython.quat_m_set)

    def __init__(self):
        this = _obspython.new_quat()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_quat
    __del__ = lambda self: None
quat_swigregister = _obspython.quat_swigregister
quat_swigregister(quat)


def quat_identity(q: 'quat') -> "void":
    return _obspython.quat_identity(q)
quat_identity = _obspython.quat_identity

def quat_set(dst: 'quat', x: 'float', y: 'float', z: 'float', w: 'float') -> "void":
    return _obspython.quat_set(dst, x, y, z, w)
quat_set = _obspython.quat_set

def quat_copy(dst: 'quat', q: 'quat') -> "void":
    return _obspython.quat_copy(dst, q)
quat_copy = _obspython.quat_copy

def quat_add(dst: 'quat', q1: 'quat', q2: 'quat') -> "void":
    return _obspython.quat_add(dst, q1, q2)
quat_add = _obspython.quat_add

def quat_sub(dst: 'quat', q1: 'quat', q2: 'quat') -> "void":
    return _obspython.quat_sub(dst, q1, q2)
quat_sub = _obspython.quat_sub

def quat_mul(dst: 'quat', q1: 'quat', q2: 'quat') -> "void":
    return _obspython.quat_mul(dst, q1, q2)
quat_mul = _obspython.quat_mul

def quat_addf(dst: 'quat', q: 'quat', f: 'float') -> "void":
    return _obspython.quat_addf(dst, q, f)
quat_addf = _obspython.quat_addf

def quat_subf(dst: 'quat', q: 'quat', f: 'float') -> "void":
    return _obspython.quat_subf(dst, q, f)
quat_subf = _obspython.quat_subf

def quat_mulf(dst: 'quat', q: 'quat', f: 'float') -> "void":
    return _obspython.quat_mulf(dst, q, f)
quat_mulf = _obspython.quat_mulf

def quat_divf(dst: 'quat', q: 'quat', f: 'float') -> "void":
    return _obspython.quat_divf(dst, q, f)
quat_divf = _obspython.quat_divf

def quat_dot(q1: 'quat', q2: 'quat') -> "float":
    return _obspython.quat_dot(q1, q2)
quat_dot = _obspython.quat_dot

def quat_inv(dst: 'quat', q: 'quat') -> "void":
    return _obspython.quat_inv(dst, q)
quat_inv = _obspython.quat_inv

def quat_neg(dst: 'quat', q: 'quat') -> "void":
    return _obspython.quat_neg(dst, q)
quat_neg = _obspython.quat_neg

def quat_len(q: 'quat') -> "float":
    return _obspython.quat_len(q)
quat_len = _obspython.quat_len

def quat_dist(q1: 'quat', q2: 'quat') -> "float":
    return _obspython.quat_dist(q1, q2)
quat_dist = _obspython.quat_dist

def quat_norm(dst: 'quat', q: 'quat') -> "void":
    return _obspython.quat_norm(dst, q)
quat_norm = _obspython.quat_norm

def quat_close(q1: 'quat', q2: 'quat', epsilon: 'float') -> "bool":
    return _obspython.quat_close(q1, q2, epsilon)
quat_close = _obspython.quat_close

def quat_from_axisang(dst: 'quat', aa: 'struct axisang const *') -> "void":
    return _obspython.quat_from_axisang(dst, aa)
quat_from_axisang = _obspython.quat_from_axisang

def quat_from_matrix3(dst: 'quat', m: 'struct matrix3 const *') -> "void":
    return _obspython.quat_from_matrix3(dst, m)
quat_from_matrix3 = _obspython.quat_from_matrix3

def quat_from_matrix4(dst: 'quat', m: 'struct matrix4 const *') -> "void":
    return _obspython.quat_from_matrix4(dst, m)
quat_from_matrix4 = _obspython.quat_from_matrix4

def quat_get_dir(dst: 'vec3', q: 'quat') -> "void":
    return _obspython.quat_get_dir(dst, q)
quat_get_dir = _obspython.quat_get_dir

def quat_set_look_dir(dst: 'quat', dir: 'vec3') -> "void":
    return _obspython.quat_set_look_dir(dst, dir)
quat_set_look_dir = _obspython.quat_set_look_dir

def quat_log(dst: 'quat', q: 'quat') -> "void":
    return _obspython.quat_log(dst, q)
quat_log = _obspython.quat_log

def quat_exp(dst: 'quat', q: 'quat') -> "void":
    return _obspython.quat_exp(dst, q)
quat_exp = _obspython.quat_exp

def quat_interpolate(dst: 'quat', q1: 'quat', q2: 'quat', t: 'float') -> "void":
    return _obspython.quat_interpolate(dst, q1, q2, t)
quat_interpolate = _obspython.quat_interpolate

def quat_get_tangent(dst: 'quat', prev: 'quat', q: 'quat', next: 'quat') -> "void":
    return _obspython.quat_get_tangent(dst, prev, q, next)
quat_get_tangent = _obspython.quat_get_tangent

def quat_interpolate_cubic(dst: 'quat', q1: 'quat', q2: 'quat', m1: 'quat', m2: 'quat', t: 'float') -> "void":
    return _obspython.quat_interpolate_cubic(dst, q1, q2, m1, m2, t)
quat_interpolate_cubic = _obspython.quat_interpolate_cubic
OBS_DATA_NULL = _obspython.OBS_DATA_NULL
OBS_DATA_STRING = _obspython.OBS_DATA_STRING
OBS_DATA_NUMBER = _obspython.OBS_DATA_NUMBER
OBS_DATA_BOOLEAN = _obspython.OBS_DATA_BOOLEAN
OBS_DATA_OBJECT = _obspython.OBS_DATA_OBJECT
OBS_DATA_ARRAY = _obspython.OBS_DATA_ARRAY
OBS_DATA_NUM_INVALID = _obspython.OBS_DATA_NUM_INVALID
OBS_DATA_NUM_INT = _obspython.OBS_DATA_NUM_INT
OBS_DATA_NUM_DOUBLE = _obspython.OBS_DATA_NUM_DOUBLE

def obs_data_create() -> "obs_data_t *":
    return _obspython.obs_data_create()
obs_data_create = _obspython.obs_data_create

def obs_data_create_from_json(json_string: 'char const *') -> "obs_data_t *":
    return _obspython.obs_data_create_from_json(json_string)
obs_data_create_from_json = _obspython.obs_data_create_from_json

def obs_data_create_from_json_file(json_file: 'char const *') -> "obs_data_t *":
    return _obspython.obs_data_create_from_json_file(json_file)
obs_data_create_from_json_file = _obspython.obs_data_create_from_json_file

def obs_data_create_from_json_file_safe(json_file: 'char const *', backup_ext: 'char const *') -> "obs_data_t *":
    return _obspython.obs_data_create_from_json_file_safe(json_file, backup_ext)
obs_data_create_from_json_file_safe = _obspython.obs_data_create_from_json_file_safe

def obs_data_addref(data: 'obs_data_t *') -> "void":
    return _obspython.obs_data_addref(data)
obs_data_addref = _obspython.obs_data_addref

def obs_data_release(data: 'obs_data_t *') -> "void":
    return _obspython.obs_data_release(data)
obs_data_release = _obspython.obs_data_release

def obs_data_get_json(data: 'obs_data_t *') -> "char const *":
    return _obspython.obs_data_get_json(data)
obs_data_get_json = _obspython.obs_data_get_json

def obs_data_save_json(data: 'obs_data_t *', file: 'char const *') -> "bool":
    return _obspython.obs_data_save_json(data, file)
obs_data_save_json = _obspython.obs_data_save_json

def obs_data_save_json_safe(data: 'obs_data_t *', file: 'char const *', temp_ext: 'char const *', backup_ext: 'char const *') -> "bool":
    return _obspython.obs_data_save_json_safe(data, file, temp_ext, backup_ext)
obs_data_save_json_safe = _obspython.obs_data_save_json_safe

def obs_data_apply(target: 'obs_data_t *', apply_data: 'obs_data_t *') -> "void":
    return _obspython.obs_data_apply(target, apply_data)
obs_data_apply = _obspython.obs_data_apply

def obs_data_erase(data: 'obs_data_t *', name: 'char const *') -> "void":
    return _obspython.obs_data_erase(data, name)
obs_data_erase = _obspython.obs_data_erase

def obs_data_clear(data: 'obs_data_t *') -> "void":
    return _obspython.obs_data_clear(data)
obs_data_clear = _obspython.obs_data_clear

def obs_data_set_string(data: 'obs_data_t *', name: 'char const *', val: 'char const *') -> "void":
    return _obspython.obs_data_set_string(data, name, val)
obs_data_set_string = _obspython.obs_data_set_string

def obs_data_set_int(data: 'obs_data_t *', name: 'char const *', val: 'long long') -> "void":
    return _obspython.obs_data_set_int(data, name, val)
obs_data_set_int = _obspython.obs_data_set_int

def obs_data_set_double(data: 'obs_data_t *', name: 'char const *', val: 'double') -> "void":
    return _obspython.obs_data_set_double(data, name, val)
obs_data_set_double = _obspython.obs_data_set_double

def obs_data_set_bool(data: 'obs_data_t *', name: 'char const *', val: 'bool') -> "void":
    return _obspython.obs_data_set_bool(data, name, val)
obs_data_set_bool = _obspython.obs_data_set_bool

def obs_data_set_obj(data: 'obs_data_t *', name: 'char const *', obj: 'obs_data_t *') -> "void":
    return _obspython.obs_data_set_obj(data, name, obj)
obs_data_set_obj = _obspython.obs_data_set_obj

def obs_data_set_array(data: 'obs_data_t *', name: 'char const *', array: 'obs_data_array_t *') -> "void":
    return _obspython.obs_data_set_array(data, name, array)
obs_data_set_array = _obspython.obs_data_set_array

def obs_data_set_default_string(data: 'obs_data_t *', name: 'char const *', val: 'char const *') -> "void":
    return _obspython.obs_data_set_default_string(data, name, val)
obs_data_set_default_string = _obspython.obs_data_set_default_string

def obs_data_set_default_int(data: 'obs_data_t *', name: 'char const *', val: 'long long') -> "void":
    return _obspython.obs_data_set_default_int(data, name, val)
obs_data_set_default_int = _obspython.obs_data_set_default_int

def obs_data_set_default_double(data: 'obs_data_t *', name: 'char const *', val: 'double') -> "void":
    return _obspython.obs_data_set_default_double(data, name, val)
obs_data_set_default_double = _obspython.obs_data_set_default_double

def obs_data_set_default_bool(data: 'obs_data_t *', name: 'char const *', val: 'bool') -> "void":
    return _obspython.obs_data_set_default_bool(data, name, val)
obs_data_set_default_bool = _obspython.obs_data_set_default_bool

def obs_data_set_default_obj(data: 'obs_data_t *', name: 'char const *', obj: 'obs_data_t *') -> "void":
    return _obspython.obs_data_set_default_obj(data, name, obj)
obs_data_set_default_obj = _obspython.obs_data_set_default_obj

def obs_data_set_autoselect_string(data: 'obs_data_t *', name: 'char const *', val: 'char const *') -> "void":
    return _obspython.obs_data_set_autoselect_string(data, name, val)
obs_data_set_autoselect_string = _obspython.obs_data_set_autoselect_string

def obs_data_set_autoselect_int(data: 'obs_data_t *', name: 'char const *', val: 'long long') -> "void":
    return _obspython.obs_data_set_autoselect_int(data, name, val)
obs_data_set_autoselect_int = _obspython.obs_data_set_autoselect_int

def obs_data_set_autoselect_double(data: 'obs_data_t *', name: 'char const *', val: 'double') -> "void":
    return _obspython.obs_data_set_autoselect_double(data, name, val)
obs_data_set_autoselect_double = _obspython.obs_data_set_autoselect_double

def obs_data_set_autoselect_bool(data: 'obs_data_t *', name: 'char const *', val: 'bool') -> "void":
    return _obspython.obs_data_set_autoselect_bool(data, name, val)
obs_data_set_autoselect_bool = _obspython.obs_data_set_autoselect_bool

def obs_data_set_autoselect_obj(data: 'obs_data_t *', name: 'char const *', obj: 'obs_data_t *') -> "void":
    return _obspython.obs_data_set_autoselect_obj(data, name, obj)
obs_data_set_autoselect_obj = _obspython.obs_data_set_autoselect_obj

def obs_data_get_string(data: 'obs_data_t *', name: 'char const *') -> "char const *":
    return _obspython.obs_data_get_string(data, name)
obs_data_get_string = _obspython.obs_data_get_string

def obs_data_get_int(data: 'obs_data_t *', name: 'char const *') -> "long long":
    return _obspython.obs_data_get_int(data, name)
obs_data_get_int = _obspython.obs_data_get_int

def obs_data_get_double(data: 'obs_data_t *', name: 'char const *') -> "double":
    return _obspython.obs_data_get_double(data, name)
obs_data_get_double = _obspython.obs_data_get_double

def obs_data_get_bool(data: 'obs_data_t *', name: 'char const *') -> "bool":
    return _obspython.obs_data_get_bool(data, name)
obs_data_get_bool = _obspython.obs_data_get_bool

def obs_data_get_obj(data: 'obs_data_t *', name: 'char const *') -> "obs_data_t *":
    return _obspython.obs_data_get_obj(data, name)
obs_data_get_obj = _obspython.obs_data_get_obj

def obs_data_get_array(data: 'obs_data_t *', name: 'char const *') -> "obs_data_array_t *":
    return _obspython.obs_data_get_array(data, name)
obs_data_get_array = _obspython.obs_data_get_array

def obs_data_get_default_string(data: 'obs_data_t *', name: 'char const *') -> "char const *":
    return _obspython.obs_data_get_default_string(data, name)
obs_data_get_default_string = _obspython.obs_data_get_default_string

def obs_data_get_default_int(data: 'obs_data_t *', name: 'char const *') -> "long long":
    return _obspython.obs_data_get_default_int(data, name)
obs_data_get_default_int = _obspython.obs_data_get_default_int

def obs_data_get_default_double(data: 'obs_data_t *', name: 'char const *') -> "double":
    return _obspython.obs_data_get_default_double(data, name)
obs_data_get_default_double = _obspython.obs_data_get_default_double

def obs_data_get_default_bool(data: 'obs_data_t *', name: 'char const *') -> "bool":
    return _obspython.obs_data_get_default_bool(data, name)
obs_data_get_default_bool = _obspython.obs_data_get_default_bool

def obs_data_get_default_obj(data: 'obs_data_t *', name: 'char const *') -> "obs_data_t *":
    return _obspython.obs_data_get_default_obj(data, name)
obs_data_get_default_obj = _obspython.obs_data_get_default_obj

def obs_data_get_default_array(data: 'obs_data_t *', name: 'char const *') -> "obs_data_array_t *":
    return _obspython.obs_data_get_default_array(data, name)
obs_data_get_default_array = _obspython.obs_data_get_default_array

def obs_data_get_autoselect_string(data: 'obs_data_t *', name: 'char const *') -> "char const *":
    return _obspython.obs_data_get_autoselect_string(data, name)
obs_data_get_autoselect_string = _obspython.obs_data_get_autoselect_string

def obs_data_get_autoselect_int(data: 'obs_data_t *', name: 'char const *') -> "long long":
    return _obspython.obs_data_get_autoselect_int(data, name)
obs_data_get_autoselect_int = _obspython.obs_data_get_autoselect_int

def obs_data_get_autoselect_double(data: 'obs_data_t *', name: 'char const *') -> "double":
    return _obspython.obs_data_get_autoselect_double(data, name)
obs_data_get_autoselect_double = _obspython.obs_data_get_autoselect_double

def obs_data_get_autoselect_bool(data: 'obs_data_t *', name: 'char const *') -> "bool":
    return _obspython.obs_data_get_autoselect_bool(data, name)
obs_data_get_autoselect_bool = _obspython.obs_data_get_autoselect_bool

def obs_data_get_autoselect_obj(data: 'obs_data_t *', name: 'char const *') -> "obs_data_t *":
    return _obspython.obs_data_get_autoselect_obj(data, name)
obs_data_get_autoselect_obj = _obspython.obs_data_get_autoselect_obj

def obs_data_get_autoselect_array(data: 'obs_data_t *', name: 'char const *') -> "obs_data_array_t *":
    return _obspython.obs_data_get_autoselect_array(data, name)
obs_data_get_autoselect_array = _obspython.obs_data_get_autoselect_array

def obs_data_array_create() -> "obs_data_array_t *":
    return _obspython.obs_data_array_create()
obs_data_array_create = _obspython.obs_data_array_create

def obs_data_array_addref(array: 'obs_data_array_t *') -> "void":
    return _obspython.obs_data_array_addref(array)
obs_data_array_addref = _obspython.obs_data_array_addref

def obs_data_array_release(array: 'obs_data_array_t *') -> "void":
    return _obspython.obs_data_array_release(array)
obs_data_array_release = _obspython.obs_data_array_release

def obs_data_array_count(array: 'obs_data_array_t *') -> "size_t":
    return _obspython.obs_data_array_count(array)
obs_data_array_count = _obspython.obs_data_array_count

def obs_data_array_item(array: 'obs_data_array_t *', idx: 'size_t') -> "obs_data_t *":
    return _obspython.obs_data_array_item(array, idx)
obs_data_array_item = _obspython.obs_data_array_item

def obs_data_array_push_back(array: 'obs_data_array_t *', obj: 'obs_data_t *') -> "size_t":
    return _obspython.obs_data_array_push_back(array, obj)
obs_data_array_push_back = _obspython.obs_data_array_push_back

def obs_data_array_insert(array: 'obs_data_array_t *', idx: 'size_t', obj: 'obs_data_t *') -> "void":
    return _obspython.obs_data_array_insert(array, idx, obj)
obs_data_array_insert = _obspython.obs_data_array_insert

def obs_data_array_push_back_array(array: 'obs_data_array_t *', array2: 'obs_data_array_t *') -> "void":
    return _obspython.obs_data_array_push_back_array(array, array2)
obs_data_array_push_back_array = _obspython.obs_data_array_push_back_array

def obs_data_array_erase(array: 'obs_data_array_t *', idx: 'size_t') -> "void":
    return _obspython.obs_data_array_erase(array, idx)
obs_data_array_erase = _obspython.obs_data_array_erase

def obs_data_has_user_value(data: 'obs_data_t *', name: 'char const *') -> "bool":
    return _obspython.obs_data_has_user_value(data, name)
obs_data_has_user_value = _obspython.obs_data_has_user_value

def obs_data_has_default_value(data: 'obs_data_t *', name: 'char const *') -> "bool":
    return _obspython.obs_data_has_default_value(data, name)
obs_data_has_default_value = _obspython.obs_data_has_default_value

def obs_data_has_autoselect_value(data: 'obs_data_t *', name: 'char const *') -> "bool":
    return _obspython.obs_data_has_autoselect_value(data, name)
obs_data_has_autoselect_value = _obspython.obs_data_has_autoselect_value

def obs_data_item_has_user_value(data: 'obs_data_item_t *') -> "bool":
    return _obspython.obs_data_item_has_user_value(data)
obs_data_item_has_user_value = _obspython.obs_data_item_has_user_value

def obs_data_item_has_default_value(data: 'obs_data_item_t *') -> "bool":
    return _obspython.obs_data_item_has_default_value(data)
obs_data_item_has_default_value = _obspython.obs_data_item_has_default_value

def obs_data_item_has_autoselect_value(data: 'obs_data_item_t *') -> "bool":
    return _obspython.obs_data_item_has_autoselect_value(data)
obs_data_item_has_autoselect_value = _obspython.obs_data_item_has_autoselect_value

def obs_data_unset_user_value(data: 'obs_data_t *', name: 'char const *') -> "void":
    return _obspython.obs_data_unset_user_value(data, name)
obs_data_unset_user_value = _obspython.obs_data_unset_user_value

def obs_data_unset_default_value(data: 'obs_data_t *', name: 'char const *') -> "void":
    return _obspython.obs_data_unset_default_value(data, name)
obs_data_unset_default_value = _obspython.obs_data_unset_default_value

def obs_data_unset_autoselect_value(data: 'obs_data_t *', name: 'char const *') -> "void":
    return _obspython.obs_data_unset_autoselect_value(data, name)
obs_data_unset_autoselect_value = _obspython.obs_data_unset_autoselect_value

def obs_data_item_unset_user_value(data: 'obs_data_item_t *') -> "void":
    return _obspython.obs_data_item_unset_user_value(data)
obs_data_item_unset_user_value = _obspython.obs_data_item_unset_user_value

def obs_data_item_unset_default_value(data: 'obs_data_item_t *') -> "void":
    return _obspython.obs_data_item_unset_default_value(data)
obs_data_item_unset_default_value = _obspython.obs_data_item_unset_default_value

def obs_data_item_unset_autoselect_value(data: 'obs_data_item_t *') -> "void":
    return _obspython.obs_data_item_unset_autoselect_value(data)
obs_data_item_unset_autoselect_value = _obspython.obs_data_item_unset_autoselect_value

def obs_data_first(data: 'obs_data_t *') -> "obs_data_item_t *":
    return _obspython.obs_data_first(data)
obs_data_first = _obspython.obs_data_first

def obs_data_item_byname(data: 'obs_data_t *', name: 'char const *') -> "obs_data_item_t *":
    return _obspython.obs_data_item_byname(data, name)
obs_data_item_byname = _obspython.obs_data_item_byname

def obs_data_item_next(item: 'obs_data_item_t **') -> "bool":
    return _obspython.obs_data_item_next(item)
obs_data_item_next = _obspython.obs_data_item_next

def obs_data_item_release(item: 'obs_data_item_t **') -> "void":
    return _obspython.obs_data_item_release(item)
obs_data_item_release = _obspython.obs_data_item_release

def obs_data_item_remove(item: 'obs_data_item_t **') -> "void":
    return _obspython.obs_data_item_remove(item)
obs_data_item_remove = _obspython.obs_data_item_remove

def obs_data_item_gettype(item: 'obs_data_item_t *') -> "enum obs_data_type":
    return _obspython.obs_data_item_gettype(item)
obs_data_item_gettype = _obspython.obs_data_item_gettype

def obs_data_item_numtype(item: 'obs_data_item_t *') -> "enum obs_data_number_type":
    return _obspython.obs_data_item_numtype(item)
obs_data_item_numtype = _obspython.obs_data_item_numtype

def obs_data_item_get_name(item: 'obs_data_item_t *') -> "char const *":
    return _obspython.obs_data_item_get_name(item)
obs_data_item_get_name = _obspython.obs_data_item_get_name

def obs_data_item_set_string(item: 'obs_data_item_t **', val: 'char const *') -> "void":
    return _obspython.obs_data_item_set_string(item, val)
obs_data_item_set_string = _obspython.obs_data_item_set_string

def obs_data_item_set_int(item: 'obs_data_item_t **', val: 'long long') -> "void":
    return _obspython.obs_data_item_set_int(item, val)
obs_data_item_set_int = _obspython.obs_data_item_set_int

def obs_data_item_set_double(item: 'obs_data_item_t **', val: 'double') -> "void":
    return _obspython.obs_data_item_set_double(item, val)
obs_data_item_set_double = _obspython.obs_data_item_set_double

def obs_data_item_set_bool(item: 'obs_data_item_t **', val: 'bool') -> "void":
    return _obspython.obs_data_item_set_bool(item, val)
obs_data_item_set_bool = _obspython.obs_data_item_set_bool

def obs_data_item_set_obj(item: 'obs_data_item_t **', val: 'obs_data_t *') -> "void":
    return _obspython.obs_data_item_set_obj(item, val)
obs_data_item_set_obj = _obspython.obs_data_item_set_obj

def obs_data_item_set_array(item: 'obs_data_item_t **', val: 'obs_data_array_t *') -> "void":
    return _obspython.obs_data_item_set_array(item, val)
obs_data_item_set_array = _obspython.obs_data_item_set_array

def obs_data_item_set_default_string(item: 'obs_data_item_t **', val: 'char const *') -> "void":
    return _obspython.obs_data_item_set_default_string(item, val)
obs_data_item_set_default_string = _obspython.obs_data_item_set_default_string

def obs_data_item_set_default_int(item: 'obs_data_item_t **', val: 'long long') -> "void":
    return _obspython.obs_data_item_set_default_int(item, val)
obs_data_item_set_default_int = _obspython.obs_data_item_set_default_int

def obs_data_item_set_default_double(item: 'obs_data_item_t **', val: 'double') -> "void":
    return _obspython.obs_data_item_set_default_double(item, val)
obs_data_item_set_default_double = _obspython.obs_data_item_set_default_double

def obs_data_item_set_default_bool(item: 'obs_data_item_t **', val: 'bool') -> "void":
    return _obspython.obs_data_item_set_default_bool(item, val)
obs_data_item_set_default_bool = _obspython.obs_data_item_set_default_bool

def obs_data_item_set_default_obj(item: 'obs_data_item_t **', val: 'obs_data_t *') -> "void":
    return _obspython.obs_data_item_set_default_obj(item, val)
obs_data_item_set_default_obj = _obspython.obs_data_item_set_default_obj

def obs_data_item_set_default_array(item: 'obs_data_item_t **', val: 'obs_data_array_t *') -> "void":
    return _obspython.obs_data_item_set_default_array(item, val)
obs_data_item_set_default_array = _obspython.obs_data_item_set_default_array

def obs_data_item_set_autoselect_string(item: 'obs_data_item_t **', val: 'char const *') -> "void":
    return _obspython.obs_data_item_set_autoselect_string(item, val)
obs_data_item_set_autoselect_string = _obspython.obs_data_item_set_autoselect_string

def obs_data_item_set_autoselect_int(item: 'obs_data_item_t **', val: 'long long') -> "void":
    return _obspython.obs_data_item_set_autoselect_int(item, val)
obs_data_item_set_autoselect_int = _obspython.obs_data_item_set_autoselect_int

def obs_data_item_set_autoselect_double(item: 'obs_data_item_t **', val: 'double') -> "void":
    return _obspython.obs_data_item_set_autoselect_double(item, val)
obs_data_item_set_autoselect_double = _obspython.obs_data_item_set_autoselect_double

def obs_data_item_set_autoselect_bool(item: 'obs_data_item_t **', val: 'bool') -> "void":
    return _obspython.obs_data_item_set_autoselect_bool(item, val)
obs_data_item_set_autoselect_bool = _obspython.obs_data_item_set_autoselect_bool

def obs_data_item_set_autoselect_obj(item: 'obs_data_item_t **', val: 'obs_data_t *') -> "void":
    return _obspython.obs_data_item_set_autoselect_obj(item, val)
obs_data_item_set_autoselect_obj = _obspython.obs_data_item_set_autoselect_obj

def obs_data_item_set_autoselect_array(item: 'obs_data_item_t **', val: 'obs_data_array_t *') -> "void":
    return _obspython.obs_data_item_set_autoselect_array(item, val)
obs_data_item_set_autoselect_array = _obspython.obs_data_item_set_autoselect_array

def obs_data_item_get_string(item: 'obs_data_item_t *') -> "char const *":
    return _obspython.obs_data_item_get_string(item)
obs_data_item_get_string = _obspython.obs_data_item_get_string

def obs_data_item_get_int(item: 'obs_data_item_t *') -> "long long":
    return _obspython.obs_data_item_get_int(item)
obs_data_item_get_int = _obspython.obs_data_item_get_int

def obs_data_item_get_double(item: 'obs_data_item_t *') -> "double":
    return _obspython.obs_data_item_get_double(item)
obs_data_item_get_double = _obspython.obs_data_item_get_double

def obs_data_item_get_bool(item: 'obs_data_item_t *') -> "bool":
    return _obspython.obs_data_item_get_bool(item)
obs_data_item_get_bool = _obspython.obs_data_item_get_bool

def obs_data_item_get_obj(item: 'obs_data_item_t *') -> "obs_data_t *":
    return _obspython.obs_data_item_get_obj(item)
obs_data_item_get_obj = _obspython.obs_data_item_get_obj

def obs_data_item_get_array(item: 'obs_data_item_t *') -> "obs_data_array_t *":
    return _obspython.obs_data_item_get_array(item)
obs_data_item_get_array = _obspython.obs_data_item_get_array

def obs_data_item_get_default_string(item: 'obs_data_item_t *') -> "char const *":
    return _obspython.obs_data_item_get_default_string(item)
obs_data_item_get_default_string = _obspython.obs_data_item_get_default_string

def obs_data_item_get_default_int(item: 'obs_data_item_t *') -> "long long":
    return _obspython.obs_data_item_get_default_int(item)
obs_data_item_get_default_int = _obspython.obs_data_item_get_default_int

def obs_data_item_get_default_double(item: 'obs_data_item_t *') -> "double":
    return _obspython.obs_data_item_get_default_double(item)
obs_data_item_get_default_double = _obspython.obs_data_item_get_default_double

def obs_data_item_get_default_bool(item: 'obs_data_item_t *') -> "bool":
    return _obspython.obs_data_item_get_default_bool(item)
obs_data_item_get_default_bool = _obspython.obs_data_item_get_default_bool

def obs_data_item_get_default_obj(item: 'obs_data_item_t *') -> "obs_data_t *":
    return _obspython.obs_data_item_get_default_obj(item)
obs_data_item_get_default_obj = _obspython.obs_data_item_get_default_obj

def obs_data_item_get_default_array(item: 'obs_data_item_t *') -> "obs_data_array_t *":
    return _obspython.obs_data_item_get_default_array(item)
obs_data_item_get_default_array = _obspython.obs_data_item_get_default_array

def obs_data_item_get_autoselect_string(item: 'obs_data_item_t *') -> "char const *":
    return _obspython.obs_data_item_get_autoselect_string(item)
obs_data_item_get_autoselect_string = _obspython.obs_data_item_get_autoselect_string

def obs_data_item_get_autoselect_int(item: 'obs_data_item_t *') -> "long long":
    return _obspython.obs_data_item_get_autoselect_int(item)
obs_data_item_get_autoselect_int = _obspython.obs_data_item_get_autoselect_int

def obs_data_item_get_autoselect_double(item: 'obs_data_item_t *') -> "double":
    return _obspython.obs_data_item_get_autoselect_double(item)
obs_data_item_get_autoselect_double = _obspython.obs_data_item_get_autoselect_double

def obs_data_item_get_autoselect_bool(item: 'obs_data_item_t *') -> "bool":
    return _obspython.obs_data_item_get_autoselect_bool(item)
obs_data_item_get_autoselect_bool = _obspython.obs_data_item_get_autoselect_bool

def obs_data_item_get_autoselect_obj(item: 'obs_data_item_t *') -> "obs_data_t *":
    return _obspython.obs_data_item_get_autoselect_obj(item)
obs_data_item_get_autoselect_obj = _obspython.obs_data_item_get_autoselect_obj

def obs_data_item_get_autoselect_array(item: 'obs_data_item_t *') -> "obs_data_array_t *":
    return _obspython.obs_data_item_get_autoselect_array(item)
obs_data_item_get_autoselect_array = _obspython.obs_data_item_get_autoselect_array

def obs_data_set_vec2(data: 'obs_data_t *', name: 'char const *', val: 'vec2') -> "void":
    return _obspython.obs_data_set_vec2(data, name, val)
obs_data_set_vec2 = _obspython.obs_data_set_vec2

def obs_data_set_vec3(data: 'obs_data_t *', name: 'char const *', val: 'vec3') -> "void":
    return _obspython.obs_data_set_vec3(data, name, val)
obs_data_set_vec3 = _obspython.obs_data_set_vec3

def obs_data_set_vec4(data: 'obs_data_t *', name: 'char const *', val: 'vec4') -> "void":
    return _obspython.obs_data_set_vec4(data, name, val)
obs_data_set_vec4 = _obspython.obs_data_set_vec4

def obs_data_set_quat(data: 'obs_data_t *', name: 'char const *', val: 'quat') -> "void":
    return _obspython.obs_data_set_quat(data, name, val)
obs_data_set_quat = _obspython.obs_data_set_quat

def obs_data_set_default_vec2(data: 'obs_data_t *', name: 'char const *', val: 'vec2') -> "void":
    return _obspython.obs_data_set_default_vec2(data, name, val)
obs_data_set_default_vec2 = _obspython.obs_data_set_default_vec2

def obs_data_set_default_vec3(data: 'obs_data_t *', name: 'char const *', val: 'vec3') -> "void":
    return _obspython.obs_data_set_default_vec3(data, name, val)
obs_data_set_default_vec3 = _obspython.obs_data_set_default_vec3

def obs_data_set_default_vec4(data: 'obs_data_t *', name: 'char const *', val: 'vec4') -> "void":
    return _obspython.obs_data_set_default_vec4(data, name, val)
obs_data_set_default_vec4 = _obspython.obs_data_set_default_vec4

def obs_data_set_default_quat(data: 'obs_data_t *', name: 'char const *', val: 'quat') -> "void":
    return _obspython.obs_data_set_default_quat(data, name, val)
obs_data_set_default_quat = _obspython.obs_data_set_default_quat

def obs_data_set_autoselect_vec2(data: 'obs_data_t *', name: 'char const *', val: 'vec2') -> "void":
    return _obspython.obs_data_set_autoselect_vec2(data, name, val)
obs_data_set_autoselect_vec2 = _obspython.obs_data_set_autoselect_vec2

def obs_data_set_autoselect_vec3(data: 'obs_data_t *', name: 'char const *', val: 'vec3') -> "void":
    return _obspython.obs_data_set_autoselect_vec3(data, name, val)
obs_data_set_autoselect_vec3 = _obspython.obs_data_set_autoselect_vec3

def obs_data_set_autoselect_vec4(data: 'obs_data_t *', name: 'char const *', val: 'vec4') -> "void":
    return _obspython.obs_data_set_autoselect_vec4(data, name, val)
obs_data_set_autoselect_vec4 = _obspython.obs_data_set_autoselect_vec4

def obs_data_set_autoselect_quat(data: 'obs_data_t *', name: 'char const *', val: 'quat') -> "void":
    return _obspython.obs_data_set_autoselect_quat(data, name, val)
obs_data_set_autoselect_quat = _obspython.obs_data_set_autoselect_quat

def obs_data_get_vec2(data: 'obs_data_t *', name: 'char const *', val: 'vec2') -> "void":
    return _obspython.obs_data_get_vec2(data, name, val)
obs_data_get_vec2 = _obspython.obs_data_get_vec2

def obs_data_get_vec3(data: 'obs_data_t *', name: 'char const *', val: 'vec3') -> "void":
    return _obspython.obs_data_get_vec3(data, name, val)
obs_data_get_vec3 = _obspython.obs_data_get_vec3

def obs_data_get_vec4(data: 'obs_data_t *', name: 'char const *', val: 'vec4') -> "void":
    return _obspython.obs_data_get_vec4(data, name, val)
obs_data_get_vec4 = _obspython.obs_data_get_vec4

def obs_data_get_quat(data: 'obs_data_t *', name: 'char const *', val: 'quat') -> "void":
    return _obspython.obs_data_get_quat(data, name, val)
obs_data_get_quat = _obspython.obs_data_get_quat

def obs_data_get_default_vec2(data: 'obs_data_t *', name: 'char const *', val: 'vec2') -> "void":
    return _obspython.obs_data_get_default_vec2(data, name, val)
obs_data_get_default_vec2 = _obspython.obs_data_get_default_vec2

def obs_data_get_default_vec3(data: 'obs_data_t *', name: 'char const *', val: 'vec3') -> "void":
    return _obspython.obs_data_get_default_vec3(data, name, val)
obs_data_get_default_vec3 = _obspython.obs_data_get_default_vec3

def obs_data_get_default_vec4(data: 'obs_data_t *', name: 'char const *', val: 'vec4') -> "void":
    return _obspython.obs_data_get_default_vec4(data, name, val)
obs_data_get_default_vec4 = _obspython.obs_data_get_default_vec4

def obs_data_get_default_quat(data: 'obs_data_t *', name: 'char const *', val: 'quat') -> "void":
    return _obspython.obs_data_get_default_quat(data, name, val)
obs_data_get_default_quat = _obspython.obs_data_get_default_quat

def obs_data_get_autoselect_vec2(data: 'obs_data_t *', name: 'char const *', val: 'vec2') -> "void":
    return _obspython.obs_data_get_autoselect_vec2(data, name, val)
obs_data_get_autoselect_vec2 = _obspython.obs_data_get_autoselect_vec2

def obs_data_get_autoselect_vec3(data: 'obs_data_t *', name: 'char const *', val: 'vec3') -> "void":
    return _obspython.obs_data_get_autoselect_vec3(data, name, val)
obs_data_get_autoselect_vec3 = _obspython.obs_data_get_autoselect_vec3

def obs_data_get_autoselect_vec4(data: 'obs_data_t *', name: 'char const *', val: 'vec4') -> "void":
    return _obspython.obs_data_get_autoselect_vec4(data, name, val)
obs_data_get_autoselect_vec4 = _obspython.obs_data_get_autoselect_vec4

def obs_data_get_autoselect_quat(data: 'obs_data_t *', name: 'char const *', val: 'quat') -> "void":
    return _obspython.obs_data_get_autoselect_quat(data, name, val)
obs_data_get_autoselect_quat = _obspython.obs_data_get_autoselect_quat

def obs_data_set_frames_per_second(data: 'obs_data_t *', name: 'char const *', fps: 'struct media_frames_per_second', option: 'char const *') -> "void":
    return _obspython.obs_data_set_frames_per_second(data, name, fps, option)
obs_data_set_frames_per_second = _obspython.obs_data_set_frames_per_second

def obs_data_set_default_frames_per_second(data: 'obs_data_t *', name: 'char const *', fps: 'struct media_frames_per_second', option: 'char const *') -> "void":
    return _obspython.obs_data_set_default_frames_per_second(data, name, fps, option)
obs_data_set_default_frames_per_second = _obspython.obs_data_set_default_frames_per_second

def obs_data_set_autoselect_frames_per_second(data: 'obs_data_t *', name: 'char const *', fps: 'struct media_frames_per_second', option: 'char const *') -> "void":
    return _obspython.obs_data_set_autoselect_frames_per_second(data, name, fps, option)
obs_data_set_autoselect_frames_per_second = _obspython.obs_data_set_autoselect_frames_per_second

def obs_data_get_frames_per_second(data: 'obs_data_t *', name: 'char const *', fps: 'struct media_frames_per_second *', option: 'char const **') -> "bool":
    return _obspython.obs_data_get_frames_per_second(data, name, fps, option)
obs_data_get_frames_per_second = _obspython.obs_data_get_frames_per_second

def obs_data_get_default_frames_per_second(data: 'obs_data_t *', name: 'char const *', fps: 'struct media_frames_per_second *', option: 'char const **') -> "bool":
    return _obspython.obs_data_get_default_frames_per_second(data, name, fps, option)
obs_data_get_default_frames_per_second = _obspython.obs_data_get_default_frames_per_second

def obs_data_get_autoselect_frames_per_second(data: 'obs_data_t *', name: 'char const *', fps: 'struct media_frames_per_second *', option: 'char const **') -> "bool":
    return _obspython.obs_data_get_autoselect_frames_per_second(data, name, fps, option)
obs_data_get_autoselect_frames_per_second = _obspython.obs_data_get_autoselect_frames_per_second

def obs_data_item_set_frames_per_second(item: 'obs_data_item_t **', fps: 'struct media_frames_per_second', option: 'char const *') -> "void":
    return _obspython.obs_data_item_set_frames_per_second(item, fps, option)
obs_data_item_set_frames_per_second = _obspython.obs_data_item_set_frames_per_second

def obs_data_item_set_default_frames_per_second(item: 'obs_data_item_t **', fps: 'struct media_frames_per_second', option: 'char const *') -> "void":
    return _obspython.obs_data_item_set_default_frames_per_second(item, fps, option)
obs_data_item_set_default_frames_per_second = _obspython.obs_data_item_set_default_frames_per_second

def obs_data_item_set_autoselect_frames_per_second(item: 'obs_data_item_t **', fps: 'struct media_frames_per_second', option: 'char const *') -> "void":
    return _obspython.obs_data_item_set_autoselect_frames_per_second(item, fps, option)
obs_data_item_set_autoselect_frames_per_second = _obspython.obs_data_item_set_autoselect_frames_per_second

def obs_data_item_get_frames_per_second(item: 'obs_data_item_t *', fps: 'struct media_frames_per_second *', option: 'char const **') -> "bool":
    return _obspython.obs_data_item_get_frames_per_second(item, fps, option)
obs_data_item_get_frames_per_second = _obspython.obs_data_item_get_frames_per_second

def obs_data_item_get_default_frames_per_second(item: 'obs_data_item_t *', fps: 'struct media_frames_per_second *', option: 'char const **') -> "bool":
    return _obspython.obs_data_item_get_default_frames_per_second(item, fps, option)
obs_data_item_get_default_frames_per_second = _obspython.obs_data_item_get_default_frames_per_second

def obs_data_item_get_autoselect_frames_per_second(item: 'obs_data_item_t *', fps: 'struct media_frames_per_second *', option: 'char const **') -> "bool":
    return _obspython.obs_data_item_get_autoselect_frames_per_second(item, fps, option)
obs_data_item_get_autoselect_frames_per_second = _obspython.obs_data_item_get_autoselect_frames_per_second

def obs_data_newref(data: 'obs_data_t *') -> "obs_data_t *":
    return _obspython.obs_data_newref(data)
obs_data_newref = _obspython.obs_data_newref
OBS_SOURCE_TYPE_INPUT = _obspython.OBS_SOURCE_TYPE_INPUT
OBS_SOURCE_TYPE_FILTER = _obspython.OBS_SOURCE_TYPE_FILTER
OBS_SOURCE_TYPE_TRANSITION = _obspython.OBS_SOURCE_TYPE_TRANSITION
OBS_SOURCE_TYPE_SCENE = _obspython.OBS_SOURCE_TYPE_SCENE
OBS_BALANCE_TYPE_SINE_LAW = _obspython.OBS_BALANCE_TYPE_SINE_LAW
OBS_BALANCE_TYPE_SQUARE_LAW = _obspython.OBS_BALANCE_TYPE_SQUARE_LAW
OBS_BALANCE_TYPE_LINEAR = _obspython.OBS_BALANCE_TYPE_LINEAR
OBS_SOURCE_VIDEO = _obspython.OBS_SOURCE_VIDEO
OBS_SOURCE_AUDIO = _obspython.OBS_SOURCE_AUDIO
OBS_SOURCE_ASYNC = _obspython.OBS_SOURCE_ASYNC
OBS_SOURCE_ASYNC_VIDEO = _obspython.OBS_SOURCE_ASYNC_VIDEO
OBS_SOURCE_CUSTOM_DRAW = _obspython.OBS_SOURCE_CUSTOM_DRAW
OBS_SOURCE_INTERACTION = _obspython.OBS_SOURCE_INTERACTION
OBS_SOURCE_COMPOSITE = _obspython.OBS_SOURCE_COMPOSITE
OBS_SOURCE_DO_NOT_DUPLICATE = _obspython.OBS_SOURCE_DO_NOT_DUPLICATE
OBS_SOURCE_DEPRECATED = _obspython.OBS_SOURCE_DEPRECATED
OBS_SOURCE_DO_NOT_SELF_MONITOR = _obspython.OBS_SOURCE_DO_NOT_SELF_MONITOR
OBS_SOURCE_CAP_DISABLED = _obspython.OBS_SOURCE_CAP_DISABLED
class obs_source_audio_mix(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_source_audio_mix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_source_audio_mix, name)
    __repr__ = _swig_repr
    __swig_setmethods__["output"] = _obspython.obs_source_audio_mix_output_set
    __swig_getmethods__["output"] = _obspython.obs_source_audio_mix_output_get
    if _newclass:
        output = _swig_property(_obspython.obs_source_audio_mix_output_get, _obspython.obs_source_audio_mix_output_set)

    def __init__(self):
        this = _obspython.new_obs_source_audio_mix()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_source_audio_mix
    __del__ = lambda self: None
obs_source_audio_mix_swigregister = _obspython.obs_source_audio_mix_swigregister
obs_source_audio_mix_swigregister(obs_source_audio_mix)

OBS_PROPERTIES_DEFER_UPDATE = _obspython.OBS_PROPERTIES_DEFER_UPDATE
OBS_PROPERTY_INVALID = _obspython.OBS_PROPERTY_INVALID
OBS_PROPERTY_BOOL = _obspython.OBS_PROPERTY_BOOL
OBS_PROPERTY_INT = _obspython.OBS_PROPERTY_INT
OBS_PROPERTY_FLOAT = _obspython.OBS_PROPERTY_FLOAT
OBS_PROPERTY_TEXT = _obspython.OBS_PROPERTY_TEXT
OBS_PROPERTY_PATH = _obspython.OBS_PROPERTY_PATH
OBS_PROPERTY_LIST = _obspython.OBS_PROPERTY_LIST
OBS_PROPERTY_COLOR = _obspython.OBS_PROPERTY_COLOR
OBS_PROPERTY_BUTTON = _obspython.OBS_PROPERTY_BUTTON
OBS_PROPERTY_FONT = _obspython.OBS_PROPERTY_FONT
OBS_PROPERTY_EDITABLE_LIST = _obspython.OBS_PROPERTY_EDITABLE_LIST
OBS_PROPERTY_FRAME_RATE = _obspython.OBS_PROPERTY_FRAME_RATE
OBS_COMBO_FORMAT_INVALID = _obspython.OBS_COMBO_FORMAT_INVALID
OBS_COMBO_FORMAT_INT = _obspython.OBS_COMBO_FORMAT_INT
OBS_COMBO_FORMAT_FLOAT = _obspython.OBS_COMBO_FORMAT_FLOAT
OBS_COMBO_FORMAT_STRING = _obspython.OBS_COMBO_FORMAT_STRING
OBS_COMBO_TYPE_INVALID = _obspython.OBS_COMBO_TYPE_INVALID
OBS_COMBO_TYPE_EDITABLE = _obspython.OBS_COMBO_TYPE_EDITABLE
OBS_COMBO_TYPE_LIST = _obspython.OBS_COMBO_TYPE_LIST
OBS_EDITABLE_LIST_TYPE_STRINGS = _obspython.OBS_EDITABLE_LIST_TYPE_STRINGS
OBS_EDITABLE_LIST_TYPE_FILES = _obspython.OBS_EDITABLE_LIST_TYPE_FILES
OBS_EDITABLE_LIST_TYPE_FILES_AND_URLS = _obspython.OBS_EDITABLE_LIST_TYPE_FILES_AND_URLS
OBS_PATH_FILE = _obspython.OBS_PATH_FILE
OBS_PATH_FILE_SAVE = _obspython.OBS_PATH_FILE_SAVE
OBS_PATH_DIRECTORY = _obspython.OBS_PATH_DIRECTORY
OBS_TEXT_DEFAULT = _obspython.OBS_TEXT_DEFAULT
OBS_TEXT_PASSWORD = _obspython.OBS_TEXT_PASSWORD
OBS_TEXT_MULTILINE = _obspython.OBS_TEXT_MULTILINE
OBS_NUMBER_SCROLLER = _obspython.OBS_NUMBER_SCROLLER
OBS_NUMBER_SLIDER = _obspython.OBS_NUMBER_SLIDER
OBS_FONT_BOLD = _obspython.OBS_FONT_BOLD
OBS_FONT_ITALIC = _obspython.OBS_FONT_ITALIC
OBS_FONT_UNDERLINE = _obspython.OBS_FONT_UNDERLINE
OBS_FONT_STRIKEOUT = _obspython.OBS_FONT_STRIKEOUT

def obs_properties_create() -> "obs_properties_t *":
    return _obspython.obs_properties_create()
obs_properties_create = _obspython.obs_properties_create

def obs_properties_create_param(param: 'void *', destroy: 'void (*)(void *)') -> "obs_properties_t *":
    return _obspython.obs_properties_create_param(param, destroy)
obs_properties_create_param = _obspython.obs_properties_create_param

def obs_properties_destroy(props: 'obs_properties_t *') -> "void":
    return _obspython.obs_properties_destroy(props)
obs_properties_destroy = _obspython.obs_properties_destroy

def obs_properties_set_flags(props: 'obs_properties_t *', flags: 'uint32_t') -> "void":
    return _obspython.obs_properties_set_flags(props, flags)
obs_properties_set_flags = _obspython.obs_properties_set_flags

def obs_properties_get_flags(props: 'obs_properties_t *') -> "uint32_t":
    return _obspython.obs_properties_get_flags(props)
obs_properties_get_flags = _obspython.obs_properties_get_flags

def obs_properties_set_param(props: 'obs_properties_t *', param: 'void *', destroy: 'void (*)(void *)') -> "void":
    return _obspython.obs_properties_set_param(props, param, destroy)
obs_properties_set_param = _obspython.obs_properties_set_param

def obs_properties_get_param(props: 'obs_properties_t *') -> "void *":
    return _obspython.obs_properties_get_param(props)
obs_properties_get_param = _obspython.obs_properties_get_param

def obs_properties_first(props: 'obs_properties_t *') -> "obs_property_t *":
    return _obspython.obs_properties_first(props)
obs_properties_first = _obspython.obs_properties_first

def obs_properties_get(props: 'obs_properties_t *', property: 'char const *') -> "obs_property_t *":
    return _obspython.obs_properties_get(props, property)
obs_properties_get = _obspython.obs_properties_get

def obs_properties_apply_settings(props: 'obs_properties_t *', settings: 'obs_data_t *') -> "void":
    return _obspython.obs_properties_apply_settings(props, settings)
obs_properties_apply_settings = _obspython.obs_properties_apply_settings

def obs_properties_add_bool(props: 'obs_properties_t *', name: 'char const *', description: 'char const *') -> "obs_property_t *":
    return _obspython.obs_properties_add_bool(props, name, description)
obs_properties_add_bool = _obspython.obs_properties_add_bool

def obs_properties_add_int(props: 'obs_properties_t *', name: 'char const *', description: 'char const *', min: 'int', max: 'int', step: 'int') -> "obs_property_t *":
    return _obspython.obs_properties_add_int(props, name, description, min, max, step)
obs_properties_add_int = _obspython.obs_properties_add_int

def obs_properties_add_float(props: 'obs_properties_t *', name: 'char const *', description: 'char const *', min: 'double', max: 'double', step: 'double') -> "obs_property_t *":
    return _obspython.obs_properties_add_float(props, name, description, min, max, step)
obs_properties_add_float = _obspython.obs_properties_add_float

def obs_properties_add_int_slider(props: 'obs_properties_t *', name: 'char const *', description: 'char const *', min: 'int', max: 'int', step: 'int') -> "obs_property_t *":
    return _obspython.obs_properties_add_int_slider(props, name, description, min, max, step)
obs_properties_add_int_slider = _obspython.obs_properties_add_int_slider

def obs_properties_add_float_slider(props: 'obs_properties_t *', name: 'char const *', description: 'char const *', min: 'double', max: 'double', step: 'double') -> "obs_property_t *":
    return _obspython.obs_properties_add_float_slider(props, name, description, min, max, step)
obs_properties_add_float_slider = _obspython.obs_properties_add_float_slider

def obs_properties_add_text(props: 'obs_properties_t *', name: 'char const *', description: 'char const *', type: 'enum obs_text_type') -> "obs_property_t *":
    return _obspython.obs_properties_add_text(props, name, description, type)
obs_properties_add_text = _obspython.obs_properties_add_text

def obs_properties_add_path(props: 'obs_properties_t *', name: 'char const *', description: 'char const *', type: 'enum obs_path_type', filter: 'char const *', default_path: 'char const *') -> "obs_property_t *":
    return _obspython.obs_properties_add_path(props, name, description, type, filter, default_path)
obs_properties_add_path = _obspython.obs_properties_add_path

def obs_properties_add_list(props: 'obs_properties_t *', name: 'char const *', description: 'char const *', type: 'enum obs_combo_type', format: 'enum obs_combo_format') -> "obs_property_t *":
    return _obspython.obs_properties_add_list(props, name, description, type, format)
obs_properties_add_list = _obspython.obs_properties_add_list

def obs_properties_add_color(props: 'obs_properties_t *', name: 'char const *', description: 'char const *') -> "obs_property_t *":
    return _obspython.obs_properties_add_color(props, name, description)
obs_properties_add_color = _obspython.obs_properties_add_color

def obs_properties_add_button2(props: 'obs_properties_t *', name: 'char const *', text: 'char const *', callback: 'obs_property_clicked_t', priv: 'void *') -> "obs_property_t *":
    return _obspython.obs_properties_add_button2(props, name, text, callback, priv)
obs_properties_add_button2 = _obspython.obs_properties_add_button2

def obs_properties_add_font(props: 'obs_properties_t *', name: 'char const *', description: 'char const *') -> "obs_property_t *":
    return _obspython.obs_properties_add_font(props, name, description)
obs_properties_add_font = _obspython.obs_properties_add_font

def obs_properties_add_editable_list(props: 'obs_properties_t *', name: 'char const *', description: 'char const *', type: 'enum obs_editable_list_type', filter: 'char const *', default_path: 'char const *') -> "obs_property_t *":
    return _obspython.obs_properties_add_editable_list(props, name, description, type, filter, default_path)
obs_properties_add_editable_list = _obspython.obs_properties_add_editable_list

def obs_properties_add_frame_rate(props: 'obs_properties_t *', name: 'char const *', description: 'char const *') -> "obs_property_t *":
    return _obspython.obs_properties_add_frame_rate(props, name, description)
obs_properties_add_frame_rate = _obspython.obs_properties_add_frame_rate

def obs_property_set_modified_callback2(p: 'obs_property_t *', modified: 'obs_property_modified2_t', priv: 'void *') -> "void":
    return _obspython.obs_property_set_modified_callback2(p, modified, priv)
obs_property_set_modified_callback2 = _obspython.obs_property_set_modified_callback2

def obs_property_modified(p: 'obs_property_t *', settings: 'obs_data_t *') -> "bool":
    return _obspython.obs_property_modified(p, settings)
obs_property_modified = _obspython.obs_property_modified

def obs_property_button_clicked(p: 'obs_property_t *', obj: 'void *') -> "bool":
    return _obspython.obs_property_button_clicked(p, obj)
obs_property_button_clicked = _obspython.obs_property_button_clicked

def obs_property_set_visible(p: 'obs_property_t *', visible: 'bool') -> "void":
    return _obspython.obs_property_set_visible(p, visible)
obs_property_set_visible = _obspython.obs_property_set_visible

def obs_property_set_enabled(p: 'obs_property_t *', enabled: 'bool') -> "void":
    return _obspython.obs_property_set_enabled(p, enabled)
obs_property_set_enabled = _obspython.obs_property_set_enabled

def obs_property_set_description(p: 'obs_property_t *', description: 'char const *') -> "void":
    return _obspython.obs_property_set_description(p, description)
obs_property_set_description = _obspython.obs_property_set_description

def obs_property_set_long_description(p: 'obs_property_t *', long_description: 'char const *') -> "void":
    return _obspython.obs_property_set_long_description(p, long_description)
obs_property_set_long_description = _obspython.obs_property_set_long_description

def obs_property_name(p: 'obs_property_t *') -> "char const *":
    return _obspython.obs_property_name(p)
obs_property_name = _obspython.obs_property_name

def obs_property_description(p: 'obs_property_t *') -> "char const *":
    return _obspython.obs_property_description(p)
obs_property_description = _obspython.obs_property_description

def obs_property_long_description(p: 'obs_property_t *') -> "char const *":
    return _obspython.obs_property_long_description(p)
obs_property_long_description = _obspython.obs_property_long_description

def obs_property_get_type(p: 'obs_property_t *') -> "enum obs_property_type":
    return _obspython.obs_property_get_type(p)
obs_property_get_type = _obspython.obs_property_get_type

def obs_property_enabled(p: 'obs_property_t *') -> "bool":
    return _obspython.obs_property_enabled(p)
obs_property_enabled = _obspython.obs_property_enabled

def obs_property_visible(p: 'obs_property_t *') -> "bool":
    return _obspython.obs_property_visible(p)
obs_property_visible = _obspython.obs_property_visible

def obs_property_next(p: 'obs_property_t **') -> "bool":
    return _obspython.obs_property_next(p)
obs_property_next = _obspython.obs_property_next

def obs_property_int_min(p: 'obs_property_t *') -> "int":
    return _obspython.obs_property_int_min(p)
obs_property_int_min = _obspython.obs_property_int_min

def obs_property_int_max(p: 'obs_property_t *') -> "int":
    return _obspython.obs_property_int_max(p)
obs_property_int_max = _obspython.obs_property_int_max

def obs_property_int_step(p: 'obs_property_t *') -> "int":
    return _obspython.obs_property_int_step(p)
obs_property_int_step = _obspython.obs_property_int_step

def obs_property_int_type(p: 'obs_property_t *') -> "enum obs_number_type":
    return _obspython.obs_property_int_type(p)
obs_property_int_type = _obspython.obs_property_int_type

def obs_property_float_min(p: 'obs_property_t *') -> "double":
    return _obspython.obs_property_float_min(p)
obs_property_float_min = _obspython.obs_property_float_min

def obs_property_float_max(p: 'obs_property_t *') -> "double":
    return _obspython.obs_property_float_max(p)
obs_property_float_max = _obspython.obs_property_float_max

def obs_property_float_step(p: 'obs_property_t *') -> "double":
    return _obspython.obs_property_float_step(p)
obs_property_float_step = _obspython.obs_property_float_step

def obs_property_float_type(p: 'obs_property_t *') -> "enum obs_number_type":
    return _obspython.obs_property_float_type(p)
obs_property_float_type = _obspython.obs_property_float_type

def obs_property_text_type(p: 'obs_property_t *') -> "enum obs_text_type":
    return _obspython.obs_property_text_type(p)
obs_property_text_type = _obspython.obs_property_text_type

def obs_property_path_type(p: 'obs_property_t *') -> "enum obs_path_type":
    return _obspython.obs_property_path_type(p)
obs_property_path_type = _obspython.obs_property_path_type

def obs_property_path_filter(p: 'obs_property_t *') -> "char const *":
    return _obspython.obs_property_path_filter(p)
obs_property_path_filter = _obspython.obs_property_path_filter

def obs_property_path_default_path(p: 'obs_property_t *') -> "char const *":
    return _obspython.obs_property_path_default_path(p)
obs_property_path_default_path = _obspython.obs_property_path_default_path

def obs_property_list_type(p: 'obs_property_t *') -> "enum obs_combo_type":
    return _obspython.obs_property_list_type(p)
obs_property_list_type = _obspython.obs_property_list_type

def obs_property_list_format(p: 'obs_property_t *') -> "enum obs_combo_format":
    return _obspython.obs_property_list_format(p)
obs_property_list_format = _obspython.obs_property_list_format

def obs_property_int_set_limits(p: 'obs_property_t *', min: 'int', max: 'int', step: 'int') -> "void":
    return _obspython.obs_property_int_set_limits(p, min, max, step)
obs_property_int_set_limits = _obspython.obs_property_int_set_limits

def obs_property_float_set_limits(p: 'obs_property_t *', min: 'double', max: 'double', step: 'double') -> "void":
    return _obspython.obs_property_float_set_limits(p, min, max, step)
obs_property_float_set_limits = _obspython.obs_property_float_set_limits

def obs_property_list_clear(p: 'obs_property_t *') -> "void":
    return _obspython.obs_property_list_clear(p)
obs_property_list_clear = _obspython.obs_property_list_clear

def obs_property_list_add_string(p: 'obs_property_t *', name: 'char const *', val: 'char const *') -> "size_t":
    return _obspython.obs_property_list_add_string(p, name, val)
obs_property_list_add_string = _obspython.obs_property_list_add_string

def obs_property_list_add_int(p: 'obs_property_t *', name: 'char const *', val: 'long long') -> "size_t":
    return _obspython.obs_property_list_add_int(p, name, val)
obs_property_list_add_int = _obspython.obs_property_list_add_int

def obs_property_list_add_float(p: 'obs_property_t *', name: 'char const *', val: 'double') -> "size_t":
    return _obspython.obs_property_list_add_float(p, name, val)
obs_property_list_add_float = _obspython.obs_property_list_add_float

def obs_property_list_insert_string(p: 'obs_property_t *', idx: 'size_t', name: 'char const *', val: 'char const *') -> "void":
    return _obspython.obs_property_list_insert_string(p, idx, name, val)
obs_property_list_insert_string = _obspython.obs_property_list_insert_string

def obs_property_list_insert_int(p: 'obs_property_t *', idx: 'size_t', name: 'char const *', val: 'long long') -> "void":
    return _obspython.obs_property_list_insert_int(p, idx, name, val)
obs_property_list_insert_int = _obspython.obs_property_list_insert_int

def obs_property_list_insert_float(p: 'obs_property_t *', idx: 'size_t', name: 'char const *', val: 'double') -> "void":
    return _obspython.obs_property_list_insert_float(p, idx, name, val)
obs_property_list_insert_float = _obspython.obs_property_list_insert_float

def obs_property_list_item_disable(p: 'obs_property_t *', idx: 'size_t', disabled: 'bool') -> "void":
    return _obspython.obs_property_list_item_disable(p, idx, disabled)
obs_property_list_item_disable = _obspython.obs_property_list_item_disable

def obs_property_list_item_disabled(p: 'obs_property_t *', idx: 'size_t') -> "bool":
    return _obspython.obs_property_list_item_disabled(p, idx)
obs_property_list_item_disabled = _obspython.obs_property_list_item_disabled

def obs_property_list_item_remove(p: 'obs_property_t *', idx: 'size_t') -> "void":
    return _obspython.obs_property_list_item_remove(p, idx)
obs_property_list_item_remove = _obspython.obs_property_list_item_remove

def obs_property_list_item_count(p: 'obs_property_t *') -> "size_t":
    return _obspython.obs_property_list_item_count(p)
obs_property_list_item_count = _obspython.obs_property_list_item_count

def obs_property_list_item_name(p: 'obs_property_t *', idx: 'size_t') -> "char const *":
    return _obspython.obs_property_list_item_name(p, idx)
obs_property_list_item_name = _obspython.obs_property_list_item_name

def obs_property_list_item_string(p: 'obs_property_t *', idx: 'size_t') -> "char const *":
    return _obspython.obs_property_list_item_string(p, idx)
obs_property_list_item_string = _obspython.obs_property_list_item_string

def obs_property_list_item_int(p: 'obs_property_t *', idx: 'size_t') -> "long long":
    return _obspython.obs_property_list_item_int(p, idx)
obs_property_list_item_int = _obspython.obs_property_list_item_int

def obs_property_list_item_float(p: 'obs_property_t *', idx: 'size_t') -> "double":
    return _obspython.obs_property_list_item_float(p, idx)
obs_property_list_item_float = _obspython.obs_property_list_item_float

def obs_property_editable_list_type(p: 'obs_property_t *') -> "enum obs_editable_list_type":
    return _obspython.obs_property_editable_list_type(p)
obs_property_editable_list_type = _obspython.obs_property_editable_list_type

def obs_property_editable_list_filter(p: 'obs_property_t *') -> "char const *":
    return _obspython.obs_property_editable_list_filter(p)
obs_property_editable_list_filter = _obspython.obs_property_editable_list_filter

def obs_property_editable_list_default_path(p: 'obs_property_t *') -> "char const *":
    return _obspython.obs_property_editable_list_default_path(p)
obs_property_editable_list_default_path = _obspython.obs_property_editable_list_default_path

def obs_property_frame_rate_clear(p: 'obs_property_t *') -> "void":
    return _obspython.obs_property_frame_rate_clear(p)
obs_property_frame_rate_clear = _obspython.obs_property_frame_rate_clear

def obs_property_frame_rate_options_clear(p: 'obs_property_t *') -> "void":
    return _obspython.obs_property_frame_rate_options_clear(p)
obs_property_frame_rate_options_clear = _obspython.obs_property_frame_rate_options_clear

def obs_property_frame_rate_fps_ranges_clear(p: 'obs_property_t *') -> "void":
    return _obspython.obs_property_frame_rate_fps_ranges_clear(p)
obs_property_frame_rate_fps_ranges_clear = _obspython.obs_property_frame_rate_fps_ranges_clear

def obs_property_frame_rate_option_add(p: 'obs_property_t *', name: 'char const *', description: 'char const *') -> "size_t":
    return _obspython.obs_property_frame_rate_option_add(p, name, description)
obs_property_frame_rate_option_add = _obspython.obs_property_frame_rate_option_add

def obs_property_frame_rate_fps_range_add(p: 'obs_property_t *', min: 'struct media_frames_per_second', max: 'struct media_frames_per_second') -> "size_t":
    return _obspython.obs_property_frame_rate_fps_range_add(p, min, max)
obs_property_frame_rate_fps_range_add = _obspython.obs_property_frame_rate_fps_range_add

def obs_property_frame_rate_option_insert(p: 'obs_property_t *', idx: 'size_t', name: 'char const *', description: 'char const *') -> "void":
    return _obspython.obs_property_frame_rate_option_insert(p, idx, name, description)
obs_property_frame_rate_option_insert = _obspython.obs_property_frame_rate_option_insert

def obs_property_frame_rate_fps_range_insert(p: 'obs_property_t *', idx: 'size_t', min: 'struct media_frames_per_second', max: 'struct media_frames_per_second') -> "void":
    return _obspython.obs_property_frame_rate_fps_range_insert(p, idx, min, max)
obs_property_frame_rate_fps_range_insert = _obspython.obs_property_frame_rate_fps_range_insert

def obs_property_frame_rate_options_count(p: 'obs_property_t *') -> "size_t":
    return _obspython.obs_property_frame_rate_options_count(p)
obs_property_frame_rate_options_count = _obspython.obs_property_frame_rate_options_count

def obs_property_frame_rate_option_name(p: 'obs_property_t *', idx: 'size_t') -> "char const *":
    return _obspython.obs_property_frame_rate_option_name(p, idx)
obs_property_frame_rate_option_name = _obspython.obs_property_frame_rate_option_name

def obs_property_frame_rate_option_description(p: 'obs_property_t *', idx: 'size_t') -> "char const *":
    return _obspython.obs_property_frame_rate_option_description(p, idx)
obs_property_frame_rate_option_description = _obspython.obs_property_frame_rate_option_description

def obs_property_frame_rate_fps_ranges_count(p: 'obs_property_t *') -> "size_t":
    return _obspython.obs_property_frame_rate_fps_ranges_count(p)
obs_property_frame_rate_fps_ranges_count = _obspython.obs_property_frame_rate_fps_ranges_count

def obs_property_frame_rate_fps_range_min(p: 'obs_property_t *', idx: 'size_t') -> "struct media_frames_per_second":
    return _obspython.obs_property_frame_rate_fps_range_min(p, idx)
obs_property_frame_rate_fps_range_min = _obspython.obs_property_frame_rate_fps_range_min

def obs_property_frame_rate_fps_range_max(p: 'obs_property_t *', idx: 'size_t') -> "struct media_frames_per_second":
    return _obspython.obs_property_frame_rate_fps_range_max(p, idx)
obs_property_frame_rate_fps_range_max = _obspython.obs_property_frame_rate_fps_range_max
INTERACT_NONE = _obspython.INTERACT_NONE
INTERACT_CAPS_KEY = _obspython.INTERACT_CAPS_KEY
INTERACT_SHIFT_KEY = _obspython.INTERACT_SHIFT_KEY
INTERACT_CONTROL_KEY = _obspython.INTERACT_CONTROL_KEY
INTERACT_ALT_KEY = _obspython.INTERACT_ALT_KEY
INTERACT_MOUSE_LEFT = _obspython.INTERACT_MOUSE_LEFT
INTERACT_MOUSE_MIDDLE = _obspython.INTERACT_MOUSE_MIDDLE
INTERACT_MOUSE_RIGHT = _obspython.INTERACT_MOUSE_RIGHT
INTERACT_COMMAND_KEY = _obspython.INTERACT_COMMAND_KEY
INTERACT_NUMLOCK_KEY = _obspython.INTERACT_NUMLOCK_KEY
INTERACT_IS_KEY_PAD = _obspython.INTERACT_IS_KEY_PAD
INTERACT_IS_LEFT = _obspython.INTERACT_IS_LEFT
INTERACT_IS_RIGHT = _obspython.INTERACT_IS_RIGHT
MOUSE_LEFT = _obspython.MOUSE_LEFT
MOUSE_MIDDLE = _obspython.MOUSE_MIDDLE
MOUSE_RIGHT = _obspython.MOUSE_RIGHT
class obs_mouse_event(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_mouse_event, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_mouse_event, name)
    __repr__ = _swig_repr
    __swig_setmethods__["modifiers"] = _obspython.obs_mouse_event_modifiers_set
    __swig_getmethods__["modifiers"] = _obspython.obs_mouse_event_modifiers_get
    if _newclass:
        modifiers = _swig_property(_obspython.obs_mouse_event_modifiers_get, _obspython.obs_mouse_event_modifiers_set)
    __swig_setmethods__["x"] = _obspython.obs_mouse_event_x_set
    __swig_getmethods__["x"] = _obspython.obs_mouse_event_x_get
    if _newclass:
        x = _swig_property(_obspython.obs_mouse_event_x_get, _obspython.obs_mouse_event_x_set)
    __swig_setmethods__["y"] = _obspython.obs_mouse_event_y_set
    __swig_getmethods__["y"] = _obspython.obs_mouse_event_y_get
    if _newclass:
        y = _swig_property(_obspython.obs_mouse_event_y_get, _obspython.obs_mouse_event_y_set)

    def __init__(self):
        this = _obspython.new_obs_mouse_event()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_mouse_event
    __del__ = lambda self: None
obs_mouse_event_swigregister = _obspython.obs_mouse_event_swigregister
obs_mouse_event_swigregister(obs_mouse_event)

class obs_key_event(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_key_event, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_key_event, name)
    __repr__ = _swig_repr
    __swig_setmethods__["modifiers"] = _obspython.obs_key_event_modifiers_set
    __swig_getmethods__["modifiers"] = _obspython.obs_key_event_modifiers_get
    if _newclass:
        modifiers = _swig_property(_obspython.obs_key_event_modifiers_get, _obspython.obs_key_event_modifiers_set)
    __swig_setmethods__["text"] = _obspython.obs_key_event_text_set
    __swig_getmethods__["text"] = _obspython.obs_key_event_text_get
    if _newclass:
        text = _swig_property(_obspython.obs_key_event_text_get, _obspython.obs_key_event_text_set)
    __swig_setmethods__["native_modifiers"] = _obspython.obs_key_event_native_modifiers_set
    __swig_getmethods__["native_modifiers"] = _obspython.obs_key_event_native_modifiers_get
    if _newclass:
        native_modifiers = _swig_property(_obspython.obs_key_event_native_modifiers_get, _obspython.obs_key_event_native_modifiers_set)
    __swig_setmethods__["native_scancode"] = _obspython.obs_key_event_native_scancode_set
    __swig_getmethods__["native_scancode"] = _obspython.obs_key_event_native_scancode_get
    if _newclass:
        native_scancode = _swig_property(_obspython.obs_key_event_native_scancode_get, _obspython.obs_key_event_native_scancode_set)
    __swig_setmethods__["native_vkey"] = _obspython.obs_key_event_native_vkey_set
    __swig_getmethods__["native_vkey"] = _obspython.obs_key_event_native_vkey_get
    if _newclass:
        native_vkey = _swig_property(_obspython.obs_key_event_native_vkey_get, _obspython.obs_key_event_native_vkey_set)

    def __init__(self):
        this = _obspython.new_obs_key_event()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_key_event
    __del__ = lambda self: None
obs_key_event_swigregister = _obspython.obs_key_event_swigregister
obs_key_event_swigregister(obs_key_event)

XINPUT_MOUSE_LEN = _obspython.XINPUT_MOUSE_LEN
OBS_KEY_LAST_VALUE = _obspython.OBS_KEY_LAST_VALUE
class obs_key_combination(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_key_combination, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_key_combination, name)
    __repr__ = _swig_repr
    __swig_setmethods__["modifiers"] = _obspython.obs_key_combination_modifiers_set
    __swig_getmethods__["modifiers"] = _obspython.obs_key_combination_modifiers_get
    if _newclass:
        modifiers = _swig_property(_obspython.obs_key_combination_modifiers_get, _obspython.obs_key_combination_modifiers_set)
    __swig_setmethods__["key"] = _obspython.obs_key_combination_key_set
    __swig_getmethods__["key"] = _obspython.obs_key_combination_key_get
    if _newclass:
        key = _swig_property(_obspython.obs_key_combination_key_get, _obspython.obs_key_combination_key_set)

    def __init__(self):
        this = _obspython.new_obs_key_combination()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_key_combination
    __del__ = lambda self: None
obs_key_combination_swigregister = _obspython.obs_key_combination_swigregister
obs_key_combination_swigregister(obs_key_combination)
cvar = _obspython.cvar
OBS_INVALID_HOTKEY_ID = cvar.OBS_INVALID_HOTKEY_ID
OBS_INVALID_HOTKEY_PAIR_ID = cvar.OBS_INVALID_HOTKEY_PAIR_ID

OBS_HOTKEY_REGISTERER_FRONTEND = _obspython.OBS_HOTKEY_REGISTERER_FRONTEND
OBS_HOTKEY_REGISTERER_SOURCE = _obspython.OBS_HOTKEY_REGISTERER_SOURCE
OBS_HOTKEY_REGISTERER_OUTPUT = _obspython.OBS_HOTKEY_REGISTERER_OUTPUT
OBS_HOTKEY_REGISTERER_ENCODER = _obspython.OBS_HOTKEY_REGISTERER_ENCODER
OBS_HOTKEY_REGISTERER_SERVICE = _obspython.OBS_HOTKEY_REGISTERER_SERVICE

def obs_hotkey_get_id(key: 'obs_hotkey_t const *') -> "obs_hotkey_id":
    return _obspython.obs_hotkey_get_id(key)
obs_hotkey_get_id = _obspython.obs_hotkey_get_id

def obs_hotkey_get_name(key: 'obs_hotkey_t const *') -> "char const *":
    return _obspython.obs_hotkey_get_name(key)
obs_hotkey_get_name = _obspython.obs_hotkey_get_name

def obs_hotkey_get_description(key: 'obs_hotkey_t const *') -> "char const *":
    return _obspython.obs_hotkey_get_description(key)
obs_hotkey_get_description = _obspython.obs_hotkey_get_description

def obs_hotkey_get_registerer_type(key: 'obs_hotkey_t const *') -> "obs_hotkey_registerer_t":
    return _obspython.obs_hotkey_get_registerer_type(key)
obs_hotkey_get_registerer_type = _obspython.obs_hotkey_get_registerer_type

def obs_hotkey_get_registerer(key: 'obs_hotkey_t const *') -> "void *":
    return _obspython.obs_hotkey_get_registerer(key)
obs_hotkey_get_registerer = _obspython.obs_hotkey_get_registerer

def obs_hotkey_get_pair_partner_id(key: 'obs_hotkey_t const *') -> "obs_hotkey_id":
    return _obspython.obs_hotkey_get_pair_partner_id(key)
obs_hotkey_get_pair_partner_id = _obspython.obs_hotkey_get_pair_partner_id

def obs_hotkey_binding_get_key_combination(binding: 'obs_hotkey_binding_t *') -> "obs_key_combination_t":
    return _obspython.obs_hotkey_binding_get_key_combination(binding)
obs_hotkey_binding_get_key_combination = _obspython.obs_hotkey_binding_get_key_combination

def obs_hotkey_binding_get_hotkey_id(binding: 'obs_hotkey_binding_t *') -> "obs_hotkey_id":
    return _obspython.obs_hotkey_binding_get_hotkey_id(binding)
obs_hotkey_binding_get_hotkey_id = _obspython.obs_hotkey_binding_get_hotkey_id

def obs_hotkey_binding_get_hotkey(binding: 'obs_hotkey_binding_t *') -> "obs_hotkey_t *":
    return _obspython.obs_hotkey_binding_get_hotkey(binding)
obs_hotkey_binding_get_hotkey = _obspython.obs_hotkey_binding_get_hotkey

def obs_hotkey_set_name(id: 'obs_hotkey_id', name: 'char const *') -> "void":
    return _obspython.obs_hotkey_set_name(id, name)
obs_hotkey_set_name = _obspython.obs_hotkey_set_name

def obs_hotkey_set_description(id: 'obs_hotkey_id', desc: 'char const *') -> "void":
    return _obspython.obs_hotkey_set_description(id, desc)
obs_hotkey_set_description = _obspython.obs_hotkey_set_description

def obs_hotkey_pair_set_names(id: 'obs_hotkey_pair_id', name0: 'char const *', name1: 'char const *') -> "void":
    return _obspython.obs_hotkey_pair_set_names(id, name0, name1)
obs_hotkey_pair_set_names = _obspython.obs_hotkey_pair_set_names

def obs_hotkey_pair_set_descriptions(id: 'obs_hotkey_pair_id', desc0: 'char const *', desc1: 'char const *') -> "void":
    return _obspython.obs_hotkey_pair_set_descriptions(id, desc0, desc1)
obs_hotkey_pair_set_descriptions = _obspython.obs_hotkey_pair_set_descriptions

def obs_hotkeys_set_audio_hotkeys_translations(mute: 'char const *', unmute: 'char const *', push_to_mute: 'char const *', push_to_talk: 'char const *') -> "void":
    return _obspython.obs_hotkeys_set_audio_hotkeys_translations(mute, unmute, push_to_mute, push_to_talk)
obs_hotkeys_set_audio_hotkeys_translations = _obspython.obs_hotkeys_set_audio_hotkeys_translations

def obs_hotkeys_set_sceneitem_hotkeys_translations(show: 'char const *', hide: 'char const *') -> "void":
    return _obspython.obs_hotkeys_set_sceneitem_hotkeys_translations(show, hide)
obs_hotkeys_set_sceneitem_hotkeys_translations = _obspython.obs_hotkeys_set_sceneitem_hotkeys_translations

def obs_hotkey_unregister(id: 'obs_hotkey_id') -> "void":
    return _obspython.obs_hotkey_unregister(id)
obs_hotkey_unregister = _obspython.obs_hotkey_unregister

def obs_hotkey_pair_unregister(id: 'obs_hotkey_pair_id') -> "void":
    return _obspython.obs_hotkey_pair_unregister(id)
obs_hotkey_pair_unregister = _obspython.obs_hotkey_pair_unregister

def obs_hotkey_load_bindings(id: 'obs_hotkey_id', combinations: 'obs_key_combination', num: 'size_t') -> "void":
    return _obspython.obs_hotkey_load_bindings(id, combinations, num)
obs_hotkey_load_bindings = _obspython.obs_hotkey_load_bindings

def obs_hotkey_load(id: 'obs_hotkey_id', data: 'obs_data_array_t *') -> "void":
    return _obspython.obs_hotkey_load(id, data)
obs_hotkey_load = _obspython.obs_hotkey_load

def obs_hotkeys_load_encoder(encoder: 'obs_encoder_t *', hotkeys: 'obs_data_t *') -> "void":
    return _obspython.obs_hotkeys_load_encoder(encoder, hotkeys)
obs_hotkeys_load_encoder = _obspython.obs_hotkeys_load_encoder

def obs_hotkeys_load_output(output: 'obs_output_t *', hotkeys: 'obs_data_t *') -> "void":
    return _obspython.obs_hotkeys_load_output(output, hotkeys)
obs_hotkeys_load_output = _obspython.obs_hotkeys_load_output

def obs_hotkeys_load_service(service: 'obs_service_t *', hotkeys: 'obs_data_t *') -> "void":
    return _obspython.obs_hotkeys_load_service(service, hotkeys)
obs_hotkeys_load_service = _obspython.obs_hotkeys_load_service

def obs_hotkeys_load_source(source: 'obs_source_t *', hotkeys: 'obs_data_t *') -> "void":
    return _obspython.obs_hotkeys_load_source(source, hotkeys)
obs_hotkeys_load_source = _obspython.obs_hotkeys_load_source

def obs_hotkey_pair_load(id: 'obs_hotkey_pair_id', data0: 'obs_data_array_t *', data1: 'obs_data_array_t *') -> "void":
    return _obspython.obs_hotkey_pair_load(id, data0, data1)
obs_hotkey_pair_load = _obspython.obs_hotkey_pair_load

def obs_hotkey_save(id: 'obs_hotkey_id') -> "obs_data_array_t *":
    return _obspython.obs_hotkey_save(id)
obs_hotkey_save = _obspython.obs_hotkey_save

def obs_hotkey_pair_save(id: 'obs_hotkey_pair_id', p_data0: 'obs_data_array_t **', p_data1: 'obs_data_array_t **') -> "void":
    return _obspython.obs_hotkey_pair_save(id, p_data0, p_data1)
obs_hotkey_pair_save = _obspython.obs_hotkey_pair_save

def obs_hotkeys_save_encoder(encoder: 'obs_encoder_t *') -> "obs_data_t *":
    return _obspython.obs_hotkeys_save_encoder(encoder)
obs_hotkeys_save_encoder = _obspython.obs_hotkeys_save_encoder

def obs_hotkeys_save_output(output: 'obs_output_t *') -> "obs_data_t *":
    return _obspython.obs_hotkeys_save_output(output)
obs_hotkeys_save_output = _obspython.obs_hotkeys_save_output

def obs_hotkeys_save_service(service: 'obs_service_t *') -> "obs_data_t *":
    return _obspython.obs_hotkeys_save_service(service)
obs_hotkeys_save_service = _obspython.obs_hotkeys_save_service

def obs_hotkeys_save_source(source: 'obs_source_t *') -> "obs_data_t *":
    return _obspython.obs_hotkeys_save_source(source)
obs_hotkeys_save_source = _obspython.obs_hotkeys_save_source

def obs_enum_hotkeys(func: 'obs_hotkey_enum_func', data: 'void *') -> "void":
    return _obspython.obs_enum_hotkeys(func, data)
obs_enum_hotkeys = _obspython.obs_enum_hotkeys

def obs_enum_hotkey_bindings(func: 'obs_hotkey_binding_enum_func', data: 'void *') -> "void":
    return _obspython.obs_enum_hotkey_bindings(func, data)
obs_enum_hotkey_bindings = _obspython.obs_enum_hotkey_bindings

def obs_hotkey_inject_event(hotkey: 'obs_key_combination', pressed: 'bool') -> "void":
    return _obspython.obs_hotkey_inject_event(hotkey, pressed)
obs_hotkey_inject_event = _obspython.obs_hotkey_inject_event

def obs_hotkey_enable_background_press(enable: 'bool') -> "void":
    return _obspython.obs_hotkey_enable_background_press(enable)
obs_hotkey_enable_background_press = _obspython.obs_hotkey_enable_background_press

def obs_hotkey_enable_strict_modifiers(enable: 'bool') -> "void":
    return _obspython.obs_hotkey_enable_strict_modifiers(enable)
obs_hotkey_enable_strict_modifiers = _obspython.obs_hotkey_enable_strict_modifiers

def obs_hotkey_set_callback_routing_func(func: 'obs_hotkey_callback_router_func', data: 'void *') -> "void":
    return _obspython.obs_hotkey_set_callback_routing_func(func, data)
obs_hotkey_set_callback_routing_func = _obspython.obs_hotkey_set_callback_routing_func

def obs_hotkey_trigger_routed_callback(id: 'obs_hotkey_id', pressed: 'bool') -> "void":
    return _obspython.obs_hotkey_trigger_routed_callback(id, pressed)
obs_hotkey_trigger_routed_callback = _obspython.obs_hotkey_trigger_routed_callback

def obs_hotkey_enable_callback_rerouting(enable: 'bool') -> "void":
    return _obspython.obs_hotkey_enable_callback_rerouting(enable)
obs_hotkey_enable_callback_rerouting = _obspython.obs_hotkey_enable_callback_rerouting

def obs_hotkey_update_atomic(func: 'obs_hotkey_atomic_update_func', data: 'void *') -> "void":
    return _obspython.obs_hotkey_update_atomic(func, data)
obs_hotkey_update_atomic = _obspython.obs_hotkey_update_atomic

def obs_key_to_str(key: 'obs_key_t', str: 'struct dstr *') -> "void":
    return _obspython.obs_key_to_str(key, str)
obs_key_to_str = _obspython.obs_key_to_str

def obs_key_combination_to_str(key: 'obs_key_combination', str: 'struct dstr *') -> "void":
    return _obspython.obs_key_combination_to_str(key, str)
obs_key_combination_to_str = _obspython.obs_key_combination_to_str

def obs_key_from_virtual_key(code: 'int') -> "obs_key_t":
    return _obspython.obs_key_from_virtual_key(code)
obs_key_from_virtual_key = _obspython.obs_key_from_virtual_key

def obs_key_to_virtual_key(key: 'obs_key_t') -> "int":
    return _obspython.obs_key_to_virtual_key(key)
obs_key_to_virtual_key = _obspython.obs_key_to_virtual_key

def obs_key_to_name(key: 'obs_key_t') -> "char const *":
    return _obspython.obs_key_to_name(key)
obs_key_to_name = _obspython.obs_key_to_name

def obs_key_from_name(name: 'char const *') -> "obs_key_t":
    return _obspython.obs_key_from_name(name)
obs_key_from_name = _obspython.obs_key_from_name

def obs_key_combination_is_empty(combo: 'obs_key_combination') -> "bool":
    return _obspython.obs_key_combination_is_empty(combo)
obs_key_combination_is_empty = _obspython.obs_key_combination_is_empty
OBS_ORDER_MOVE_UP = _obspython.OBS_ORDER_MOVE_UP
OBS_ORDER_MOVE_DOWN = _obspython.OBS_ORDER_MOVE_DOWN
OBS_ORDER_MOVE_TOP = _obspython.OBS_ORDER_MOVE_TOP
OBS_ORDER_MOVE_BOTTOM = _obspython.OBS_ORDER_MOVE_BOTTOM
OBS_NO_DIRECT_RENDERING = _obspython.OBS_NO_DIRECT_RENDERING
OBS_ALLOW_DIRECT_RENDERING = _obspython.OBS_ALLOW_DIRECT_RENDERING
OBS_SCALE_DISABLE = _obspython.OBS_SCALE_DISABLE
OBS_SCALE_POINT = _obspython.OBS_SCALE_POINT
OBS_SCALE_BICUBIC = _obspython.OBS_SCALE_BICUBIC
OBS_SCALE_BILINEAR = _obspython.OBS_SCALE_BILINEAR
OBS_SCALE_LANCZOS = _obspython.OBS_SCALE_LANCZOS
OBS_SCALE_AREA = _obspython.OBS_SCALE_AREA
OBS_BOUNDS_NONE = _obspython.OBS_BOUNDS_NONE
OBS_BOUNDS_STRETCH = _obspython.OBS_BOUNDS_STRETCH
OBS_BOUNDS_SCALE_INNER = _obspython.OBS_BOUNDS_SCALE_INNER
OBS_BOUNDS_SCALE_OUTER = _obspython.OBS_BOUNDS_SCALE_OUTER
OBS_BOUNDS_SCALE_TO_WIDTH = _obspython.OBS_BOUNDS_SCALE_TO_WIDTH
OBS_BOUNDS_SCALE_TO_HEIGHT = _obspython.OBS_BOUNDS_SCALE_TO_HEIGHT
OBS_BOUNDS_MAX_ONLY = _obspython.OBS_BOUNDS_MAX_ONLY
class obs_transform_info(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_transform_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_transform_info, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pos"] = _obspython.obs_transform_info_pos_set
    __swig_getmethods__["pos"] = _obspython.obs_transform_info_pos_get
    if _newclass:
        pos = _swig_property(_obspython.obs_transform_info_pos_get, _obspython.obs_transform_info_pos_set)
    __swig_setmethods__["rot"] = _obspython.obs_transform_info_rot_set
    __swig_getmethods__["rot"] = _obspython.obs_transform_info_rot_get
    if _newclass:
        rot = _swig_property(_obspython.obs_transform_info_rot_get, _obspython.obs_transform_info_rot_set)
    __swig_setmethods__["scale"] = _obspython.obs_transform_info_scale_set
    __swig_getmethods__["scale"] = _obspython.obs_transform_info_scale_get
    if _newclass:
        scale = _swig_property(_obspython.obs_transform_info_scale_get, _obspython.obs_transform_info_scale_set)
    __swig_setmethods__["alignment"] = _obspython.obs_transform_info_alignment_set
    __swig_getmethods__["alignment"] = _obspython.obs_transform_info_alignment_get
    if _newclass:
        alignment = _swig_property(_obspython.obs_transform_info_alignment_get, _obspython.obs_transform_info_alignment_set)
    __swig_setmethods__["bounds_type"] = _obspython.obs_transform_info_bounds_type_set
    __swig_getmethods__["bounds_type"] = _obspython.obs_transform_info_bounds_type_get
    if _newclass:
        bounds_type = _swig_property(_obspython.obs_transform_info_bounds_type_get, _obspython.obs_transform_info_bounds_type_set)
    __swig_setmethods__["bounds_alignment"] = _obspython.obs_transform_info_bounds_alignment_set
    __swig_getmethods__["bounds_alignment"] = _obspython.obs_transform_info_bounds_alignment_get
    if _newclass:
        bounds_alignment = _swig_property(_obspython.obs_transform_info_bounds_alignment_get, _obspython.obs_transform_info_bounds_alignment_set)
    __swig_setmethods__["bounds"] = _obspython.obs_transform_info_bounds_set
    __swig_getmethods__["bounds"] = _obspython.obs_transform_info_bounds_get
    if _newclass:
        bounds = _swig_property(_obspython.obs_transform_info_bounds_get, _obspython.obs_transform_info_bounds_set)

    def __init__(self):
        this = _obspython.new_obs_transform_info()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_transform_info
    __del__ = lambda self: None
obs_transform_info_swigregister = _obspython.obs_transform_info_swigregister
obs_transform_info_swigregister(obs_transform_info)

class obs_video_info(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_video_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_video_info, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fps_num"] = _obspython.obs_video_info_fps_num_set
    __swig_getmethods__["fps_num"] = _obspython.obs_video_info_fps_num_get
    if _newclass:
        fps_num = _swig_property(_obspython.obs_video_info_fps_num_get, _obspython.obs_video_info_fps_num_set)
    __swig_setmethods__["fps_den"] = _obspython.obs_video_info_fps_den_set
    __swig_getmethods__["fps_den"] = _obspython.obs_video_info_fps_den_get
    if _newclass:
        fps_den = _swig_property(_obspython.obs_video_info_fps_den_get, _obspython.obs_video_info_fps_den_set)
    __swig_setmethods__["base_width"] = _obspython.obs_video_info_base_width_set
    __swig_getmethods__["base_width"] = _obspython.obs_video_info_base_width_get
    if _newclass:
        base_width = _swig_property(_obspython.obs_video_info_base_width_get, _obspython.obs_video_info_base_width_set)
    __swig_setmethods__["base_height"] = _obspython.obs_video_info_base_height_set
    __swig_getmethods__["base_height"] = _obspython.obs_video_info_base_height_get
    if _newclass:
        base_height = _swig_property(_obspython.obs_video_info_base_height_get, _obspython.obs_video_info_base_height_set)
    __swig_setmethods__["output_width"] = _obspython.obs_video_info_output_width_set
    __swig_getmethods__["output_width"] = _obspython.obs_video_info_output_width_get
    if _newclass:
        output_width = _swig_property(_obspython.obs_video_info_output_width_get, _obspython.obs_video_info_output_width_set)
    __swig_setmethods__["output_height"] = _obspython.obs_video_info_output_height_set
    __swig_getmethods__["output_height"] = _obspython.obs_video_info_output_height_get
    if _newclass:
        output_height = _swig_property(_obspython.obs_video_info_output_height_get, _obspython.obs_video_info_output_height_set)
    __swig_setmethods__["output_format"] = _obspython.obs_video_info_output_format_set
    __swig_getmethods__["output_format"] = _obspython.obs_video_info_output_format_get
    if _newclass:
        output_format = _swig_property(_obspython.obs_video_info_output_format_get, _obspython.obs_video_info_output_format_set)
    __swig_setmethods__["adapter"] = _obspython.obs_video_info_adapter_set
    __swig_getmethods__["adapter"] = _obspython.obs_video_info_adapter_get
    if _newclass:
        adapter = _swig_property(_obspython.obs_video_info_adapter_get, _obspython.obs_video_info_adapter_set)
    __swig_setmethods__["gpu_conversion"] = _obspython.obs_video_info_gpu_conversion_set
    __swig_getmethods__["gpu_conversion"] = _obspython.obs_video_info_gpu_conversion_get
    if _newclass:
        gpu_conversion = _swig_property(_obspython.obs_video_info_gpu_conversion_get, _obspython.obs_video_info_gpu_conversion_set)
    __swig_setmethods__["colorspace"] = _obspython.obs_video_info_colorspace_set
    __swig_getmethods__["colorspace"] = _obspython.obs_video_info_colorspace_get
    if _newclass:
        colorspace = _swig_property(_obspython.obs_video_info_colorspace_get, _obspython.obs_video_info_colorspace_set)
    __swig_setmethods__["range"] = _obspython.obs_video_info_range_set
    __swig_getmethods__["range"] = _obspython.obs_video_info_range_get
    if _newclass:
        range = _swig_property(_obspython.obs_video_info_range_get, _obspython.obs_video_info_range_set)
    __swig_setmethods__["scale_type"] = _obspython.obs_video_info_scale_type_set
    __swig_getmethods__["scale_type"] = _obspython.obs_video_info_scale_type_get
    if _newclass:
        scale_type = _swig_property(_obspython.obs_video_info_scale_type_get, _obspython.obs_video_info_scale_type_set)

    def __init__(self):
        this = _obspython.new_obs_video_info()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_video_info
    __del__ = lambda self: None
obs_video_info_swigregister = _obspython.obs_video_info_swigregister
obs_video_info_swigregister(obs_video_info)

class obs_audio_info(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_audio_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_audio_info, name)
    __repr__ = _swig_repr
    __swig_setmethods__["samples_per_sec"] = _obspython.obs_audio_info_samples_per_sec_set
    __swig_getmethods__["samples_per_sec"] = _obspython.obs_audio_info_samples_per_sec_get
    if _newclass:
        samples_per_sec = _swig_property(_obspython.obs_audio_info_samples_per_sec_get, _obspython.obs_audio_info_samples_per_sec_set)
    __swig_setmethods__["speakers"] = _obspython.obs_audio_info_speakers_set
    __swig_getmethods__["speakers"] = _obspython.obs_audio_info_speakers_get
    if _newclass:
        speakers = _swig_property(_obspython.obs_audio_info_speakers_get, _obspython.obs_audio_info_speakers_set)

    def __init__(self):
        this = _obspython.new_obs_audio_info()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_audio_info
    __del__ = lambda self: None
obs_audio_info_swigregister = _obspython.obs_audio_info_swigregister
obs_audio_info_swigregister(obs_audio_info)

class obs_audio_data(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_audio_data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_audio_data, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _obspython.obs_audio_data_data_set
    __swig_getmethods__["data"] = _obspython.obs_audio_data_data_get
    if _newclass:
        data = _swig_property(_obspython.obs_audio_data_data_get, _obspython.obs_audio_data_data_set)
    __swig_setmethods__["frames"] = _obspython.obs_audio_data_frames_set
    __swig_getmethods__["frames"] = _obspython.obs_audio_data_frames_get
    if _newclass:
        frames = _swig_property(_obspython.obs_audio_data_frames_get, _obspython.obs_audio_data_frames_set)
    __swig_setmethods__["timestamp"] = _obspython.obs_audio_data_timestamp_set
    __swig_getmethods__["timestamp"] = _obspython.obs_audio_data_timestamp_get
    if _newclass:
        timestamp = _swig_property(_obspython.obs_audio_data_timestamp_get, _obspython.obs_audio_data_timestamp_set)

    def __init__(self):
        this = _obspython.new_obs_audio_data()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_audio_data
    __del__ = lambda self: None
obs_audio_data_swigregister = _obspython.obs_audio_data_swigregister
obs_audio_data_swigregister(obs_audio_data)

class obs_source_audio(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_source_audio, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_source_audio, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _obspython.obs_source_audio_data_set
    __swig_getmethods__["data"] = _obspython.obs_source_audio_data_get
    if _newclass:
        data = _swig_property(_obspython.obs_source_audio_data_get, _obspython.obs_source_audio_data_set)
    __swig_setmethods__["frames"] = _obspython.obs_source_audio_frames_set
    __swig_getmethods__["frames"] = _obspython.obs_source_audio_frames_get
    if _newclass:
        frames = _swig_property(_obspython.obs_source_audio_frames_get, _obspython.obs_source_audio_frames_set)
    __swig_setmethods__["speakers"] = _obspython.obs_source_audio_speakers_set
    __swig_getmethods__["speakers"] = _obspython.obs_source_audio_speakers_get
    if _newclass:
        speakers = _swig_property(_obspython.obs_source_audio_speakers_get, _obspython.obs_source_audio_speakers_set)
    __swig_setmethods__["format"] = _obspython.obs_source_audio_format_set
    __swig_getmethods__["format"] = _obspython.obs_source_audio_format_get
    if _newclass:
        format = _swig_property(_obspython.obs_source_audio_format_get, _obspython.obs_source_audio_format_set)
    __swig_setmethods__["samples_per_sec"] = _obspython.obs_source_audio_samples_per_sec_set
    __swig_getmethods__["samples_per_sec"] = _obspython.obs_source_audio_samples_per_sec_get
    if _newclass:
        samples_per_sec = _swig_property(_obspython.obs_source_audio_samples_per_sec_get, _obspython.obs_source_audio_samples_per_sec_set)
    __swig_setmethods__["timestamp"] = _obspython.obs_source_audio_timestamp_set
    __swig_getmethods__["timestamp"] = _obspython.obs_source_audio_timestamp_get
    if _newclass:
        timestamp = _swig_property(_obspython.obs_source_audio_timestamp_get, _obspython.obs_source_audio_timestamp_set)

    def __init__(self):
        this = _obspython.new_obs_source_audio()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_source_audio
    __del__ = lambda self: None
obs_source_audio_swigregister = _obspython.obs_source_audio_swigregister
obs_source_audio_swigregister(obs_source_audio)

class obs_source_frame(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_source_frame, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_source_frame, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _obspython.obs_source_frame_data_set
    __swig_getmethods__["data"] = _obspython.obs_source_frame_data_get
    if _newclass:
        data = _swig_property(_obspython.obs_source_frame_data_get, _obspython.obs_source_frame_data_set)
    __swig_setmethods__["linesize"] = _obspython.obs_source_frame_linesize_set
    __swig_getmethods__["linesize"] = _obspython.obs_source_frame_linesize_get
    if _newclass:
        linesize = _swig_property(_obspython.obs_source_frame_linesize_get, _obspython.obs_source_frame_linesize_set)
    __swig_setmethods__["width"] = _obspython.obs_source_frame_width_set
    __swig_getmethods__["width"] = _obspython.obs_source_frame_width_get
    if _newclass:
        width = _swig_property(_obspython.obs_source_frame_width_get, _obspython.obs_source_frame_width_set)
    __swig_setmethods__["height"] = _obspython.obs_source_frame_height_set
    __swig_getmethods__["height"] = _obspython.obs_source_frame_height_get
    if _newclass:
        height = _swig_property(_obspython.obs_source_frame_height_get, _obspython.obs_source_frame_height_set)
    __swig_setmethods__["timestamp"] = _obspython.obs_source_frame_timestamp_set
    __swig_getmethods__["timestamp"] = _obspython.obs_source_frame_timestamp_get
    if _newclass:
        timestamp = _swig_property(_obspython.obs_source_frame_timestamp_get, _obspython.obs_source_frame_timestamp_set)
    __swig_setmethods__["format"] = _obspython.obs_source_frame_format_set
    __swig_getmethods__["format"] = _obspython.obs_source_frame_format_get
    if _newclass:
        format = _swig_property(_obspython.obs_source_frame_format_get, _obspython.obs_source_frame_format_set)
    __swig_setmethods__["color_matrix"] = _obspython.obs_source_frame_color_matrix_set
    __swig_getmethods__["color_matrix"] = _obspython.obs_source_frame_color_matrix_get
    if _newclass:
        color_matrix = _swig_property(_obspython.obs_source_frame_color_matrix_get, _obspython.obs_source_frame_color_matrix_set)
    __swig_setmethods__["full_range"] = _obspython.obs_source_frame_full_range_set
    __swig_getmethods__["full_range"] = _obspython.obs_source_frame_full_range_get
    if _newclass:
        full_range = _swig_property(_obspython.obs_source_frame_full_range_get, _obspython.obs_source_frame_full_range_set)
    __swig_setmethods__["color_range_min"] = _obspython.obs_source_frame_color_range_min_set
    __swig_getmethods__["color_range_min"] = _obspython.obs_source_frame_color_range_min_get
    if _newclass:
        color_range_min = _swig_property(_obspython.obs_source_frame_color_range_min_get, _obspython.obs_source_frame_color_range_min_set)
    __swig_setmethods__["color_range_max"] = _obspython.obs_source_frame_color_range_max_set
    __swig_getmethods__["color_range_max"] = _obspython.obs_source_frame_color_range_max_get
    if _newclass:
        color_range_max = _swig_property(_obspython.obs_source_frame_color_range_max_get, _obspython.obs_source_frame_color_range_max_set)
    __swig_setmethods__["flip"] = _obspython.obs_source_frame_flip_set
    __swig_getmethods__["flip"] = _obspython.obs_source_frame_flip_get
    if _newclass:
        flip = _swig_property(_obspython.obs_source_frame_flip_get, _obspython.obs_source_frame_flip_set)
    __swig_setmethods__["refs"] = _obspython.obs_source_frame_refs_set
    __swig_getmethods__["refs"] = _obspython.obs_source_frame_refs_get
    if _newclass:
        refs = _swig_property(_obspython.obs_source_frame_refs_get, _obspython.obs_source_frame_refs_set)
    __swig_setmethods__["prev_frame"] = _obspython.obs_source_frame_prev_frame_set
    __swig_getmethods__["prev_frame"] = _obspython.obs_source_frame_prev_frame_get
    if _newclass:
        prev_frame = _swig_property(_obspython.obs_source_frame_prev_frame_get, _obspython.obs_source_frame_prev_frame_set)

    def __init__(self):
        this = _obspython.new_obs_source_frame()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_source_frame
    __del__ = lambda self: None
obs_source_frame_swigregister = _obspython.obs_source_frame_swigregister
obs_source_frame_swigregister(obs_source_frame)

class obs_cmdline_args(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_cmdline_args, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_cmdline_args, name)
    __repr__ = _swig_repr
    __swig_setmethods__["argc"] = _obspython.obs_cmdline_args_argc_set
    __swig_getmethods__["argc"] = _obspython.obs_cmdline_args_argc_get
    if _newclass:
        argc = _swig_property(_obspython.obs_cmdline_args_argc_get, _obspython.obs_cmdline_args_argc_set)
    __swig_setmethods__["argv"] = _obspython.obs_cmdline_args_argv_set
    __swig_getmethods__["argv"] = _obspython.obs_cmdline_args_argv_get
    if _newclass:
        argv = _swig_property(_obspython.obs_cmdline_args_argv_get, _obspython.obs_cmdline_args_argv_set)

    def __init__(self):
        this = _obspython.new_obs_cmdline_args()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_cmdline_args
    __del__ = lambda self: None
obs_cmdline_args_swigregister = _obspython.obs_cmdline_args_swigregister
obs_cmdline_args_swigregister(obs_cmdline_args)


def obs_find_data_file(file: 'char const *') -> "char *":
    return _obspython.obs_find_data_file(file)
obs_find_data_file = _obspython.obs_find_data_file

def obs_add_data_path(path: 'char const *') -> "void":
    return _obspython.obs_add_data_path(path)
obs_add_data_path = _obspython.obs_add_data_path

def obs_remove_data_path(path: 'char const *') -> "bool":
    return _obspython.obs_remove_data_path(path)
obs_remove_data_path = _obspython.obs_remove_data_path

def obs_startup(locale: 'char const *', module_config_path: 'char const *', store: 'profiler_name_store_t *') -> "bool":
    return _obspython.obs_startup(locale, module_config_path, store)
obs_startup = _obspython.obs_startup

def obs_shutdown() -> "void":
    return _obspython.obs_shutdown()
obs_shutdown = _obspython.obs_shutdown

def obs_initialized() -> "bool":
    return _obspython.obs_initialized()
obs_initialized = _obspython.obs_initialized

def obs_get_version() -> "uint32_t":
    return _obspython.obs_get_version()
obs_get_version = _obspython.obs_get_version

def obs_get_version_string() -> "char const *":
    return _obspython.obs_get_version_string()
obs_get_version_string = _obspython.obs_get_version_string

def obs_set_cmdline_args(argc: 'int', argv: 'char const *const *') -> "void":
    return _obspython.obs_set_cmdline_args(argc, argv)
obs_set_cmdline_args = _obspython.obs_set_cmdline_args

def obs_get_cmdline_args() -> "struct obs_cmdline_args":
    return _obspython.obs_get_cmdline_args()
obs_get_cmdline_args = _obspython.obs_get_cmdline_args

def obs_set_locale(locale: 'char const *') -> "void":
    return _obspython.obs_set_locale(locale)
obs_set_locale = _obspython.obs_set_locale

def obs_get_locale() -> "char const *":
    return _obspython.obs_get_locale()
obs_get_locale = _obspython.obs_get_locale

def obs_get_profiler_name_store() -> "profiler_name_store_t *":
    return _obspython.obs_get_profiler_name_store()
obs_get_profiler_name_store = _obspython.obs_get_profiler_name_store

def obs_reset_video(ovi: 'obs_video_info') -> "int":
    return _obspython.obs_reset_video(ovi)
obs_reset_video = _obspython.obs_reset_video

def obs_reset_audio(oai: 'obs_audio_info') -> "bool":
    return _obspython.obs_reset_audio(oai)
obs_reset_audio = _obspython.obs_reset_audio

def obs_get_video_info(ovi: 'obs_video_info') -> "bool":
    return _obspython.obs_get_video_info(ovi)
obs_get_video_info = _obspython.obs_get_video_info

def obs_get_audio_info(oai: 'obs_audio_info') -> "bool":
    return _obspython.obs_get_audio_info(oai)
obs_get_audio_info = _obspython.obs_get_audio_info

def obs_open_module(module: 'obs_module_t **', path: 'char const *', data_path: 'char const *') -> "int":
    return _obspython.obs_open_module(module, path, data_path)
obs_open_module = _obspython.obs_open_module

def obs_init_module(module: 'obs_module_t *') -> "bool":
    return _obspython.obs_init_module(module)
obs_init_module = _obspython.obs_init_module

def obs_log_loaded_modules() -> "void":
    return _obspython.obs_log_loaded_modules()
obs_log_loaded_modules = _obspython.obs_log_loaded_modules

def obs_get_module_file_name(module: 'obs_module_t *') -> "char const *":
    return _obspython.obs_get_module_file_name(module)
obs_get_module_file_name = _obspython.obs_get_module_file_name

def obs_get_module_name(module: 'obs_module_t *') -> "char const *":
    return _obspython.obs_get_module_name(module)
obs_get_module_name = _obspython.obs_get_module_name

def obs_get_module_author(module: 'obs_module_t *') -> "char const *":
    return _obspython.obs_get_module_author(module)
obs_get_module_author = _obspython.obs_get_module_author

def obs_get_module_description(module: 'obs_module_t *') -> "char const *":
    return _obspython.obs_get_module_description(module)
obs_get_module_description = _obspython.obs_get_module_description

def obs_get_module_binary_path(module: 'obs_module_t *') -> "char const *":
    return _obspython.obs_get_module_binary_path(module)
obs_get_module_binary_path = _obspython.obs_get_module_binary_path

def obs_get_module_data_path(module: 'obs_module_t *') -> "char const *":
    return _obspython.obs_get_module_data_path(module)
obs_get_module_data_path = _obspython.obs_get_module_data_path

def obs_add_module_path(bin: 'char const *', data: 'char const *') -> "void":
    return _obspython.obs_add_module_path(bin, data)
obs_add_module_path = _obspython.obs_add_module_path

def obs_load_all_modules() -> "void":
    return _obspython.obs_load_all_modules()
obs_load_all_modules = _obspython.obs_load_all_modules

def obs_post_load_modules() -> "void":
    return _obspython.obs_post_load_modules()
obs_post_load_modules = _obspython.obs_post_load_modules

def obs_enum_modules(callback: 'obs_enum_module_callback_t', param: 'void *') -> "void":
    return _obspython.obs_enum_modules(callback, param)
obs_enum_modules = _obspython.obs_enum_modules

def obs_module_load_locale(module: 'obs_module_t *', default_locale: 'char const *', locale: 'char const *') -> "lookup_t *":
    return _obspython.obs_module_load_locale(module, default_locale, locale)
obs_module_load_locale = _obspython.obs_module_load_locale

def obs_find_module_file(module: 'obs_module_t *', file: 'char const *') -> "char *":
    return _obspython.obs_find_module_file(module, file)
obs_find_module_file = _obspython.obs_find_module_file

def obs_module_get_config_path(module: 'obs_module_t *', file: 'char const *') -> "char *":
    return _obspython.obs_module_get_config_path(module, file)
obs_module_get_config_path = _obspython.obs_module_get_config_path

def obs_enum_source_types(idx: 'size_t', id: 'char const **') -> "bool":
    return _obspython.obs_enum_source_types(idx, id)
obs_enum_source_types = _obspython.obs_enum_source_types

def obs_enum_input_types(idx: 'size_t', id: 'char const **') -> "bool":
    return _obspython.obs_enum_input_types(idx, id)
obs_enum_input_types = _obspython.obs_enum_input_types

def obs_enum_filter_types(idx: 'size_t', id: 'char const **') -> "bool":
    return _obspython.obs_enum_filter_types(idx, id)
obs_enum_filter_types = _obspython.obs_enum_filter_types

def obs_enum_transition_types(idx: 'size_t', id: 'char const **') -> "bool":
    return _obspython.obs_enum_transition_types(idx, id)
obs_enum_transition_types = _obspython.obs_enum_transition_types

def obs_enum_output_types(idx: 'size_t', id: 'char const **') -> "bool":
    return _obspython.obs_enum_output_types(idx, id)
obs_enum_output_types = _obspython.obs_enum_output_types

def obs_enum_encoder_types(idx: 'size_t', id: 'char const **') -> "bool":
    return _obspython.obs_enum_encoder_types(idx, id)
obs_enum_encoder_types = _obspython.obs_enum_encoder_types

def obs_enum_service_types(idx: 'size_t', id: 'char const **') -> "bool":
    return _obspython.obs_enum_service_types(idx, id)
obs_enum_service_types = _obspython.obs_enum_service_types

def obs_enter_graphics() -> "void":
    return _obspython.obs_enter_graphics()
obs_enter_graphics = _obspython.obs_enter_graphics

def obs_leave_graphics() -> "void":
    return _obspython.obs_leave_graphics()
obs_leave_graphics = _obspython.obs_leave_graphics

def obs_get_audio() -> "audio_t *":
    return _obspython.obs_get_audio()
obs_get_audio = _obspython.obs_get_audio

def obs_get_video() -> "video_t *":
    return _obspython.obs_get_video()
obs_get_video = _obspython.obs_get_video

def obs_video_active() -> "bool":
    return _obspython.obs_video_active()
obs_video_active = _obspython.obs_video_active

def obs_set_output_source(channel: 'uint32_t', source: 'obs_source_t *') -> "void":
    return _obspython.obs_set_output_source(channel, source)
obs_set_output_source = _obspython.obs_set_output_source

def obs_get_output_source(channel: 'uint32_t') -> "obs_source_t *":
    return _obspython.obs_get_output_source(channel)
obs_get_output_source = _obspython.obs_get_output_source

def obs_enum_scenes(enum_proc: 'bool (*)(void *,obs_source_t *)', param: 'void *') -> "void":
    return _obspython.obs_enum_scenes(enum_proc, param)
obs_enum_scenes = _obspython.obs_enum_scenes

def obs_enum_outputs(enum_proc: 'bool (*)(void *,obs_output_t *)', param: 'void *') -> "void":
    return _obspython.obs_enum_outputs(enum_proc, param)
obs_enum_outputs = _obspython.obs_enum_outputs

def obs_enum_encoders(enum_proc: 'bool (*)(void *,obs_encoder_t *)', param: 'void *') -> "void":
    return _obspython.obs_enum_encoders(enum_proc, param)
obs_enum_encoders = _obspython.obs_enum_encoders

def obs_enum_services(enum_proc: 'bool (*)(void *,obs_service_t *)', param: 'void *') -> "void":
    return _obspython.obs_enum_services(enum_proc, param)
obs_enum_services = _obspython.obs_enum_services

def obs_get_source_by_name(name: 'char const *') -> "obs_source_t *":
    return _obspython.obs_get_source_by_name(name)
obs_get_source_by_name = _obspython.obs_get_source_by_name

def obs_get_output_by_name(name: 'char const *') -> "obs_output_t *":
    return _obspython.obs_get_output_by_name(name)
obs_get_output_by_name = _obspython.obs_get_output_by_name

def obs_get_encoder_by_name(name: 'char const *') -> "obs_encoder_t *":
    return _obspython.obs_get_encoder_by_name(name)
obs_get_encoder_by_name = _obspython.obs_get_encoder_by_name

def obs_get_service_by_name(name: 'char const *') -> "obs_service_t *":
    return _obspython.obs_get_service_by_name(name)
obs_get_service_by_name = _obspython.obs_get_service_by_name
OBS_EFFECT_DEFAULT = _obspython.OBS_EFFECT_DEFAULT
OBS_EFFECT_DEFAULT_RECT = _obspython.OBS_EFFECT_DEFAULT_RECT
OBS_EFFECT_OPAQUE = _obspython.OBS_EFFECT_OPAQUE
OBS_EFFECT_SOLID = _obspython.OBS_EFFECT_SOLID
OBS_EFFECT_BICUBIC = _obspython.OBS_EFFECT_BICUBIC
OBS_EFFECT_LANCZOS = _obspython.OBS_EFFECT_LANCZOS
OBS_EFFECT_BILINEAR_LOWRES = _obspython.OBS_EFFECT_BILINEAR_LOWRES
OBS_EFFECT_PREMULTIPLIED_ALPHA = _obspython.OBS_EFFECT_PREMULTIPLIED_ALPHA
OBS_EFFECT_REPEAT = _obspython.OBS_EFFECT_REPEAT
OBS_EFFECT_AREA = _obspython.OBS_EFFECT_AREA

def obs_get_base_effect(effect: 'enum obs_base_effect') -> "gs_effect_t *":
    return _obspython.obs_get_base_effect(effect)
obs_get_base_effect = _obspython.obs_get_base_effect

def obs_get_signal_handler() -> "signal_handler_t *":
    return _obspython.obs_get_signal_handler()
obs_get_signal_handler = _obspython.obs_get_signal_handler

def obs_get_proc_handler() -> "proc_handler_t *":
    return _obspython.obs_get_proc_handler()
obs_get_proc_handler = _obspython.obs_get_proc_handler

def obs_render_main_texture() -> "void":
    return _obspython.obs_render_main_texture()
obs_render_main_texture = _obspython.obs_render_main_texture

def obs_get_main_texture() -> "gs_texture_t *":
    return _obspython.obs_get_main_texture()
obs_get_main_texture = _obspython.obs_get_main_texture

def obs_set_master_volume(volume: 'float') -> "void":
    return _obspython.obs_set_master_volume(volume)
obs_set_master_volume = _obspython.obs_set_master_volume

def obs_get_master_volume() -> "float":
    return _obspython.obs_get_master_volume()
obs_get_master_volume = _obspython.obs_get_master_volume

def obs_save_source(source: 'obs_source_t *') -> "obs_data_t *":
    return _obspython.obs_save_source(source)
obs_save_source = _obspython.obs_save_source

def obs_load_source(data: 'obs_data_t *') -> "obs_source_t *":
    return _obspython.obs_load_source(data)
obs_load_source = _obspython.obs_load_source

def obs_source_save(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_save(source)
obs_source_save = _obspython.obs_source_save

def obs_source_load(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_load(source)
obs_source_load = _obspython.obs_source_load

def obs_load_sources(array: 'obs_data_array_t *', cb: 'obs_load_source_cb', private_data: 'void *') -> "void":
    return _obspython.obs_load_sources(array, cb, private_data)
obs_load_sources = _obspython.obs_load_sources

def obs_save_sources() -> "obs_data_array_t *":
    return _obspython.obs_save_sources()
obs_save_sources = _obspython.obs_save_sources

def obs_save_sources_filtered(cb: 'obs_save_source_filter_cb', data: 'void *') -> "obs_data_array_t *":
    return _obspython.obs_save_sources_filtered(cb, data)
obs_save_sources_filtered = _obspython.obs_save_sources_filtered
OBS_OBJ_TYPE_INVALID = _obspython.OBS_OBJ_TYPE_INVALID
OBS_OBJ_TYPE_SOURCE = _obspython.OBS_OBJ_TYPE_SOURCE
OBS_OBJ_TYPE_OUTPUT = _obspython.OBS_OBJ_TYPE_OUTPUT
OBS_OBJ_TYPE_ENCODER = _obspython.OBS_OBJ_TYPE_ENCODER
OBS_OBJ_TYPE_SERVICE = _obspython.OBS_OBJ_TYPE_SERVICE

def obs_obj_get_type(obj: 'void *') -> "enum obs_obj_type":
    return _obspython.obs_obj_get_type(obj)
obs_obj_get_type = _obspython.obs_obj_get_type

def obs_obj_get_id(obj: 'void *') -> "char const *":
    return _obspython.obs_obj_get_id(obj)
obs_obj_get_id = _obspython.obs_obj_get_id

def obs_obj_invalid(obj: 'void *') -> "bool":
    return _obspython.obs_obj_invalid(obj)
obs_obj_invalid = _obspython.obs_obj_invalid

def obs_obj_get_data(obj: 'void *') -> "void *":
    return _obspython.obs_obj_get_data(obj)
obs_obj_get_data = _obspython.obs_obj_get_data

def obs_enum_audio_monitoring_devices(cb: 'obs_enum_audio_device_cb', data: 'void *') -> "void":
    return _obspython.obs_enum_audio_monitoring_devices(cb, data)
obs_enum_audio_monitoring_devices = _obspython.obs_enum_audio_monitoring_devices

def obs_set_audio_monitoring_device(name: 'char const *', id: 'char const *') -> "bool":
    return _obspython.obs_set_audio_monitoring_device(name, id)
obs_set_audio_monitoring_device = _obspython.obs_set_audio_monitoring_device

def obs_get_audio_monitoring_device(name: 'char const **', id: 'char const **') -> "void":
    return _obspython.obs_get_audio_monitoring_device(name, id)
obs_get_audio_monitoring_device = _obspython.obs_get_audio_monitoring_device

def obs_add_raw_video_callback(conversion: 'struct video_scale_info const *', callback: 'void (*)(void *,struct video_data *)', param: 'void *') -> "void":
    return _obspython.obs_add_raw_video_callback(conversion, callback, param)
obs_add_raw_video_callback = _obspython.obs_add_raw_video_callback

def obs_remove_raw_video_callback(callback: 'void (*)(void *,struct video_data *)', param: 'void *') -> "void":
    return _obspython.obs_remove_raw_video_callback(callback, param)
obs_remove_raw_video_callback = _obspython.obs_remove_raw_video_callback

def obs_get_video_frame_time() -> "uint64_t":
    return _obspython.obs_get_video_frame_time()
obs_get_video_frame_time = _obspython.obs_get_video_frame_time

def obs_get_active_fps() -> "double":
    return _obspython.obs_get_active_fps()
obs_get_active_fps = _obspython.obs_get_active_fps

def obs_get_average_frame_time_ns() -> "uint64_t":
    return _obspython.obs_get_average_frame_time_ns()
obs_get_average_frame_time_ns = _obspython.obs_get_average_frame_time_ns

def obs_get_total_frames() -> "uint32_t":
    return _obspython.obs_get_total_frames()
obs_get_total_frames = _obspython.obs_get_total_frames

def obs_get_lagged_frames() -> "uint32_t":
    return _obspython.obs_get_lagged_frames()
obs_get_lagged_frames = _obspython.obs_get_lagged_frames

def obs_nv12_tex_active() -> "bool":
    return _obspython.obs_nv12_tex_active()
obs_nv12_tex_active = _obspython.obs_nv12_tex_active

def obs_apply_private_data(settings: 'obs_data_t *') -> "void":
    return _obspython.obs_apply_private_data(settings)
obs_apply_private_data = _obspython.obs_apply_private_data

def obs_set_private_data(settings: 'obs_data_t *') -> "void":
    return _obspython.obs_set_private_data(settings)
obs_set_private_data = _obspython.obs_set_private_data

def obs_get_private_data() -> "obs_data_t *":
    return _obspython.obs_get_private_data()
obs_get_private_data = _obspython.obs_get_private_data

def obs_view_create() -> "obs_view_t *":
    return _obspython.obs_view_create()
obs_view_create = _obspython.obs_view_create

def obs_view_destroy(view: 'obs_view_t *') -> "void":
    return _obspython.obs_view_destroy(view)
obs_view_destroy = _obspython.obs_view_destroy

def obs_view_set_source(view: 'obs_view_t *', channel: 'uint32_t', source: 'obs_source_t *') -> "void":
    return _obspython.obs_view_set_source(view, channel, source)
obs_view_set_source = _obspython.obs_view_set_source

def obs_view_get_source(view: 'obs_view_t *', channel: 'uint32_t') -> "obs_source_t *":
    return _obspython.obs_view_get_source(view, channel)
obs_view_get_source = _obspython.obs_view_get_source

def obs_view_render(view: 'obs_view_t *') -> "void":
    return _obspython.obs_view_render(view)
obs_view_render = _obspython.obs_view_render

def obs_display_create(graphics_data: 'gs_init_data', backround_color: 'uint32_t') -> "obs_display_t *":
    return _obspython.obs_display_create(graphics_data, backround_color)
obs_display_create = _obspython.obs_display_create

def obs_display_destroy(display: 'obs_display_t *') -> "void":
    return _obspython.obs_display_destroy(display)
obs_display_destroy = _obspython.obs_display_destroy

def obs_display_resize(display: 'obs_display_t *', cx: 'uint32_t', cy: 'uint32_t') -> "void":
    return _obspython.obs_display_resize(display, cx, cy)
obs_display_resize = _obspython.obs_display_resize

def obs_display_add_draw_callback(display: 'obs_display_t *', draw: 'void (*)(void *,uint32_t,uint32_t)', param: 'void *') -> "void":
    return _obspython.obs_display_add_draw_callback(display, draw, param)
obs_display_add_draw_callback = _obspython.obs_display_add_draw_callback

def obs_display_remove_draw_callback(display: 'obs_display_t *', draw: 'void (*)(void *,uint32_t,uint32_t)', param: 'void *') -> "void":
    return _obspython.obs_display_remove_draw_callback(display, draw, param)
obs_display_remove_draw_callback = _obspython.obs_display_remove_draw_callback

def obs_display_set_enabled(display: 'obs_display_t *', enable: 'bool') -> "void":
    return _obspython.obs_display_set_enabled(display, enable)
obs_display_set_enabled = _obspython.obs_display_set_enabled

def obs_display_enabled(display: 'obs_display_t *') -> "bool":
    return _obspython.obs_display_enabled(display)
obs_display_enabled = _obspython.obs_display_enabled

def obs_display_set_background_color(display: 'obs_display_t *', color: 'uint32_t') -> "void":
    return _obspython.obs_display_set_background_color(display, color)
obs_display_set_background_color = _obspython.obs_display_set_background_color

def obs_source_get_display_name(id: 'char const *') -> "char const *":
    return _obspython.obs_source_get_display_name(id)
obs_source_get_display_name = _obspython.obs_source_get_display_name

def obs_source_create(id: 'char const *', name: 'char const *', settings: 'obs_data_t *', hotkey_data: 'obs_data_t *') -> "obs_source_t *":
    return _obspython.obs_source_create(id, name, settings, hotkey_data)
obs_source_create = _obspython.obs_source_create

def obs_source_create_private(id: 'char const *', name: 'char const *', settings: 'obs_data_t *') -> "obs_source_t *":
    return _obspython.obs_source_create_private(id, name, settings)
obs_source_create_private = _obspython.obs_source_create_private

def obs_source_duplicate(source: 'obs_source_t *', desired_name: 'char const *', create_private: 'bool') -> "obs_source_t *":
    return _obspython.obs_source_duplicate(source, desired_name, create_private)
obs_source_duplicate = _obspython.obs_source_duplicate

def obs_source_addref(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_addref(source)
obs_source_addref = _obspython.obs_source_addref

def obs_source_release(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_release(source)
obs_source_release = _obspython.obs_source_release

def obs_weak_source_addref(weak: 'obs_weak_source_t *') -> "void":
    return _obspython.obs_weak_source_addref(weak)
obs_weak_source_addref = _obspython.obs_weak_source_addref

def obs_weak_source_release(weak: 'obs_weak_source_t *') -> "void":
    return _obspython.obs_weak_source_release(weak)
obs_weak_source_release = _obspython.obs_weak_source_release

def obs_source_get_ref(source: 'obs_source_t *') -> "obs_source_t *":
    return _obspython.obs_source_get_ref(source)
obs_source_get_ref = _obspython.obs_source_get_ref

def obs_source_get_weak_source(source: 'obs_source_t *') -> "obs_weak_source_t *":
    return _obspython.obs_source_get_weak_source(source)
obs_source_get_weak_source = _obspython.obs_source_get_weak_source

def obs_weak_source_get_source(weak: 'obs_weak_source_t *') -> "obs_source_t *":
    return _obspython.obs_weak_source_get_source(weak)
obs_weak_source_get_source = _obspython.obs_weak_source_get_source

def obs_weak_source_references_source(weak: 'obs_weak_source_t *', source: 'obs_source_t *') -> "bool":
    return _obspython.obs_weak_source_references_source(weak, source)
obs_weak_source_references_source = _obspython.obs_weak_source_references_source

def obs_source_remove(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_remove(source)
obs_source_remove = _obspython.obs_source_remove

def obs_source_removed(source: 'obs_source_t const *') -> "bool":
    return _obspython.obs_source_removed(source)
obs_source_removed = _obspython.obs_source_removed

def obs_source_get_output_flags(source: 'obs_source_t const *') -> "uint32_t":
    return _obspython.obs_source_get_output_flags(source)
obs_source_get_output_flags = _obspython.obs_source_get_output_flags

def obs_get_source_output_flags(id: 'char const *') -> "uint32_t":
    return _obspython.obs_get_source_output_flags(id)
obs_get_source_output_flags = _obspython.obs_get_source_output_flags

def obs_get_source_defaults(id: 'char const *') -> "obs_data_t *":
    return _obspython.obs_get_source_defaults(id)
obs_get_source_defaults = _obspython.obs_get_source_defaults

def obs_get_source_properties(id: 'char const *') -> "obs_properties_t *":
    return _obspython.obs_get_source_properties(id)
obs_get_source_properties = _obspython.obs_get_source_properties

def obs_is_source_configurable(id: 'char const *') -> "bool":
    return _obspython.obs_is_source_configurable(id)
obs_is_source_configurable = _obspython.obs_is_source_configurable

def obs_source_configurable(source: 'obs_source_t const *') -> "bool":
    return _obspython.obs_source_configurable(source)
obs_source_configurable = _obspython.obs_source_configurable

def obs_source_properties(source: 'obs_source_t const *') -> "obs_properties_t *":
    return _obspython.obs_source_properties(source)
obs_source_properties = _obspython.obs_source_properties

def obs_source_update(source: 'obs_source_t *', settings: 'obs_data_t *') -> "void":
    return _obspython.obs_source_update(source, settings)
obs_source_update = _obspython.obs_source_update

def obs_source_video_render(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_video_render(source)
obs_source_video_render = _obspython.obs_source_video_render

def obs_source_get_width(source: 'obs_source_t *') -> "uint32_t":
    return _obspython.obs_source_get_width(source)
obs_source_get_width = _obspython.obs_source_get_width

def obs_source_get_height(source: 'obs_source_t *') -> "uint32_t":
    return _obspython.obs_source_get_height(source)
obs_source_get_height = _obspython.obs_source_get_height

def obs_filter_get_parent(filter: 'obs_source_t const *') -> "obs_source_t *":
    return _obspython.obs_filter_get_parent(filter)
obs_filter_get_parent = _obspython.obs_filter_get_parent

def obs_filter_get_target(filter: 'obs_source_t const *') -> "obs_source_t *":
    return _obspython.obs_filter_get_target(filter)
obs_filter_get_target = _obspython.obs_filter_get_target

def obs_source_default_render(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_default_render(source)
obs_source_default_render = _obspython.obs_source_default_render

def obs_source_filter_add(source: 'obs_source_t *', filter: 'obs_source_t *') -> "void":
    return _obspython.obs_source_filter_add(source, filter)
obs_source_filter_add = _obspython.obs_source_filter_add

def obs_source_filter_remove(source: 'obs_source_t *', filter: 'obs_source_t *') -> "void":
    return _obspython.obs_source_filter_remove(source, filter)
obs_source_filter_remove = _obspython.obs_source_filter_remove

def obs_source_filter_set_order(source: 'obs_source_t *', filter: 'obs_source_t *', movement: 'enum obs_order_movement') -> "void":
    return _obspython.obs_source_filter_set_order(source, filter, movement)
obs_source_filter_set_order = _obspython.obs_source_filter_set_order

def obs_source_get_settings(source: 'obs_source_t const *') -> "obs_data_t *":
    return _obspython.obs_source_get_settings(source)
obs_source_get_settings = _obspython.obs_source_get_settings

def obs_source_get_name(source: 'obs_source_t const *') -> "char const *":
    return _obspython.obs_source_get_name(source)
obs_source_get_name = _obspython.obs_source_get_name

def obs_source_set_name(source: 'obs_source_t *', name: 'char const *') -> "void":
    return _obspython.obs_source_set_name(source, name)
obs_source_set_name = _obspython.obs_source_set_name

def obs_source_get_type(source: 'obs_source_t const *') -> "enum obs_source_type":
    return _obspython.obs_source_get_type(source)
obs_source_get_type = _obspython.obs_source_get_type

def obs_source_get_id(source: 'obs_source_t const *') -> "char const *":
    return _obspython.obs_source_get_id(source)
obs_source_get_id = _obspython.obs_source_get_id

def obs_source_get_signal_handler(source: 'obs_source_t const *') -> "signal_handler_t *":
    return _obspython.obs_source_get_signal_handler(source)
obs_source_get_signal_handler = _obspython.obs_source_get_signal_handler

def obs_source_get_proc_handler(source: 'obs_source_t const *') -> "proc_handler_t *":
    return _obspython.obs_source_get_proc_handler(source)
obs_source_get_proc_handler = _obspython.obs_source_get_proc_handler

def obs_source_set_volume(source: 'obs_source_t *', volume: 'float') -> "void":
    return _obspython.obs_source_set_volume(source, volume)
obs_source_set_volume = _obspython.obs_source_set_volume

def obs_source_get_volume(source: 'obs_source_t const *') -> "float":
    return _obspython.obs_source_get_volume(source)
obs_source_get_volume = _obspython.obs_source_get_volume

def obs_source_get_speaker_layout(source: 'obs_source_t *') -> "enum speaker_layout":
    return _obspython.obs_source_get_speaker_layout(source)
obs_source_get_speaker_layout = _obspython.obs_source_get_speaker_layout

def obs_source_set_balance_value(source: 'obs_source_t *', balance: 'float') -> "void":
    return _obspython.obs_source_set_balance_value(source, balance)
obs_source_set_balance_value = _obspython.obs_source_set_balance_value

def obs_source_get_balance_value(source: 'obs_source_t const *') -> "float":
    return _obspython.obs_source_get_balance_value(source)
obs_source_get_balance_value = _obspython.obs_source_get_balance_value

def obs_source_set_sync_offset(source: 'obs_source_t *', offset: 'int64_t') -> "void":
    return _obspython.obs_source_set_sync_offset(source, offset)
obs_source_set_sync_offset = _obspython.obs_source_set_sync_offset

def obs_source_get_sync_offset(source: 'obs_source_t const *') -> "int64_t":
    return _obspython.obs_source_get_sync_offset(source)
obs_source_get_sync_offset = _obspython.obs_source_get_sync_offset

def obs_source_enum_active_sources(source: 'obs_source_t *', enum_callback: 'obs_source_enum_proc_t', param: 'void *') -> "void":
    return _obspython.obs_source_enum_active_sources(source, enum_callback, param)
obs_source_enum_active_sources = _obspython.obs_source_enum_active_sources

def obs_source_enum_active_tree(source: 'obs_source_t *', enum_callback: 'obs_source_enum_proc_t', param: 'void *') -> "void":
    return _obspython.obs_source_enum_active_tree(source, enum_callback, param)
obs_source_enum_active_tree = _obspython.obs_source_enum_active_tree

def obs_source_active(source: 'obs_source_t const *') -> "bool":
    return _obspython.obs_source_active(source)
obs_source_active = _obspython.obs_source_active

def obs_source_showing(source: 'obs_source_t const *') -> "bool":
    return _obspython.obs_source_showing(source)
obs_source_showing = _obspython.obs_source_showing
OBS_SOURCE_FLAG_UNUSED_1 = _obspython.OBS_SOURCE_FLAG_UNUSED_1
OBS_SOURCE_FLAG_FORCE_MONO = _obspython.OBS_SOURCE_FLAG_FORCE_MONO

def obs_source_set_flags(source: 'obs_source_t *', flags: 'uint32_t') -> "void":
    return _obspython.obs_source_set_flags(source, flags)
obs_source_set_flags = _obspython.obs_source_set_flags

def obs_source_get_flags(source: 'obs_source_t const *') -> "uint32_t":
    return _obspython.obs_source_get_flags(source)
obs_source_get_flags = _obspython.obs_source_get_flags

def obs_source_set_audio_mixers(source: 'obs_source_t *', mixers: 'uint32_t') -> "void":
    return _obspython.obs_source_set_audio_mixers(source, mixers)
obs_source_set_audio_mixers = _obspython.obs_source_set_audio_mixers

def obs_source_get_audio_mixers(source: 'obs_source_t const *') -> "uint32_t":
    return _obspython.obs_source_get_audio_mixers(source)
obs_source_get_audio_mixers = _obspython.obs_source_get_audio_mixers

def obs_source_inc_showing(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_inc_showing(source)
obs_source_inc_showing = _obspython.obs_source_inc_showing

def obs_source_dec_showing(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_dec_showing(source)
obs_source_dec_showing = _obspython.obs_source_dec_showing

def obs_source_enum_filters(source: 'obs_source_t *', callback: 'obs_source_enum_proc_t', param: 'void *') -> "void":
    return _obspython.obs_source_enum_filters(source, callback, param)
obs_source_enum_filters = _obspython.obs_source_enum_filters

def obs_source_get_filter_by_name(source: 'obs_source_t *', name: 'char const *') -> "obs_source_t *":
    return _obspython.obs_source_get_filter_by_name(source, name)
obs_source_get_filter_by_name = _obspython.obs_source_get_filter_by_name

def obs_source_copy_filters(dst: 'obs_source_t *', src: 'obs_source_t *') -> "void":
    return _obspython.obs_source_copy_filters(dst, src)
obs_source_copy_filters = _obspython.obs_source_copy_filters

def obs_source_enabled(source: 'obs_source_t const *') -> "bool":
    return _obspython.obs_source_enabled(source)
obs_source_enabled = _obspython.obs_source_enabled

def obs_source_set_enabled(source: 'obs_source_t *', enabled: 'bool') -> "void":
    return _obspython.obs_source_set_enabled(source, enabled)
obs_source_set_enabled = _obspython.obs_source_set_enabled

def obs_source_muted(source: 'obs_source_t const *') -> "bool":
    return _obspython.obs_source_muted(source)
obs_source_muted = _obspython.obs_source_muted

def obs_source_set_muted(source: 'obs_source_t *', muted: 'bool') -> "void":
    return _obspython.obs_source_set_muted(source, muted)
obs_source_set_muted = _obspython.obs_source_set_muted

def obs_source_push_to_mute_enabled(source: 'obs_source_t *') -> "bool":
    return _obspython.obs_source_push_to_mute_enabled(source)
obs_source_push_to_mute_enabled = _obspython.obs_source_push_to_mute_enabled

def obs_source_enable_push_to_mute(source: 'obs_source_t *', enabled: 'bool') -> "void":
    return _obspython.obs_source_enable_push_to_mute(source, enabled)
obs_source_enable_push_to_mute = _obspython.obs_source_enable_push_to_mute

def obs_source_get_push_to_mute_delay(source: 'obs_source_t *') -> "uint64_t":
    return _obspython.obs_source_get_push_to_mute_delay(source)
obs_source_get_push_to_mute_delay = _obspython.obs_source_get_push_to_mute_delay

def obs_source_set_push_to_mute_delay(source: 'obs_source_t *', delay: 'uint64_t') -> "void":
    return _obspython.obs_source_set_push_to_mute_delay(source, delay)
obs_source_set_push_to_mute_delay = _obspython.obs_source_set_push_to_mute_delay

def obs_source_push_to_talk_enabled(source: 'obs_source_t *') -> "bool":
    return _obspython.obs_source_push_to_talk_enabled(source)
obs_source_push_to_talk_enabled = _obspython.obs_source_push_to_talk_enabled

def obs_source_enable_push_to_talk(source: 'obs_source_t *', enabled: 'bool') -> "void":
    return _obspython.obs_source_enable_push_to_talk(source, enabled)
obs_source_enable_push_to_talk = _obspython.obs_source_enable_push_to_talk

def obs_source_get_push_to_talk_delay(source: 'obs_source_t *') -> "uint64_t":
    return _obspython.obs_source_get_push_to_talk_delay(source)
obs_source_get_push_to_talk_delay = _obspython.obs_source_get_push_to_talk_delay

def obs_source_set_push_to_talk_delay(source: 'obs_source_t *', delay: 'uint64_t') -> "void":
    return _obspython.obs_source_set_push_to_talk_delay(source, delay)
obs_source_set_push_to_talk_delay = _obspython.obs_source_set_push_to_talk_delay

def obs_source_add_audio_capture_callback(source: 'obs_source_t *', callback: 'obs_source_audio_capture_t', param: 'void *') -> "void":
    return _obspython.obs_source_add_audio_capture_callback(source, callback, param)
obs_source_add_audio_capture_callback = _obspython.obs_source_add_audio_capture_callback

def obs_source_remove_audio_capture_callback(source: 'obs_source_t *', callback: 'obs_source_audio_capture_t', param: 'void *') -> "void":
    return _obspython.obs_source_remove_audio_capture_callback(source, callback, param)
obs_source_remove_audio_capture_callback = _obspython.obs_source_remove_audio_capture_callback
OBS_DEINTERLACE_MODE_DISABLE = _obspython.OBS_DEINTERLACE_MODE_DISABLE
OBS_DEINTERLACE_MODE_DISCARD = _obspython.OBS_DEINTERLACE_MODE_DISCARD
OBS_DEINTERLACE_MODE_RETRO = _obspython.OBS_DEINTERLACE_MODE_RETRO
OBS_DEINTERLACE_MODE_BLEND = _obspython.OBS_DEINTERLACE_MODE_BLEND
OBS_DEINTERLACE_MODE_BLEND_2X = _obspython.OBS_DEINTERLACE_MODE_BLEND_2X
OBS_DEINTERLACE_MODE_LINEAR = _obspython.OBS_DEINTERLACE_MODE_LINEAR
OBS_DEINTERLACE_MODE_LINEAR_2X = _obspython.OBS_DEINTERLACE_MODE_LINEAR_2X
OBS_DEINTERLACE_MODE_YADIF = _obspython.OBS_DEINTERLACE_MODE_YADIF
OBS_DEINTERLACE_MODE_YADIF_2X = _obspython.OBS_DEINTERLACE_MODE_YADIF_2X
OBS_DEINTERLACE_FIELD_ORDER_TOP = _obspython.OBS_DEINTERLACE_FIELD_ORDER_TOP
OBS_DEINTERLACE_FIELD_ORDER_BOTTOM = _obspython.OBS_DEINTERLACE_FIELD_ORDER_BOTTOM

def obs_source_set_deinterlace_mode(source: 'obs_source_t *', mode: 'enum obs_deinterlace_mode') -> "void":
    return _obspython.obs_source_set_deinterlace_mode(source, mode)
obs_source_set_deinterlace_mode = _obspython.obs_source_set_deinterlace_mode

def obs_source_get_deinterlace_mode(source: 'obs_source_t const *') -> "enum obs_deinterlace_mode":
    return _obspython.obs_source_get_deinterlace_mode(source)
obs_source_get_deinterlace_mode = _obspython.obs_source_get_deinterlace_mode

def obs_source_set_deinterlace_field_order(source: 'obs_source_t *', field_order: 'enum obs_deinterlace_field_order') -> "void":
    return _obspython.obs_source_set_deinterlace_field_order(source, field_order)
obs_source_set_deinterlace_field_order = _obspython.obs_source_set_deinterlace_field_order

def obs_source_get_deinterlace_field_order(source: 'obs_source_t const *') -> "enum obs_deinterlace_field_order":
    return _obspython.obs_source_get_deinterlace_field_order(source)
obs_source_get_deinterlace_field_order = _obspython.obs_source_get_deinterlace_field_order
OBS_MONITORING_TYPE_NONE = _obspython.OBS_MONITORING_TYPE_NONE
OBS_MONITORING_TYPE_MONITOR_ONLY = _obspython.OBS_MONITORING_TYPE_MONITOR_ONLY
OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT = _obspython.OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT

def obs_source_set_monitoring_type(source: 'obs_source_t *', type: 'enum obs_monitoring_type') -> "void":
    return _obspython.obs_source_set_monitoring_type(source, type)
obs_source_set_monitoring_type = _obspython.obs_source_set_monitoring_type

def obs_source_get_monitoring_type(source: 'obs_source_t const *') -> "enum obs_monitoring_type":
    return _obspython.obs_source_get_monitoring_type(source)
obs_source_get_monitoring_type = _obspython.obs_source_get_monitoring_type

def obs_source_get_private_settings(item: 'obs_source_t *') -> "obs_data_t *":
    return _obspython.obs_source_get_private_settings(item)
obs_source_get_private_settings = _obspython.obs_source_get_private_settings

def obs_source_get_type_data(source: 'obs_source_t *') -> "void *":
    return _obspython.obs_source_get_type_data(source)
obs_source_get_type_data = _obspython.obs_source_get_type_data

def obs_source_draw_set_color_matrix(color_matrix: 'struct matrix4 const *', color_range_min: 'vec3', color_range_max: 'vec3') -> "void":
    return _obspython.obs_source_draw_set_color_matrix(color_matrix, color_range_min, color_range_max)
obs_source_draw_set_color_matrix = _obspython.obs_source_draw_set_color_matrix

def obs_source_draw(image: 'gs_texture_t *', x: 'int', y: 'int', cx: 'uint32_t', cy: 'uint32_t', flip: 'bool') -> "void":
    return _obspython.obs_source_draw(image, x, y, cx, cy, flip)
obs_source_draw = _obspython.obs_source_draw

def obs_source_output_video(source: 'obs_source_t *', frame: 'obs_source_frame') -> "void":
    return _obspython.obs_source_output_video(source, frame)
obs_source_output_video = _obspython.obs_source_output_video

def obs_source_preload_video(source: 'obs_source_t *', frame: 'obs_source_frame') -> "void":
    return _obspython.obs_source_preload_video(source, frame)
obs_source_preload_video = _obspython.obs_source_preload_video

def obs_source_show_preloaded_video(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_show_preloaded_video(source)
obs_source_show_preloaded_video = _obspython.obs_source_show_preloaded_video

def obs_source_output_audio(source: 'obs_source_t *', audio: 'obs_source_audio') -> "void":
    return _obspython.obs_source_output_audio(source, audio)
obs_source_output_audio = _obspython.obs_source_output_audio

def obs_source_update_properties(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_update_properties(source)
obs_source_update_properties = _obspython.obs_source_update_properties

def obs_source_get_frame(source: 'obs_source_t *') -> "struct obs_source_frame *":
    return _obspython.obs_source_get_frame(source)
obs_source_get_frame = _obspython.obs_source_get_frame

def obs_source_release_frame(source: 'obs_source_t *', frame: 'obs_source_frame') -> "void":
    return _obspython.obs_source_release_frame(source, frame)
obs_source_release_frame = _obspython.obs_source_release_frame

def obs_source_process_filter_begin(filter: 'obs_source_t *', format: 'enum gs_color_format', allow_direct: 'enum obs_allow_direct_render') -> "bool":
    return _obspython.obs_source_process_filter_begin(filter, format, allow_direct)
obs_source_process_filter_begin = _obspython.obs_source_process_filter_begin

def obs_source_process_filter_end(filter: 'obs_source_t *', effect: 'gs_effect_t *', width: 'uint32_t', height: 'uint32_t') -> "void":
    return _obspython.obs_source_process_filter_end(filter, effect, width, height)
obs_source_process_filter_end = _obspython.obs_source_process_filter_end

def obs_source_process_filter_tech_end(filter: 'obs_source_t *', effect: 'gs_effect_t *', width: 'uint32_t', height: 'uint32_t', tech_name: 'char const *') -> "void":
    return _obspython.obs_source_process_filter_tech_end(filter, effect, width, height, tech_name)
obs_source_process_filter_tech_end = _obspython.obs_source_process_filter_tech_end

def obs_source_skip_video_filter(filter: 'obs_source_t *') -> "void":
    return _obspython.obs_source_skip_video_filter(filter)
obs_source_skip_video_filter = _obspython.obs_source_skip_video_filter

def obs_source_add_active_child(parent: 'obs_source_t *', child: 'obs_source_t *') -> "bool":
    return _obspython.obs_source_add_active_child(parent, child)
obs_source_add_active_child = _obspython.obs_source_add_active_child

def obs_source_remove_active_child(parent: 'obs_source_t *', child: 'obs_source_t *') -> "void":
    return _obspython.obs_source_remove_active_child(parent, child)
obs_source_remove_active_child = _obspython.obs_source_remove_active_child

def obs_source_send_mouse_click(source: 'obs_source_t *', event: 'obs_mouse_event', type: 'int32_t', mouse_up: 'bool', click_count: 'uint32_t') -> "void":
    return _obspython.obs_source_send_mouse_click(source, event, type, mouse_up, click_count)
obs_source_send_mouse_click = _obspython.obs_source_send_mouse_click

def obs_source_send_mouse_move(source: 'obs_source_t *', event: 'obs_mouse_event', mouse_leave: 'bool') -> "void":
    return _obspython.obs_source_send_mouse_move(source, event, mouse_leave)
obs_source_send_mouse_move = _obspython.obs_source_send_mouse_move

def obs_source_send_mouse_wheel(source: 'obs_source_t *', event: 'obs_mouse_event', x_delta: 'int', y_delta: 'int') -> "void":
    return _obspython.obs_source_send_mouse_wheel(source, event, x_delta, y_delta)
obs_source_send_mouse_wheel = _obspython.obs_source_send_mouse_wheel

def obs_source_send_focus(source: 'obs_source_t *', focus: 'bool') -> "void":
    return _obspython.obs_source_send_focus(source, focus)
obs_source_send_focus = _obspython.obs_source_send_focus

def obs_source_send_key_click(source: 'obs_source_t *', event: 'obs_key_event', key_up: 'bool') -> "void":
    return _obspython.obs_source_send_key_click(source, event, key_up)
obs_source_send_key_click = _obspython.obs_source_send_key_click

def obs_source_set_default_flags(source: 'obs_source_t *', flags: 'uint32_t') -> "void":
    return _obspython.obs_source_set_default_flags(source, flags)
obs_source_set_default_flags = _obspython.obs_source_set_default_flags

def obs_source_get_base_width(source: 'obs_source_t *') -> "uint32_t":
    return _obspython.obs_source_get_base_width(source)
obs_source_get_base_width = _obspython.obs_source_get_base_width

def obs_source_get_base_height(source: 'obs_source_t *') -> "uint32_t":
    return _obspython.obs_source_get_base_height(source)
obs_source_get_base_height = _obspython.obs_source_get_base_height

def obs_source_audio_pending(source: 'obs_source_t const *') -> "bool":
    return _obspython.obs_source_audio_pending(source)
obs_source_audio_pending = _obspython.obs_source_audio_pending

def obs_source_get_audio_timestamp(source: 'obs_source_t const *') -> "uint64_t":
    return _obspython.obs_source_get_audio_timestamp(source)
obs_source_get_audio_timestamp = _obspython.obs_source_get_audio_timestamp

def obs_source_get_audio_mix(source: 'obs_source_t const *', audio: 'obs_source_audio_mix') -> "void":
    return _obspython.obs_source_get_audio_mix(source, audio)
obs_source_get_audio_mix = _obspython.obs_source_get_audio_mix

def obs_source_set_async_unbuffered(source: 'obs_source_t *', unbuffered: 'bool') -> "void":
    return _obspython.obs_source_set_async_unbuffered(source, unbuffered)
obs_source_set_async_unbuffered = _obspython.obs_source_set_async_unbuffered

def obs_source_async_unbuffered(source: 'obs_source_t const *') -> "bool":
    return _obspython.obs_source_async_unbuffered(source)
obs_source_async_unbuffered = _obspython.obs_source_async_unbuffered

def obs_source_set_async_decoupled(source: 'obs_source_t *', decouple: 'bool') -> "void":
    return _obspython.obs_source_set_async_decoupled(source, decouple)
obs_source_set_async_decoupled = _obspython.obs_source_set_async_decoupled

def obs_source_async_decoupled(source: 'obs_source_t const *') -> "bool":
    return _obspython.obs_source_async_decoupled(source)
obs_source_async_decoupled = _obspython.obs_source_async_decoupled
OBS_TRANSITION_SOURCE_A = _obspython.OBS_TRANSITION_SOURCE_A
OBS_TRANSITION_SOURCE_B = _obspython.OBS_TRANSITION_SOURCE_B

def obs_transition_get_source(transition: 'obs_source_t *', target: 'enum obs_transition_target') -> "obs_source_t *":
    return _obspython.obs_transition_get_source(transition, target)
obs_transition_get_source = _obspython.obs_transition_get_source

def obs_transition_clear(transition: 'obs_source_t *') -> "void":
    return _obspython.obs_transition_clear(transition)
obs_transition_clear = _obspython.obs_transition_clear

def obs_transition_get_active_source(transition: 'obs_source_t *') -> "obs_source_t *":
    return _obspython.obs_transition_get_active_source(transition)
obs_transition_get_active_source = _obspython.obs_transition_get_active_source
OBS_TRANSITION_MODE_AUTO = _obspython.OBS_TRANSITION_MODE_AUTO

def obs_transition_start(transition: 'obs_source_t *', mode: 'enum obs_transition_mode', duration_ms: 'uint32_t', dest: 'obs_source_t *') -> "bool":
    return _obspython.obs_transition_start(transition, mode, duration_ms, dest)
obs_transition_start = _obspython.obs_transition_start

def obs_transition_set(transition: 'obs_source_t *', source: 'obs_source_t *') -> "void":
    return _obspython.obs_transition_set(transition, source)
obs_transition_set = _obspython.obs_transition_set
OBS_TRANSITION_SCALE_MAX_ONLY = _obspython.OBS_TRANSITION_SCALE_MAX_ONLY
OBS_TRANSITION_SCALE_ASPECT = _obspython.OBS_TRANSITION_SCALE_ASPECT
OBS_TRANSITION_SCALE_STRETCH = _obspython.OBS_TRANSITION_SCALE_STRETCH

def obs_transition_set_scale_type(transition: 'obs_source_t *', type: 'enum obs_transition_scale_type') -> "void":
    return _obspython.obs_transition_set_scale_type(transition, type)
obs_transition_set_scale_type = _obspython.obs_transition_set_scale_type

def obs_transition_get_scale_type(transition: 'obs_source_t const *') -> "enum obs_transition_scale_type":
    return _obspython.obs_transition_get_scale_type(transition)
obs_transition_get_scale_type = _obspython.obs_transition_get_scale_type

def obs_transition_set_alignment(transition: 'obs_source_t *', alignment: 'uint32_t') -> "void":
    return _obspython.obs_transition_set_alignment(transition, alignment)
obs_transition_set_alignment = _obspython.obs_transition_set_alignment

def obs_transition_get_alignment(transition: 'obs_source_t const *') -> "uint32_t":
    return _obspython.obs_transition_get_alignment(transition)
obs_transition_get_alignment = _obspython.obs_transition_get_alignment

def obs_transition_set_size(transition: 'obs_source_t *', cx: 'uint32_t', cy: 'uint32_t') -> "void":
    return _obspython.obs_transition_set_size(transition, cx, cy)
obs_transition_set_size = _obspython.obs_transition_set_size

def obs_transition_get_size(transition: 'obs_source_t const *', cx: 'uint32_t *', cy: 'uint32_t *') -> "void":
    return _obspython.obs_transition_get_size(transition, cx, cy)
obs_transition_get_size = _obspython.obs_transition_get_size

def obs_transition_enable_fixed(transition: 'obs_source_t *', enable: 'bool', duration_ms: 'uint32_t') -> "void":
    return _obspython.obs_transition_enable_fixed(transition, enable, duration_ms)
obs_transition_enable_fixed = _obspython.obs_transition_enable_fixed

def obs_transition_fixed(transition: 'obs_source_t *') -> "bool":
    return _obspython.obs_transition_fixed(transition)
obs_transition_fixed = _obspython.obs_transition_fixed

def obs_transition_get_time(transition: 'obs_source_t *') -> "float":
    return _obspython.obs_transition_get_time(transition)
obs_transition_get_time = _obspython.obs_transition_get_time

def obs_transition_video_render(transition: 'obs_source_t *', callback: 'obs_transition_video_render_callback_t') -> "void":
    return _obspython.obs_transition_video_render(transition, callback)
obs_transition_video_render = _obspython.obs_transition_video_render

def obs_transition_video_render_direct(transition: 'obs_source_t *', target: 'enum obs_transition_target') -> "bool":
    return _obspython.obs_transition_video_render_direct(transition, target)
obs_transition_video_render_direct = _obspython.obs_transition_video_render_direct

def obs_transition_audio_render(transition: 'obs_source_t *', ts_out: 'uint64_t *', audio: 'obs_source_audio_mix', mixers: 'uint32_t', channels: 'size_t', sample_rate: 'size_t', mix_a_callback: 'obs_transition_audio_mix_callback_t', mix_b_callback: 'obs_transition_audio_mix_callback_t') -> "bool":
    return _obspython.obs_transition_audio_render(transition, ts_out, audio, mixers, channels, sample_rate, mix_a_callback, mix_b_callback)
obs_transition_audio_render = _obspython.obs_transition_audio_render

def obs_transition_swap_begin(tr_dest: 'obs_source_t *', tr_source: 'obs_source_t *') -> "void":
    return _obspython.obs_transition_swap_begin(tr_dest, tr_source)
obs_transition_swap_begin = _obspython.obs_transition_swap_begin

def obs_transition_swap_end(tr_dest: 'obs_source_t *', tr_source: 'obs_source_t *') -> "void":
    return _obspython.obs_transition_swap_end(tr_dest, tr_source)
obs_transition_swap_end = _obspython.obs_transition_swap_end

def obs_scene_create(name: 'char const *') -> "obs_scene_t *":
    return _obspython.obs_scene_create(name)
obs_scene_create = _obspython.obs_scene_create

def obs_scene_create_private(name: 'char const *') -> "obs_scene_t *":
    return _obspython.obs_scene_create_private(name)
obs_scene_create_private = _obspython.obs_scene_create_private
OBS_SCENE_DUP_REFS = _obspython.OBS_SCENE_DUP_REFS
OBS_SCENE_DUP_COPY = _obspython.OBS_SCENE_DUP_COPY
OBS_SCENE_DUP_PRIVATE_REFS = _obspython.OBS_SCENE_DUP_PRIVATE_REFS
OBS_SCENE_DUP_PRIVATE_COPY = _obspython.OBS_SCENE_DUP_PRIVATE_COPY

def obs_scene_duplicate(scene: 'obs_scene_t *', name: 'char const *', type: 'enum obs_scene_duplicate_type') -> "obs_scene_t *":
    return _obspython.obs_scene_duplicate(scene, name, type)
obs_scene_duplicate = _obspython.obs_scene_duplicate

def obs_scene_addref(scene: 'obs_scene_t *') -> "void":
    return _obspython.obs_scene_addref(scene)
obs_scene_addref = _obspython.obs_scene_addref

def obs_scene_release(scene: 'obs_scene_t *') -> "void":
    return _obspython.obs_scene_release(scene)
obs_scene_release = _obspython.obs_scene_release

def obs_scene_get_source(scene: 'obs_scene_t const *') -> "obs_source_t *":
    return _obspython.obs_scene_get_source(scene)
obs_scene_get_source = _obspython.obs_scene_get_source

def obs_scene_from_source(source: 'obs_source_t const *') -> "obs_scene_t *":
    return _obspython.obs_scene_from_source(source)
obs_scene_from_source = _obspython.obs_scene_from_source

def obs_scene_find_source(scene: 'obs_scene_t *', name: 'char const *') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_find_source(scene, name)
obs_scene_find_source = _obspython.obs_scene_find_source

def obs_scene_find_sceneitem_by_id(scene: 'obs_scene_t *', id: 'int64_t') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_find_sceneitem_by_id(scene, id)
obs_scene_find_sceneitem_by_id = _obspython.obs_scene_find_sceneitem_by_id

def obs_scene_enum_items(scene: 'obs_scene_t *', callback: 'bool (*)(obs_scene_t *,obs_sceneitem_t *,void *)', param: 'void *') -> "void":
    return _obspython.obs_scene_enum_items(scene, callback, param)
obs_scene_enum_items = _obspython.obs_scene_enum_items

def obs_scene_reorder_items(scene: 'obs_scene_t *', item_order: 'obs_sceneitem_t *const *', item_order_size: 'size_t') -> "bool":
    return _obspython.obs_scene_reorder_items(scene, item_order, item_order_size)
obs_scene_reorder_items = _obspython.obs_scene_reorder_items
class obs_sceneitem_order_info(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_sceneitem_order_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_sceneitem_order_info, name)
    __repr__ = _swig_repr
    __swig_setmethods__["group"] = _obspython.obs_sceneitem_order_info_group_set
    __swig_getmethods__["group"] = _obspython.obs_sceneitem_order_info_group_get
    if _newclass:
        group = _swig_property(_obspython.obs_sceneitem_order_info_group_get, _obspython.obs_sceneitem_order_info_group_set)
    __swig_setmethods__["item"] = _obspython.obs_sceneitem_order_info_item_set
    __swig_getmethods__["item"] = _obspython.obs_sceneitem_order_info_item_get
    if _newclass:
        item = _swig_property(_obspython.obs_sceneitem_order_info_item_get, _obspython.obs_sceneitem_order_info_item_set)

    def __init__(self):
        this = _obspython.new_obs_sceneitem_order_info()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_sceneitem_order_info
    __del__ = lambda self: None
obs_sceneitem_order_info_swigregister = _obspython.obs_sceneitem_order_info_swigregister
obs_sceneitem_order_info_swigregister(obs_sceneitem_order_info)


def obs_scene_reorder_items2(scene: 'obs_scene_t *', item_order: 'obs_sceneitem_order_info', item_order_size: 'size_t') -> "bool":
    return _obspython.obs_scene_reorder_items2(scene, item_order, item_order_size)
obs_scene_reorder_items2 = _obspython.obs_scene_reorder_items2

def obs_scene_add(scene: 'obs_scene_t *', source: 'obs_source_t *') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_add(scene, source)
obs_scene_add = _obspython.obs_scene_add

def obs_scene_atomic_update(scene: 'obs_scene_t *', func: 'obs_scene_atomic_update_func', data: 'void *') -> "void":
    return _obspython.obs_scene_atomic_update(scene, func, data)
obs_scene_atomic_update = _obspython.obs_scene_atomic_update

def obs_sceneitem_addref(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_addref(item)
obs_sceneitem_addref = _obspython.obs_sceneitem_addref

def obs_sceneitem_release(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_release(item)
obs_sceneitem_release = _obspython.obs_sceneitem_release

def obs_sceneitem_remove(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_remove(item)
obs_sceneitem_remove = _obspython.obs_sceneitem_remove

def obs_sceneitem_get_scene(item: 'obs_sceneitem_t const *') -> "obs_scene_t *":
    return _obspython.obs_sceneitem_get_scene(item)
obs_sceneitem_get_scene = _obspython.obs_sceneitem_get_scene

def obs_sceneitem_get_source(item: 'obs_sceneitem_t const *') -> "obs_source_t *":
    return _obspython.obs_sceneitem_get_source(item)
obs_sceneitem_get_source = _obspython.obs_sceneitem_get_source

def obs_sceneitem_select(item: 'obs_sceneitem_t *', select: 'bool') -> "void":
    return _obspython.obs_sceneitem_select(item, select)
obs_sceneitem_select = _obspython.obs_sceneitem_select

def obs_sceneitem_selected(item: 'obs_sceneitem_t const *') -> "bool":
    return _obspython.obs_sceneitem_selected(item)
obs_sceneitem_selected = _obspython.obs_sceneitem_selected

def obs_sceneitem_locked(item: 'obs_sceneitem_t const *') -> "bool":
    return _obspython.obs_sceneitem_locked(item)
obs_sceneitem_locked = _obspython.obs_sceneitem_locked

def obs_sceneitem_set_locked(item: 'obs_sceneitem_t *', lock: 'bool') -> "bool":
    return _obspython.obs_sceneitem_set_locked(item, lock)
obs_sceneitem_set_locked = _obspython.obs_sceneitem_set_locked

def obs_sceneitem_set_pos(item: 'obs_sceneitem_t *', pos: 'vec2') -> "void":
    return _obspython.obs_sceneitem_set_pos(item, pos)
obs_sceneitem_set_pos = _obspython.obs_sceneitem_set_pos

def obs_sceneitem_set_rot(item: 'obs_sceneitem_t *', rot_deg: 'float') -> "void":
    return _obspython.obs_sceneitem_set_rot(item, rot_deg)
obs_sceneitem_set_rot = _obspython.obs_sceneitem_set_rot

def obs_sceneitem_set_scale(item: 'obs_sceneitem_t *', scale: 'vec2') -> "void":
    return _obspython.obs_sceneitem_set_scale(item, scale)
obs_sceneitem_set_scale = _obspython.obs_sceneitem_set_scale

def obs_sceneitem_set_alignment(item: 'obs_sceneitem_t *', alignment: 'uint32_t') -> "void":
    return _obspython.obs_sceneitem_set_alignment(item, alignment)
obs_sceneitem_set_alignment = _obspython.obs_sceneitem_set_alignment

def obs_sceneitem_set_order(item: 'obs_sceneitem_t *', movement: 'enum obs_order_movement') -> "void":
    return _obspython.obs_sceneitem_set_order(item, movement)
obs_sceneitem_set_order = _obspython.obs_sceneitem_set_order

def obs_sceneitem_set_order_position(item: 'obs_sceneitem_t *', position: 'int') -> "void":
    return _obspython.obs_sceneitem_set_order_position(item, position)
obs_sceneitem_set_order_position = _obspython.obs_sceneitem_set_order_position

def obs_sceneitem_set_bounds_type(item: 'obs_sceneitem_t *', type: 'enum obs_bounds_type') -> "void":
    return _obspython.obs_sceneitem_set_bounds_type(item, type)
obs_sceneitem_set_bounds_type = _obspython.obs_sceneitem_set_bounds_type

def obs_sceneitem_set_bounds_alignment(item: 'obs_sceneitem_t *', alignment: 'uint32_t') -> "void":
    return _obspython.obs_sceneitem_set_bounds_alignment(item, alignment)
obs_sceneitem_set_bounds_alignment = _obspython.obs_sceneitem_set_bounds_alignment

def obs_sceneitem_set_bounds(item: 'obs_sceneitem_t *', bounds: 'vec2') -> "void":
    return _obspython.obs_sceneitem_set_bounds(item, bounds)
obs_sceneitem_set_bounds = _obspython.obs_sceneitem_set_bounds

def obs_sceneitem_get_id(item: 'obs_sceneitem_t const *') -> "int64_t":
    return _obspython.obs_sceneitem_get_id(item)
obs_sceneitem_get_id = _obspython.obs_sceneitem_get_id

def obs_sceneitem_get_pos(item: 'obs_sceneitem_t const *', pos: 'vec2') -> "void":
    return _obspython.obs_sceneitem_get_pos(item, pos)
obs_sceneitem_get_pos = _obspython.obs_sceneitem_get_pos

def obs_sceneitem_get_rot(item: 'obs_sceneitem_t const *') -> "float":
    return _obspython.obs_sceneitem_get_rot(item)
obs_sceneitem_get_rot = _obspython.obs_sceneitem_get_rot

def obs_sceneitem_get_scale(item: 'obs_sceneitem_t const *', scale: 'vec2') -> "void":
    return _obspython.obs_sceneitem_get_scale(item, scale)
obs_sceneitem_get_scale = _obspython.obs_sceneitem_get_scale

def obs_sceneitem_get_alignment(item: 'obs_sceneitem_t const *') -> "uint32_t":
    return _obspython.obs_sceneitem_get_alignment(item)
obs_sceneitem_get_alignment = _obspython.obs_sceneitem_get_alignment

def obs_sceneitem_get_bounds_type(item: 'obs_sceneitem_t const *') -> "enum obs_bounds_type":
    return _obspython.obs_sceneitem_get_bounds_type(item)
obs_sceneitem_get_bounds_type = _obspython.obs_sceneitem_get_bounds_type

def obs_sceneitem_get_bounds_alignment(item: 'obs_sceneitem_t const *') -> "uint32_t":
    return _obspython.obs_sceneitem_get_bounds_alignment(item)
obs_sceneitem_get_bounds_alignment = _obspython.obs_sceneitem_get_bounds_alignment

def obs_sceneitem_get_bounds(item: 'obs_sceneitem_t const *', bounds: 'vec2') -> "void":
    return _obspython.obs_sceneitem_get_bounds(item, bounds)
obs_sceneitem_get_bounds = _obspython.obs_sceneitem_get_bounds

def obs_sceneitem_get_info(item: 'obs_sceneitem_t const *', info: 'obs_transform_info') -> "void":
    return _obspython.obs_sceneitem_get_info(item, info)
obs_sceneitem_get_info = _obspython.obs_sceneitem_get_info

def obs_sceneitem_set_info(item: 'obs_sceneitem_t *', info: 'obs_transform_info') -> "void":
    return _obspython.obs_sceneitem_set_info(item, info)
obs_sceneitem_set_info = _obspython.obs_sceneitem_set_info

def obs_sceneitem_get_draw_transform(item: 'obs_sceneitem_t const *', transform: 'struct matrix4 *') -> "void":
    return _obspython.obs_sceneitem_get_draw_transform(item, transform)
obs_sceneitem_get_draw_transform = _obspython.obs_sceneitem_get_draw_transform

def obs_sceneitem_get_box_transform(item: 'obs_sceneitem_t const *', transform: 'struct matrix4 *') -> "void":
    return _obspython.obs_sceneitem_get_box_transform(item, transform)
obs_sceneitem_get_box_transform = _obspython.obs_sceneitem_get_box_transform

def obs_sceneitem_visible(item: 'obs_sceneitem_t const *') -> "bool":
    return _obspython.obs_sceneitem_visible(item)
obs_sceneitem_visible = _obspython.obs_sceneitem_visible

def obs_sceneitem_set_visible(item: 'obs_sceneitem_t *', visible: 'bool') -> "bool":
    return _obspython.obs_sceneitem_set_visible(item, visible)
obs_sceneitem_set_visible = _obspython.obs_sceneitem_set_visible
class obs_sceneitem_crop(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, obs_sceneitem_crop, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, obs_sceneitem_crop, name)
    __repr__ = _swig_repr
    __swig_setmethods__["left"] = _obspython.obs_sceneitem_crop_left_set
    __swig_getmethods__["left"] = _obspython.obs_sceneitem_crop_left_get
    if _newclass:
        left = _swig_property(_obspython.obs_sceneitem_crop_left_get, _obspython.obs_sceneitem_crop_left_set)
    __swig_setmethods__["top"] = _obspython.obs_sceneitem_crop_top_set
    __swig_getmethods__["top"] = _obspython.obs_sceneitem_crop_top_get
    if _newclass:
        top = _swig_property(_obspython.obs_sceneitem_crop_top_get, _obspython.obs_sceneitem_crop_top_set)
    __swig_setmethods__["right"] = _obspython.obs_sceneitem_crop_right_set
    __swig_getmethods__["right"] = _obspython.obs_sceneitem_crop_right_get
    if _newclass:
        right = _swig_property(_obspython.obs_sceneitem_crop_right_get, _obspython.obs_sceneitem_crop_right_set)
    __swig_setmethods__["bottom"] = _obspython.obs_sceneitem_crop_bottom_set
    __swig_getmethods__["bottom"] = _obspython.obs_sceneitem_crop_bottom_get
    if _newclass:
        bottom = _swig_property(_obspython.obs_sceneitem_crop_bottom_get, _obspython.obs_sceneitem_crop_bottom_set)

    def __init__(self):
        this = _obspython.new_obs_sceneitem_crop()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_obs_sceneitem_crop
    __del__ = lambda self: None
obs_sceneitem_crop_swigregister = _obspython.obs_sceneitem_crop_swigregister
obs_sceneitem_crop_swigregister(obs_sceneitem_crop)


def obs_sceneitem_set_crop(item: 'obs_sceneitem_t *', crop: 'obs_sceneitem_crop') -> "void":
    return _obspython.obs_sceneitem_set_crop(item, crop)
obs_sceneitem_set_crop = _obspython.obs_sceneitem_set_crop

def obs_sceneitem_get_crop(item: 'obs_sceneitem_t const *', crop: 'obs_sceneitem_crop') -> "void":
    return _obspython.obs_sceneitem_get_crop(item, crop)
obs_sceneitem_get_crop = _obspython.obs_sceneitem_get_crop

def obs_sceneitem_set_scale_filter(item: 'obs_sceneitem_t *', filter: 'enum obs_scale_type') -> "void":
    return _obspython.obs_sceneitem_set_scale_filter(item, filter)
obs_sceneitem_set_scale_filter = _obspython.obs_sceneitem_set_scale_filter

def obs_sceneitem_get_scale_filter(item: 'obs_sceneitem_t *') -> "enum obs_scale_type":
    return _obspython.obs_sceneitem_get_scale_filter(item)
obs_sceneitem_get_scale_filter = _obspython.obs_sceneitem_get_scale_filter

def obs_sceneitem_force_update_transform(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_force_update_transform(item)
obs_sceneitem_force_update_transform = _obspython.obs_sceneitem_force_update_transform

def obs_sceneitem_defer_update_begin(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_defer_update_begin(item)
obs_sceneitem_defer_update_begin = _obspython.obs_sceneitem_defer_update_begin

def obs_sceneitem_defer_update_end(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_defer_update_end(item)
obs_sceneitem_defer_update_end = _obspython.obs_sceneitem_defer_update_end

def obs_sceneitem_get_private_settings(item: 'obs_sceneitem_t *') -> "obs_data_t *":
    return _obspython.obs_sceneitem_get_private_settings(item)
obs_sceneitem_get_private_settings = _obspython.obs_sceneitem_get_private_settings

def obs_scene_add_group(scene: 'obs_scene_t *', name: 'char const *') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_add_group(scene, name)
obs_scene_add_group = _obspython.obs_scene_add_group

def obs_scene_insert_group(scene: 'obs_scene_t *', name: 'char const *', items: 'obs_sceneitem_t **', count: 'size_t') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_insert_group(scene, name, items, count)
obs_scene_insert_group = _obspython.obs_scene_insert_group

def obs_scene_get_group(scene: 'obs_scene_t *', name: 'char const *') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_get_group(scene, name)
obs_scene_get_group = _obspython.obs_scene_get_group

def obs_sceneitem_is_group(item: 'obs_sceneitem_t *') -> "bool":
    return _obspython.obs_sceneitem_is_group(item)
obs_sceneitem_is_group = _obspython.obs_sceneitem_is_group

def obs_sceneitem_group_get_scene(group: 'obs_sceneitem_t const *') -> "obs_scene_t *":
    return _obspython.obs_sceneitem_group_get_scene(group)
obs_sceneitem_group_get_scene = _obspython.obs_sceneitem_group_get_scene

def obs_sceneitem_group_ungroup(group: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_group_ungroup(group)
obs_sceneitem_group_ungroup = _obspython.obs_sceneitem_group_ungroup

def obs_sceneitem_group_add_item(group: 'obs_sceneitem_t *', item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_group_add_item(group, item)
obs_sceneitem_group_add_item = _obspython.obs_sceneitem_group_add_item

def obs_sceneitem_group_remove_item(group: 'obs_sceneitem_t *', item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_group_remove_item(group, item)
obs_sceneitem_group_remove_item = _obspython.obs_sceneitem_group_remove_item

def obs_sceneitem_get_group(scene: 'obs_scene_t *', item: 'obs_sceneitem_t *') -> "obs_sceneitem_t *":
    return _obspython.obs_sceneitem_get_group(scene, item)
obs_sceneitem_get_group = _obspython.obs_sceneitem_get_group

def obs_source_is_group(source: 'obs_source_t const *') -> "bool":
    return _obspython.obs_source_is_group(source)
obs_source_is_group = _obspython.obs_source_is_group

def obs_scene_is_group(scene: 'obs_scene_t const *') -> "bool":
    return _obspython.obs_scene_is_group(scene)
obs_scene_is_group = _obspython.obs_scene_is_group

def obs_sceneitem_group_enum_items(group: 'obs_sceneitem_t *', callback: 'bool (*)(obs_scene_t *,obs_sceneitem_t *,void *)', param: 'void *') -> "void":
    return _obspython.obs_sceneitem_group_enum_items(group, callback, param)
obs_sceneitem_group_enum_items = _obspython.obs_sceneitem_group_enum_items

def obs_sceneitem_defer_group_resize_begin(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_defer_group_resize_begin(item)
obs_sceneitem_defer_group_resize_begin = _obspython.obs_sceneitem_defer_group_resize_begin

def obs_sceneitem_defer_group_resize_end(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_defer_group_resize_end(item)
obs_sceneitem_defer_group_resize_end = _obspython.obs_sceneitem_defer_group_resize_end

def obs_output_get_display_name(id: 'char const *') -> "char const *":
    return _obspython.obs_output_get_display_name(id)
obs_output_get_display_name = _obspython.obs_output_get_display_name

def obs_output_create(id: 'char const *', name: 'char const *', settings: 'obs_data_t *', hotkey_data: 'obs_data_t *') -> "obs_output_t *":
    return _obspython.obs_output_create(id, name, settings, hotkey_data)
obs_output_create = _obspython.obs_output_create

def obs_output_addref(output: 'obs_output_t *') -> "void":
    return _obspython.obs_output_addref(output)
obs_output_addref = _obspython.obs_output_addref

def obs_output_release(output: 'obs_output_t *') -> "void":
    return _obspython.obs_output_release(output)
obs_output_release = _obspython.obs_output_release

def obs_weak_output_addref(weak: 'obs_weak_output_t *') -> "void":
    return _obspython.obs_weak_output_addref(weak)
obs_weak_output_addref = _obspython.obs_weak_output_addref

def obs_weak_output_release(weak: 'obs_weak_output_t *') -> "void":
    return _obspython.obs_weak_output_release(weak)
obs_weak_output_release = _obspython.obs_weak_output_release

def obs_output_get_ref(output: 'obs_output_t *') -> "obs_output_t *":
    return _obspython.obs_output_get_ref(output)
obs_output_get_ref = _obspython.obs_output_get_ref

def obs_output_get_weak_output(output: 'obs_output_t *') -> "obs_weak_output_t *":
    return _obspython.obs_output_get_weak_output(output)
obs_output_get_weak_output = _obspython.obs_output_get_weak_output

def obs_weak_output_get_output(weak: 'obs_weak_output_t *') -> "obs_output_t *":
    return _obspython.obs_weak_output_get_output(weak)
obs_weak_output_get_output = _obspython.obs_weak_output_get_output

def obs_weak_output_references_output(weak: 'obs_weak_output_t *', output: 'obs_output_t *') -> "bool":
    return _obspython.obs_weak_output_references_output(weak, output)
obs_weak_output_references_output = _obspython.obs_weak_output_references_output

def obs_output_get_name(output: 'obs_output_t const *') -> "char const *":
    return _obspython.obs_output_get_name(output)
obs_output_get_name = _obspython.obs_output_get_name

def obs_output_start(output: 'obs_output_t *') -> "bool":
    return _obspython.obs_output_start(output)
obs_output_start = _obspython.obs_output_start

def obs_output_stop(output: 'obs_output_t *') -> "void":
    return _obspython.obs_output_stop(output)
obs_output_stop = _obspython.obs_output_stop
OBS_OUTPUT_DELAY_PRESERVE = _obspython.OBS_OUTPUT_DELAY_PRESERVE

def obs_output_set_delay(output: 'obs_output_t *', delay_sec: 'uint32_t', flags: 'uint32_t') -> "void":
    return _obspython.obs_output_set_delay(output, delay_sec, flags)
obs_output_set_delay = _obspython.obs_output_set_delay

def obs_output_get_delay(output: 'obs_output_t const *') -> "uint32_t":
    return _obspython.obs_output_get_delay(output)
obs_output_get_delay = _obspython.obs_output_get_delay

def obs_output_get_active_delay(output: 'obs_output_t const *') -> "uint32_t":
    return _obspython.obs_output_get_active_delay(output)
obs_output_get_active_delay = _obspython.obs_output_get_active_delay

def obs_output_force_stop(output: 'obs_output_t *') -> "void":
    return _obspython.obs_output_force_stop(output)
obs_output_force_stop = _obspython.obs_output_force_stop

def obs_output_active(output: 'obs_output_t const *') -> "bool":
    return _obspython.obs_output_active(output)
obs_output_active = _obspython.obs_output_active

def obs_output_get_flags(output: 'obs_output_t const *') -> "uint32_t":
    return _obspython.obs_output_get_flags(output)
obs_output_get_flags = _obspython.obs_output_get_flags

def obs_get_output_flags(id: 'char const *') -> "uint32_t":
    return _obspython.obs_get_output_flags(id)
obs_get_output_flags = _obspython.obs_get_output_flags

def obs_output_defaults(id: 'char const *') -> "obs_data_t *":
    return _obspython.obs_output_defaults(id)
obs_output_defaults = _obspython.obs_output_defaults

def obs_get_output_properties(id: 'char const *') -> "obs_properties_t *":
    return _obspython.obs_get_output_properties(id)
obs_get_output_properties = _obspython.obs_get_output_properties

def obs_output_properties(output: 'obs_output_t const *') -> "obs_properties_t *":
    return _obspython.obs_output_properties(output)
obs_output_properties = _obspython.obs_output_properties

def obs_output_update(output: 'obs_output_t *', settings: 'obs_data_t *') -> "void":
    return _obspython.obs_output_update(output, settings)
obs_output_update = _obspython.obs_output_update

def obs_output_can_pause(output: 'obs_output_t const *') -> "bool":
    return _obspython.obs_output_can_pause(output)
obs_output_can_pause = _obspython.obs_output_can_pause

def obs_output_pause(output: 'obs_output_t *') -> "void":
    return _obspython.obs_output_pause(output)
obs_output_pause = _obspython.obs_output_pause

def obs_output_get_settings(output: 'obs_output_t const *') -> "obs_data_t *":
    return _obspython.obs_output_get_settings(output)
obs_output_get_settings = _obspython.obs_output_get_settings

def obs_output_get_signal_handler(output: 'obs_output_t const *') -> "signal_handler_t *":
    return _obspython.obs_output_get_signal_handler(output)
obs_output_get_signal_handler = _obspython.obs_output_get_signal_handler

def obs_output_get_proc_handler(output: 'obs_output_t const *') -> "proc_handler_t *":
    return _obspython.obs_output_get_proc_handler(output)
obs_output_get_proc_handler = _obspython.obs_output_get_proc_handler

def obs_output_set_media(output: 'obs_output_t *', video: 'video_t *', audio: 'audio_t *') -> "void":
    return _obspython.obs_output_set_media(output, video, audio)
obs_output_set_media = _obspython.obs_output_set_media

def obs_output_audio(output: 'obs_output_t const *') -> "audio_t *":
    return _obspython.obs_output_audio(output)
obs_output_audio = _obspython.obs_output_audio

def obs_output_set_mixer(output: 'obs_output_t *', mixer_idx: 'size_t') -> "void":
    return _obspython.obs_output_set_mixer(output, mixer_idx)
obs_output_set_mixer = _obspython.obs_output_set_mixer

def obs_output_get_mixer(output: 'obs_output_t const *') -> "size_t":
    return _obspython.obs_output_get_mixer(output)
obs_output_get_mixer = _obspython.obs_output_get_mixer

def obs_output_set_mixers(output: 'obs_output_t *', mixers: 'size_t') -> "void":
    return _obspython.obs_output_set_mixers(output, mixers)
obs_output_set_mixers = _obspython.obs_output_set_mixers

def obs_output_get_mixers(output: 'obs_output_t const *') -> "size_t":
    return _obspython.obs_output_get_mixers(output)
obs_output_get_mixers = _obspython.obs_output_get_mixers

def obs_output_set_video_encoder(output: 'obs_output_t *', encoder: 'obs_encoder_t *') -> "void":
    return _obspython.obs_output_set_video_encoder(output, encoder)
obs_output_set_video_encoder = _obspython.obs_output_set_video_encoder

def obs_output_set_audio_encoder(output: 'obs_output_t *', encoder: 'obs_encoder_t *', idx: 'size_t') -> "void":
    return _obspython.obs_output_set_audio_encoder(output, encoder, idx)
obs_output_set_audio_encoder = _obspython.obs_output_set_audio_encoder

def obs_output_get_video_encoder(output: 'obs_output_t const *') -> "obs_encoder_t *":
    return _obspython.obs_output_get_video_encoder(output)
obs_output_get_video_encoder = _obspython.obs_output_get_video_encoder

def obs_output_get_audio_encoder(output: 'obs_output_t const *', idx: 'size_t') -> "obs_encoder_t *":
    return _obspython.obs_output_get_audio_encoder(output, idx)
obs_output_get_audio_encoder = _obspython.obs_output_get_audio_encoder

def obs_output_set_service(output: 'obs_output_t *', service: 'obs_service_t *') -> "void":
    return _obspython.obs_output_set_service(output, service)
obs_output_set_service = _obspython.obs_output_set_service

def obs_output_get_service(output: 'obs_output_t const *') -> "obs_service_t *":
    return _obspython.obs_output_get_service(output)
obs_output_get_service = _obspython.obs_output_get_service

def obs_output_set_reconnect_settings(output: 'obs_output_t *', retry_count: 'int', retry_sec: 'int') -> "void":
    return _obspython.obs_output_set_reconnect_settings(output, retry_count, retry_sec)
obs_output_set_reconnect_settings = _obspython.obs_output_set_reconnect_settings

def obs_output_get_total_bytes(output: 'obs_output_t const *') -> "uint64_t":
    return _obspython.obs_output_get_total_bytes(output)
obs_output_get_total_bytes = _obspython.obs_output_get_total_bytes

def obs_output_get_frames_dropped(output: 'obs_output_t const *') -> "int":
    return _obspython.obs_output_get_frames_dropped(output)
obs_output_get_frames_dropped = _obspython.obs_output_get_frames_dropped

def obs_output_get_total_frames(output: 'obs_output_t const *') -> "int":
    return _obspython.obs_output_get_total_frames(output)
obs_output_get_total_frames = _obspython.obs_output_get_total_frames

def obs_output_set_preferred_size(output: 'obs_output_t *', width: 'uint32_t', height: 'uint32_t') -> "void":
    return _obspython.obs_output_set_preferred_size(output, width, height)
obs_output_set_preferred_size = _obspython.obs_output_set_preferred_size

def obs_output_get_width(output: 'obs_output_t const *') -> "uint32_t":
    return _obspython.obs_output_get_width(output)
obs_output_get_width = _obspython.obs_output_get_width

def obs_output_get_height(output: 'obs_output_t const *') -> "uint32_t":
    return _obspython.obs_output_get_height(output)
obs_output_get_height = _obspython.obs_output_get_height

def obs_output_get_id(output: 'obs_output_t const *') -> "char const *":
    return _obspython.obs_output_get_id(output)
obs_output_get_id = _obspython.obs_output_get_id

def obs_output_get_congestion(output: 'obs_output_t *') -> "float":
    return _obspython.obs_output_get_congestion(output)
obs_output_get_congestion = _obspython.obs_output_get_congestion

def obs_output_get_connect_time_ms(output: 'obs_output_t *') -> "int":
    return _obspython.obs_output_get_connect_time_ms(output)
obs_output_get_connect_time_ms = _obspython.obs_output_get_connect_time_ms

def obs_output_reconnecting(output: 'obs_output_t const *') -> "bool":
    return _obspython.obs_output_reconnecting(output)
obs_output_reconnecting = _obspython.obs_output_reconnecting

def obs_output_set_last_error(output: 'obs_output_t *', message: 'char const *') -> "void":
    return _obspython.obs_output_set_last_error(output, message)
obs_output_set_last_error = _obspython.obs_output_set_last_error

def obs_output_get_last_error(output: 'obs_output_t *') -> "char const *":
    return _obspython.obs_output_get_last_error(output)
obs_output_get_last_error = _obspython.obs_output_get_last_error

def obs_output_get_supported_video_codecs(output: 'obs_output_t const *') -> "char const *":
    return _obspython.obs_output_get_supported_video_codecs(output)
obs_output_get_supported_video_codecs = _obspython.obs_output_get_supported_video_codecs

def obs_output_get_supported_audio_codecs(output: 'obs_output_t const *') -> "char const *":
    return _obspython.obs_output_get_supported_audio_codecs(output)
obs_output_get_supported_audio_codecs = _obspython.obs_output_get_supported_audio_codecs

def obs_output_get_type_data(output: 'obs_output_t *') -> "void *":
    return _obspython.obs_output_get_type_data(output)
obs_output_get_type_data = _obspython.obs_output_get_type_data

def obs_output_set_video_conversion(output: 'obs_output_t *', conversion: 'struct video_scale_info const *') -> "void":
    return _obspython.obs_output_set_video_conversion(output, conversion)
obs_output_set_video_conversion = _obspython.obs_output_set_video_conversion

def obs_output_set_audio_conversion(output: 'obs_output_t *', conversion: 'struct audio_convert_info const *') -> "void":
    return _obspython.obs_output_set_audio_conversion(output, conversion)
obs_output_set_audio_conversion = _obspython.obs_output_set_audio_conversion

def obs_output_can_begin_data_capture(output: 'obs_output_t const *', flags: 'uint32_t') -> "bool":
    return _obspython.obs_output_can_begin_data_capture(output, flags)
obs_output_can_begin_data_capture = _obspython.obs_output_can_begin_data_capture

def obs_output_initialize_encoders(output: 'obs_output_t *', flags: 'uint32_t') -> "bool":
    return _obspython.obs_output_initialize_encoders(output, flags)
obs_output_initialize_encoders = _obspython.obs_output_initialize_encoders

def obs_output_begin_data_capture(output: 'obs_output_t *', flags: 'uint32_t') -> "bool":
    return _obspython.obs_output_begin_data_capture(output, flags)
obs_output_begin_data_capture = _obspython.obs_output_begin_data_capture

def obs_output_end_data_capture(output: 'obs_output_t *') -> "void":
    return _obspython.obs_output_end_data_capture(output)
obs_output_end_data_capture = _obspython.obs_output_end_data_capture

def obs_output_signal_stop(output: 'obs_output_t *', code: 'int') -> "void":
    return _obspython.obs_output_signal_stop(output, code)
obs_output_signal_stop = _obspython.obs_output_signal_stop

def obs_encoder_get_display_name(id: 'char const *') -> "char const *":
    return _obspython.obs_encoder_get_display_name(id)
obs_encoder_get_display_name = _obspython.obs_encoder_get_display_name

def obs_video_encoder_create(id: 'char const *', name: 'char const *', settings: 'obs_data_t *', hotkey_data: 'obs_data_t *') -> "obs_encoder_t *":
    return _obspython.obs_video_encoder_create(id, name, settings, hotkey_data)
obs_video_encoder_create = _obspython.obs_video_encoder_create

def obs_audio_encoder_create(id: 'char const *', name: 'char const *', settings: 'obs_data_t *', mixer_idx: 'size_t', hotkey_data: 'obs_data_t *') -> "obs_encoder_t *":
    return _obspython.obs_audio_encoder_create(id, name, settings, mixer_idx, hotkey_data)
obs_audio_encoder_create = _obspython.obs_audio_encoder_create

def obs_encoder_addref(encoder: 'obs_encoder_t *') -> "void":
    return _obspython.obs_encoder_addref(encoder)
obs_encoder_addref = _obspython.obs_encoder_addref

def obs_encoder_release(encoder: 'obs_encoder_t *') -> "void":
    return _obspython.obs_encoder_release(encoder)
obs_encoder_release = _obspython.obs_encoder_release

def obs_weak_encoder_addref(weak: 'obs_weak_encoder_t *') -> "void":
    return _obspython.obs_weak_encoder_addref(weak)
obs_weak_encoder_addref = _obspython.obs_weak_encoder_addref

def obs_weak_encoder_release(weak: 'obs_weak_encoder_t *') -> "void":
    return _obspython.obs_weak_encoder_release(weak)
obs_weak_encoder_release = _obspython.obs_weak_encoder_release

def obs_encoder_get_ref(encoder: 'obs_encoder_t *') -> "obs_encoder_t *":
    return _obspython.obs_encoder_get_ref(encoder)
obs_encoder_get_ref = _obspython.obs_encoder_get_ref

def obs_encoder_get_weak_encoder(encoder: 'obs_encoder_t *') -> "obs_weak_encoder_t *":
    return _obspython.obs_encoder_get_weak_encoder(encoder)
obs_encoder_get_weak_encoder = _obspython.obs_encoder_get_weak_encoder

def obs_weak_encoder_get_encoder(weak: 'obs_weak_encoder_t *') -> "obs_encoder_t *":
    return _obspython.obs_weak_encoder_get_encoder(weak)
obs_weak_encoder_get_encoder = _obspython.obs_weak_encoder_get_encoder

def obs_weak_encoder_references_encoder(weak: 'obs_weak_encoder_t *', encoder: 'obs_encoder_t *') -> "bool":
    return _obspython.obs_weak_encoder_references_encoder(weak, encoder)
obs_weak_encoder_references_encoder = _obspython.obs_weak_encoder_references_encoder

def obs_encoder_set_name(encoder: 'obs_encoder_t *', name: 'char const *') -> "void":
    return _obspython.obs_encoder_set_name(encoder, name)
obs_encoder_set_name = _obspython.obs_encoder_set_name

def obs_encoder_get_name(encoder: 'obs_encoder_t const *') -> "char const *":
    return _obspython.obs_encoder_get_name(encoder)
obs_encoder_get_name = _obspython.obs_encoder_get_name

def obs_get_encoder_codec(id: 'char const *') -> "char const *":
    return _obspython.obs_get_encoder_codec(id)
obs_get_encoder_codec = _obspython.obs_get_encoder_codec

def obs_get_encoder_type(id: 'char const *') -> "enum obs_encoder_type":
    return _obspython.obs_get_encoder_type(id)
obs_get_encoder_type = _obspython.obs_get_encoder_type

def obs_encoder_get_codec(encoder: 'obs_encoder_t const *') -> "char const *":
    return _obspython.obs_encoder_get_codec(encoder)
obs_encoder_get_codec = _obspython.obs_encoder_get_codec

def obs_encoder_get_type(encoder: 'obs_encoder_t const *') -> "enum obs_encoder_type":
    return _obspython.obs_encoder_get_type(encoder)
obs_encoder_get_type = _obspython.obs_encoder_get_type

def obs_encoder_set_scaled_size(encoder: 'obs_encoder_t *', width: 'uint32_t', height: 'uint32_t') -> "void":
    return _obspython.obs_encoder_set_scaled_size(encoder, width, height)
obs_encoder_set_scaled_size = _obspython.obs_encoder_set_scaled_size

def obs_encoder_get_width(encoder: 'obs_encoder_t const *') -> "uint32_t":
    return _obspython.obs_encoder_get_width(encoder)
obs_encoder_get_width = _obspython.obs_encoder_get_width

def obs_encoder_get_height(encoder: 'obs_encoder_t const *') -> "uint32_t":
    return _obspython.obs_encoder_get_height(encoder)
obs_encoder_get_height = _obspython.obs_encoder_get_height

def obs_encoder_get_sample_rate(encoder: 'obs_encoder_t const *') -> "uint32_t":
    return _obspython.obs_encoder_get_sample_rate(encoder)
obs_encoder_get_sample_rate = _obspython.obs_encoder_get_sample_rate

def obs_encoder_set_preferred_video_format(encoder: 'obs_encoder_t *', format: 'enum video_format') -> "void":
    return _obspython.obs_encoder_set_preferred_video_format(encoder, format)
obs_encoder_set_preferred_video_format = _obspython.obs_encoder_set_preferred_video_format

def obs_encoder_get_preferred_video_format(encoder: 'obs_encoder_t const *') -> "enum video_format":
    return _obspython.obs_encoder_get_preferred_video_format(encoder)
obs_encoder_get_preferred_video_format = _obspython.obs_encoder_get_preferred_video_format

def obs_encoder_defaults(id: 'char const *') -> "obs_data_t *":
    return _obspython.obs_encoder_defaults(id)
obs_encoder_defaults = _obspython.obs_encoder_defaults

def obs_encoder_get_defaults(encoder: 'obs_encoder_t const *') -> "obs_data_t *":
    return _obspython.obs_encoder_get_defaults(encoder)
obs_encoder_get_defaults = _obspython.obs_encoder_get_defaults

def obs_get_encoder_properties(id: 'char const *') -> "obs_properties_t *":
    return _obspython.obs_get_encoder_properties(id)
obs_get_encoder_properties = _obspython.obs_get_encoder_properties

def obs_encoder_properties(encoder: 'obs_encoder_t const *') -> "obs_properties_t *":
    return _obspython.obs_encoder_properties(encoder)
obs_encoder_properties = _obspython.obs_encoder_properties

def obs_encoder_update(encoder: 'obs_encoder_t *', settings: 'obs_data_t *') -> "void":
    return _obspython.obs_encoder_update(encoder, settings)
obs_encoder_update = _obspython.obs_encoder_update

def obs_encoder_get_extra_data(encoder: 'obs_encoder_t const *', extra_data: 'uint8_t **', size: 'size_t *') -> "bool":
    return _obspython.obs_encoder_get_extra_data(encoder, extra_data, size)
obs_encoder_get_extra_data = _obspython.obs_encoder_get_extra_data

def obs_encoder_get_settings(encoder: 'obs_encoder_t const *') -> "obs_data_t *":
    return _obspython.obs_encoder_get_settings(encoder)
obs_encoder_get_settings = _obspython.obs_encoder_get_settings

def obs_encoder_set_video(encoder: 'obs_encoder_t *', video: 'video_t *') -> "void":
    return _obspython.obs_encoder_set_video(encoder, video)
obs_encoder_set_video = _obspython.obs_encoder_set_video

def obs_encoder_set_audio(encoder: 'obs_encoder_t *', audio: 'audio_t *') -> "void":
    return _obspython.obs_encoder_set_audio(encoder, audio)
obs_encoder_set_audio = _obspython.obs_encoder_set_audio

def obs_encoder_video(encoder: 'obs_encoder_t const *') -> "video_t *":
    return _obspython.obs_encoder_video(encoder)
obs_encoder_video = _obspython.obs_encoder_video

def obs_encoder_audio(encoder: 'obs_encoder_t const *') -> "audio_t *":
    return _obspython.obs_encoder_audio(encoder)
obs_encoder_audio = _obspython.obs_encoder_audio

def obs_encoder_active(encoder: 'obs_encoder_t const *') -> "bool":
    return _obspython.obs_encoder_active(encoder)
obs_encoder_active = _obspython.obs_encoder_active

def obs_encoder_get_type_data(encoder: 'obs_encoder_t *') -> "void *":
    return _obspython.obs_encoder_get_type_data(encoder)
obs_encoder_get_type_data = _obspython.obs_encoder_get_type_data

def obs_encoder_get_id(encoder: 'obs_encoder_t const *') -> "char const *":
    return _obspython.obs_encoder_get_id(encoder)
obs_encoder_get_id = _obspython.obs_encoder_get_id

def obs_get_encoder_caps(encoder_id: 'char const *') -> "uint32_t":
    return _obspython.obs_get_encoder_caps(encoder_id)
obs_get_encoder_caps = _obspython.obs_get_encoder_caps

def obs_encoder_get_caps(encoder: 'obs_encoder_t const *') -> "uint32_t":
    return _obspython.obs_encoder_get_caps(encoder)
obs_encoder_get_caps = _obspython.obs_encoder_get_caps

def obs_encoder_packet_ref(dst: 'struct encoder_packet *', src: 'struct encoder_packet *') -> "void":
    return _obspython.obs_encoder_packet_ref(dst, src)
obs_encoder_packet_ref = _obspython.obs_encoder_packet_ref

def obs_encoder_packet_release(packet: 'struct encoder_packet *') -> "void":
    return _obspython.obs_encoder_packet_release(packet)
obs_encoder_packet_release = _obspython.obs_encoder_packet_release

def obs_encoder_create_rerouted(encoder: 'obs_encoder_t *', reroute_id: 'char const *') -> "void *":
    return _obspython.obs_encoder_create_rerouted(encoder, reroute_id)
obs_encoder_create_rerouted = _obspython.obs_encoder_create_rerouted

def obs_service_get_display_name(id: 'char const *') -> "char const *":
    return _obspython.obs_service_get_display_name(id)
obs_service_get_display_name = _obspython.obs_service_get_display_name

def obs_service_create(id: 'char const *', name: 'char const *', settings: 'obs_data_t *', hotkey_data: 'obs_data_t *') -> "obs_service_t *":
    return _obspython.obs_service_create(id, name, settings, hotkey_data)
obs_service_create = _obspython.obs_service_create

def obs_service_create_private(id: 'char const *', name: 'char const *', settings: 'obs_data_t *') -> "obs_service_t *":
    return _obspython.obs_service_create_private(id, name, settings)
obs_service_create_private = _obspython.obs_service_create_private

def obs_service_addref(service: 'obs_service_t *') -> "void":
    return _obspython.obs_service_addref(service)
obs_service_addref = _obspython.obs_service_addref

def obs_service_release(service: 'obs_service_t *') -> "void":
    return _obspython.obs_service_release(service)
obs_service_release = _obspython.obs_service_release

def obs_weak_service_addref(weak: 'obs_weak_service_t *') -> "void":
    return _obspython.obs_weak_service_addref(weak)
obs_weak_service_addref = _obspython.obs_weak_service_addref

def obs_weak_service_release(weak: 'obs_weak_service_t *') -> "void":
    return _obspython.obs_weak_service_release(weak)
obs_weak_service_release = _obspython.obs_weak_service_release

def obs_service_get_ref(service: 'obs_service_t *') -> "obs_service_t *":
    return _obspython.obs_service_get_ref(service)
obs_service_get_ref = _obspython.obs_service_get_ref

def obs_service_get_weak_service(service: 'obs_service_t *') -> "obs_weak_service_t *":
    return _obspython.obs_service_get_weak_service(service)
obs_service_get_weak_service = _obspython.obs_service_get_weak_service

def obs_weak_service_get_service(weak: 'obs_weak_service_t *') -> "obs_service_t *":
    return _obspython.obs_weak_service_get_service(weak)
obs_weak_service_get_service = _obspython.obs_weak_service_get_service

def obs_weak_service_references_service(weak: 'obs_weak_service_t *', service: 'obs_service_t *') -> "bool":
    return _obspython.obs_weak_service_references_service(weak, service)
obs_weak_service_references_service = _obspython.obs_weak_service_references_service

def obs_service_get_name(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_name(service)
obs_service_get_name = _obspython.obs_service_get_name

def obs_service_defaults(id: 'char const *') -> "obs_data_t *":
    return _obspython.obs_service_defaults(id)
obs_service_defaults = _obspython.obs_service_defaults

def obs_get_service_properties(id: 'char const *') -> "obs_properties_t *":
    return _obspython.obs_get_service_properties(id)
obs_get_service_properties = _obspython.obs_get_service_properties

def obs_service_properties(service: 'obs_service_t const *') -> "obs_properties_t *":
    return _obspython.obs_service_properties(service)
obs_service_properties = _obspython.obs_service_properties

def obs_service_get_type(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_type(service)
obs_service_get_type = _obspython.obs_service_get_type

def obs_service_update(service: 'obs_service_t *', settings: 'obs_data_t *') -> "void":
    return _obspython.obs_service_update(service, settings)
obs_service_update = _obspython.obs_service_update

def obs_service_get_settings(service: 'obs_service_t const *') -> "obs_data_t *":
    return _obspython.obs_service_get_settings(service)
obs_service_get_settings = _obspython.obs_service_get_settings

def obs_service_get_url(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_url(service)
obs_service_get_url = _obspython.obs_service_get_url

def obs_service_get_key(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_key(service)
obs_service_get_key = _obspython.obs_service_get_key

def obs_service_get_username(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_username(service)
obs_service_get_username = _obspython.obs_service_get_username

def obs_service_get_password(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_password(service)
obs_service_get_password = _obspython.obs_service_get_password

def obs_service_apply_encoder_settings(service: 'obs_service_t *', video_encoder_settings: 'obs_data_t *', audio_encoder_settings: 'obs_data_t *') -> "void":
    return _obspython.obs_service_apply_encoder_settings(service, video_encoder_settings, audio_encoder_settings)
obs_service_apply_encoder_settings = _obspython.obs_service_apply_encoder_settings

def obs_service_get_type_data(service: 'obs_service_t *') -> "void *":
    return _obspython.obs_service_get_type_data(service)
obs_service_get_type_data = _obspython.obs_service_get_type_data

def obs_service_get_id(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_id(service)
obs_service_get_id = _obspython.obs_service_get_id

def obs_service_get_output_type(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_output_type(service)
obs_service_get_output_type = _obspython.obs_service_get_output_type

def obs_source_frame_init(frame: 'obs_source_frame', format: 'enum video_format', width: 'uint32_t', height: 'uint32_t') -> "void":
    return _obspython.obs_source_frame_init(frame, format, width, height)
obs_source_frame_init = _obspython.obs_source_frame_init

def obs_source_frame_free(frame: 'obs_source_frame') -> "void":
    return _obspython.obs_source_frame_free(frame)
obs_source_frame_free = _obspython.obs_source_frame_free

def obs_source_frame_create(format: 'enum video_format', width: 'uint32_t', height: 'uint32_t') -> "struct obs_source_frame *":
    return _obspython.obs_source_frame_create(format, width, height)
obs_source_frame_create = _obspython.obs_source_frame_create

def obs_source_frame_destroy(frame: 'obs_source_frame') -> "void":
    return _obspython.obs_source_frame_destroy(frame)
obs_source_frame_destroy = _obspython.obs_source_frame_destroy

def obs_source_frame_copy(dst: 'obs_source_frame', src: 'obs_source_frame') -> "void":
    return _obspython.obs_source_frame_copy(dst, src)
obs_source_frame_copy = _obspython.obs_source_frame_copy
CALL_PARAM_TYPE_VOID = _obspython.CALL_PARAM_TYPE_VOID
CALL_PARAM_TYPE_INT = _obspython.CALL_PARAM_TYPE_INT
CALL_PARAM_TYPE_FLOAT = _obspython.CALL_PARAM_TYPE_FLOAT
CALL_PARAM_TYPE_BOOL = _obspython.CALL_PARAM_TYPE_BOOL
CALL_PARAM_TYPE_PTR = _obspython.CALL_PARAM_TYPE_PTR
CALL_PARAM_TYPE_STRING = _obspython.CALL_PARAM_TYPE_STRING
CALL_PARAM_IN = _obspython.CALL_PARAM_IN
CALL_PARAM_OUT = _obspython.CALL_PARAM_OUT
class calldata(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, calldata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, calldata, name)
    __repr__ = _swig_repr
    __swig_setmethods__["stack"] = _obspython.calldata_stack_set
    __swig_getmethods__["stack"] = _obspython.calldata_stack_get
    if _newclass:
        stack = _swig_property(_obspython.calldata_stack_get, _obspython.calldata_stack_set)
    __swig_setmethods__["size"] = _obspython.calldata_size_set
    __swig_getmethods__["size"] = _obspython.calldata_size_get
    if _newclass:
        size = _swig_property(_obspython.calldata_size_get, _obspython.calldata_size_set)
    __swig_setmethods__["capacity"] = _obspython.calldata_capacity_set
    __swig_getmethods__["capacity"] = _obspython.calldata_capacity_get
    if _newclass:
        capacity = _swig_property(_obspython.calldata_capacity_get, _obspython.calldata_capacity_set)
    __swig_setmethods__["fixed"] = _obspython.calldata_fixed_set
    __swig_getmethods__["fixed"] = _obspython.calldata_fixed_get
    if _newclass:
        fixed = _swig_property(_obspython.calldata_fixed_get, _obspython.calldata_fixed_set)

    def __init__(self):
        this = _obspython.new_calldata()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_calldata
    __del__ = lambda self: None
calldata_swigregister = _obspython.calldata_swigregister
calldata_swigregister(calldata)


def calldata_init(data: 'calldata') -> "void":
    return _obspython.calldata_init(data)
calldata_init = _obspython.calldata_init

def calldata_clear(data: 'calldata') -> "void":
    return _obspython.calldata_clear(data)
calldata_clear = _obspython.calldata_clear

def calldata_init_fixed(data: 'calldata', stack: 'uint8_t *', size: 'size_t') -> "void":
    return _obspython.calldata_init_fixed(data, stack, size)
calldata_init_fixed = _obspython.calldata_init_fixed

def calldata_free(data: 'calldata') -> "void":
    return _obspython.calldata_free(data)
calldata_free = _obspython.calldata_free

def calldata_get_data(data: 'calldata', name: 'char const *', out: 'void *', size: 'size_t') -> "bool":
    return _obspython.calldata_get_data(data, name, out, size)
calldata_get_data = _obspython.calldata_get_data

def calldata_set_data(data: 'calldata', name: 'char const *', arg3: 'void const *', new_size: 'size_t') -> "void":
    return _obspython.calldata_set_data(data, name, arg3, new_size)
calldata_set_data = _obspython.calldata_set_data

def calldata_create() -> "calldata_t *":
    return _obspython.calldata_create()
calldata_create = _obspython.calldata_create

def calldata_destroy(cd: 'calldata') -> "void":
    return _obspython.calldata_destroy(cd)
calldata_destroy = _obspython.calldata_destroy

def calldata_get_int(data: 'calldata', name: 'char const *', val: 'long long *') -> "bool":
    return _obspython.calldata_get_int(data, name, val)
calldata_get_int = _obspython.calldata_get_int

def calldata_get_float(data: 'calldata', name: 'char const *', val: 'double *') -> "bool":
    return _obspython.calldata_get_float(data, name, val)
calldata_get_float = _obspython.calldata_get_float

def calldata_get_bool(data: 'calldata', name: 'char const *', val: 'bool *') -> "bool":
    return _obspython.calldata_get_bool(data, name, val)
calldata_get_bool = _obspython.calldata_get_bool

def calldata_get_ptr(data: 'calldata', name: 'char const *', p_ptr: 'void *') -> "bool":
    return _obspython.calldata_get_ptr(data, name, p_ptr)
calldata_get_ptr = _obspython.calldata_get_ptr

def calldata_get_string(data: 'calldata', name: 'char const *', str: 'char const **') -> "bool":
    return _obspython.calldata_get_string(data, name, str)
calldata_get_string = _obspython.calldata_get_string

def calldata_int(data: 'calldata', name: 'char const *') -> "long long":
    return _obspython.calldata_int(data, name)
calldata_int = _obspython.calldata_int

def calldata_float(data: 'calldata', name: 'char const *') -> "double":
    return _obspython.calldata_float(data, name)
calldata_float = _obspython.calldata_float

def calldata_bool(data: 'calldata', name: 'char const *') -> "bool":
    return _obspython.calldata_bool(data, name)
calldata_bool = _obspython.calldata_bool

def calldata_ptr(data: 'calldata', name: 'char const *') -> "void *":
    return _obspython.calldata_ptr(data, name)
calldata_ptr = _obspython.calldata_ptr

def calldata_string(data: 'calldata', name: 'char const *') -> "char const *":
    return _obspython.calldata_string(data, name)
calldata_string = _obspython.calldata_string

def calldata_set_int(data: 'calldata', name: 'char const *', val: 'long long') -> "void":
    return _obspython.calldata_set_int(data, name, val)
calldata_set_int = _obspython.calldata_set_int

def calldata_set_float(data: 'calldata', name: 'char const *', val: 'double') -> "void":
    return _obspython.calldata_set_float(data, name, val)
calldata_set_float = _obspython.calldata_set_float

def calldata_set_bool(data: 'calldata', name: 'char const *', val: 'bool') -> "void":
    return _obspython.calldata_set_bool(data, name, val)
calldata_set_bool = _obspython.calldata_set_bool

def calldata_set_ptr(data: 'calldata', name: 'char const *', ptr: 'void *') -> "void":
    return _obspython.calldata_set_ptr(data, name, ptr)
calldata_set_ptr = _obspython.calldata_set_ptr

def calldata_set_string(data: 'calldata', name: 'char const *', str: 'char const *') -> "void":
    return _obspython.calldata_set_string(data, name, str)
calldata_set_string = _obspython.calldata_set_string

def proc_handler_create() -> "proc_handler_t *":
    return _obspython.proc_handler_create()
proc_handler_create = _obspython.proc_handler_create

def proc_handler_destroy(handler: 'proc_handler_t *') -> "void":
    return _obspython.proc_handler_destroy(handler)
proc_handler_destroy = _obspython.proc_handler_destroy

def proc_handler_add(handler: 'proc_handler_t *', decl_string: 'char const *', proc: 'proc_handler_proc_t', data: 'void *') -> "void":
    return _obspython.proc_handler_add(handler, decl_string, proc, data)
proc_handler_add = _obspython.proc_handler_add

def proc_handler_call(handler: 'proc_handler_t *', name: 'char const *', params: 'calldata') -> "bool":
    return _obspython.proc_handler_call(handler, name, params)
proc_handler_call = _obspython.proc_handler_call

def signal_handler_create() -> "signal_handler_t *":
    return _obspython.signal_handler_create()
signal_handler_create = _obspython.signal_handler_create

def signal_handler_destroy(handler: 'signal_handler_t *') -> "void":
    return _obspython.signal_handler_destroy(handler)
signal_handler_destroy = _obspython.signal_handler_destroy

def signal_handler_add(handler: 'signal_handler_t *', signal_decl: 'char const *') -> "bool":
    return _obspython.signal_handler_add(handler, signal_decl)
signal_handler_add = _obspython.signal_handler_add

def signal_handler_add_array(handler: 'signal_handler_t *', signal_decls: 'char const **') -> "bool":
    return _obspython.signal_handler_add_array(handler, signal_decls)
signal_handler_add_array = _obspython.signal_handler_add_array

def signal_handler_connect_ref(handler: 'signal_handler_t *', signal: 'char const *', callback: 'signal_callback_t', data: 'void *') -> "void":
    return _obspython.signal_handler_connect_ref(handler, signal, callback, data)
signal_handler_connect_ref = _obspython.signal_handler_connect_ref

def signal_handler_signal(handler: 'signal_handler_t *', signal: 'char const *', params: 'calldata') -> "void":
    return _obspython.signal_handler_signal(handler, signal, params)
signal_handler_signal = _obspython.signal_handler_signal
class base_allocator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, base_allocator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, base_allocator, name)
    __repr__ = _swig_repr
    __swig_setmethods__["malloc"] = _obspython.base_allocator_malloc_set
    __swig_getmethods__["malloc"] = _obspython.base_allocator_malloc_get
    if _newclass:
        malloc = _swig_property(_obspython.base_allocator_malloc_get, _obspython.base_allocator_malloc_set)
    __swig_setmethods__["realloc"] = _obspython.base_allocator_realloc_set
    __swig_getmethods__["realloc"] = _obspython.base_allocator_realloc_get
    if _newclass:
        realloc = _swig_property(_obspython.base_allocator_realloc_get, _obspython.base_allocator_realloc_set)
    __swig_setmethods__["free"] = _obspython.base_allocator_free_set
    __swig_getmethods__["free"] = _obspython.base_allocator_free_get
    if _newclass:
        free = _swig_property(_obspython.base_allocator_free_get, _obspython.base_allocator_free_set)

    def __init__(self):
        this = _obspython.new_base_allocator()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _obspython.delete_base_allocator
    __del__ = lambda self: None
base_allocator_swigregister = _obspython.base_allocator_swigregister
base_allocator_swigregister(base_allocator)


def base_set_allocator(defs: 'base_allocator') -> "void":
    return _obspython.base_set_allocator(defs)
base_set_allocator = _obspython.base_set_allocator

def bmalloc(size: 'size_t') -> "void *":
    return _obspython.bmalloc(size)
bmalloc = _obspython.bmalloc

def brealloc(ptr: 'void *', size: 'size_t') -> "void *":
    return _obspython.brealloc(ptr, size)
brealloc = _obspython.brealloc

def bfree(ptr: 'void *') -> "void":
    return _obspython.bfree(ptr)
bfree = _obspython.bfree

def base_get_alignment() -> "int":
    return _obspython.base_get_alignment()
base_get_alignment = _obspython.base_get_alignment

def bnum_allocs() -> "long":
    return _obspython.bnum_allocs()
bnum_allocs = _obspython.bnum_allocs

def bmemdup(ptr: 'void const *', size: 'size_t') -> "void *":
    return _obspython.bmemdup(ptr, size)
bmemdup = _obspython.bmemdup

def bzalloc(size: 'size_t') -> "void *":
    return _obspython.bzalloc(size)
bzalloc = _obspython.bzalloc

def bstrdup_n(str: 'char const *', n: 'size_t') -> "char *":
    return _obspython.bstrdup_n(str, n)
bstrdup_n = _obspython.bstrdup_n

def bwstrdup_n(str: 'wchar_t const *', n: 'size_t') -> "wchar_t *":
    return _obspython.bwstrdup_n(str, n)
bwstrdup_n = _obspython.bwstrdup_n

def bstrdup(str: 'char const *') -> "char *":
    return _obspython.bstrdup(str)
bstrdup = _obspython.bstrdup

def bwstrdup(str: 'wchar_t const *') -> "wchar_t *":
    return _obspython.bwstrdup(str)
bwstrdup = _obspython.bwstrdup
S__LINE__ = _obspython.S__LINE__
INT_CUR_LINE = _obspython.INT_CUR_LINE
FILE_LINE = _obspython.FILE_LINE
LOG_ERROR = _obspython.LOG_ERROR
LOG_WARNING = _obspython.LOG_WARNING
LOG_INFO = _obspython.LOG_INFO
LOG_DEBUG = _obspython.LOG_DEBUG

def base_get_log_handler(handler: 'log_handler_t *', param: 'void **') -> "void":
    return _obspython.base_get_log_handler(handler, param)
base_get_log_handler = _obspython.base_get_log_handler

def base_set_log_handler(handler: 'log_handler_t', param: 'void *') -> "void":
    return _obspython.base_set_log_handler(handler, param)
base_set_log_handler = _obspython.base_set_log_handler

def base_set_crash_handler(handler: 'void (*)(char const *,va_list,void *)', param: 'void *') -> "void":
    return _obspython.base_set_crash_handler(handler, param)
base_set_crash_handler = _obspython.base_set_crash_handler
TRUE = _obspython.TRUE
ON = _obspython.ON
FALSE = _obspython.FALSE
OFF = _obspython.OFF
SCRIPT_DIR = _obspython.SCRIPT_DIR
PYTHON_LIB = _obspython.PYTHON_LIB
COMPILE_LUA = _obspython.COMPILE_LUA
COMPILE_PYTHON = _obspython.COMPILE_PYTHON
UI_ENABLED = _obspython.UI_ENABLED
OBS_FRONTEND_EVENT_STREAMING_STARTING = _obspython.OBS_FRONTEND_EVENT_STREAMING_STARTING
OBS_FRONTEND_EVENT_STREAMING_STARTED = _obspython.OBS_FRONTEND_EVENT_STREAMING_STARTED
OBS_FRONTEND_EVENT_STREAMING_STOPPING = _obspython.OBS_FRONTEND_EVENT_STREAMING_STOPPING
OBS_FRONTEND_EVENT_STREAMING_STOPPED = _obspython.OBS_FRONTEND_EVENT_STREAMING_STOPPED
OBS_FRONTEND_EVENT_RECORDING_STARTING = _obspython.OBS_FRONTEND_EVENT_RECORDING_STARTING
OBS_FRONTEND_EVENT_RECORDING_STARTED = _obspython.OBS_FRONTEND_EVENT_RECORDING_STARTED
OBS_FRONTEND_EVENT_RECORDING_STOPPING = _obspython.OBS_FRONTEND_EVENT_RECORDING_STOPPING
OBS_FRONTEND_EVENT_RECORDING_STOPPED = _obspython.OBS_FRONTEND_EVENT_RECORDING_STOPPED
OBS_FRONTEND_EVENT_SCENE_CHANGED = _obspython.OBS_FRONTEND_EVENT_SCENE_CHANGED
OBS_FRONTEND_EVENT_SCENE_LIST_CHANGED = _obspython.OBS_FRONTEND_EVENT_SCENE_LIST_CHANGED
OBS_FRONTEND_EVENT_TRANSITION_CHANGED = _obspython.OBS_FRONTEND_EVENT_TRANSITION_CHANGED
OBS_FRONTEND_EVENT_TRANSITION_STOPPED = _obspython.OBS_FRONTEND_EVENT_TRANSITION_STOPPED
OBS_FRONTEND_EVENT_TRANSITION_LIST_CHANGED = _obspython.OBS_FRONTEND_EVENT_TRANSITION_LIST_CHANGED
OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGED = _obspython.OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGED
OBS_FRONTEND_EVENT_SCENE_COLLECTION_LIST_CHANGED = _obspython.OBS_FRONTEND_EVENT_SCENE_COLLECTION_LIST_CHANGED
OBS_FRONTEND_EVENT_PROFILE_CHANGED = _obspython.OBS_FRONTEND_EVENT_PROFILE_CHANGED
OBS_FRONTEND_EVENT_PROFILE_LIST_CHANGED = _obspython.OBS_FRONTEND_EVENT_PROFILE_LIST_CHANGED
OBS_FRONTEND_EVENT_EXIT = _obspython.OBS_FRONTEND_EVENT_EXIT
OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTING = _obspython.OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTING
OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTED = _obspython.OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTED
OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPING = _obspython.OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPING
OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPED = _obspython.OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPED
OBS_FRONTEND_EVENT_STUDIO_MODE_ENABLED = _obspython.OBS_FRONTEND_EVENT_STUDIO_MODE_ENABLED
OBS_FRONTEND_EVENT_STUDIO_MODE_DISABLED = _obspython.OBS_FRONTEND_EVENT_STUDIO_MODE_DISABLED
OBS_FRONTEND_EVENT_PREVIEW_SCENE_CHANGED = _obspython.OBS_FRONTEND_EVENT_PREVIEW_SCENE_CHANGED
OBS_FRONTEND_EVENT_SCENE_COLLECTION_CLEANUP = _obspython.OBS_FRONTEND_EVENT_SCENE_COLLECTION_CLEANUP
OBS_FRONTEND_EVENT_FINISHED_LOADING = _obspython.OBS_FRONTEND_EVENT_FINISHED_LOADING

def obs_frontend_streaming_start() -> "void":
    return _obspython.obs_frontend_streaming_start()
obs_frontend_streaming_start = _obspython.obs_frontend_streaming_start

def obs_frontend_streaming_stop() -> "void":
    return _obspython.obs_frontend_streaming_stop()
obs_frontend_streaming_stop = _obspython.obs_frontend_streaming_stop

def obs_frontend_streaming_active() -> "bool":
    return _obspython.obs_frontend_streaming_active()
obs_frontend_streaming_active = _obspython.obs_frontend_streaming_active

def obs_frontend_recording_start() -> "void":
    return _obspython.obs_frontend_recording_start()
obs_frontend_recording_start = _obspython.obs_frontend_recording_start

def obs_frontend_recording_stop() -> "void":
    return _obspython.obs_frontend_recording_stop()
obs_frontend_recording_stop = _obspython.obs_frontend_recording_stop

def obs_frontend_recording_active() -> "bool":
    return _obspython.obs_frontend_recording_active()
obs_frontend_recording_active = _obspython.obs_frontend_recording_active

def obs_frontend_replay_buffer_start() -> "void":
    return _obspython.obs_frontend_replay_buffer_start()
obs_frontend_replay_buffer_start = _obspython.obs_frontend_replay_buffer_start

def obs_frontend_replay_buffer_save() -> "void":
    return _obspython.obs_frontend_replay_buffer_save()
obs_frontend_replay_buffer_save = _obspython.obs_frontend_replay_buffer_save

def obs_frontend_replay_buffer_stop() -> "void":
    return _obspython.obs_frontend_replay_buffer_stop()
obs_frontend_replay_buffer_stop = _obspython.obs_frontend_replay_buffer_stop

def obs_frontend_replay_buffer_active() -> "bool":
    return _obspython.obs_frontend_replay_buffer_active()
obs_frontend_replay_buffer_active = _obspython.obs_frontend_replay_buffer_active

def obs_frontend_save() -> "void":
    return _obspython.obs_frontend_save()
obs_frontend_save = _obspython.obs_frontend_save

def obs_frontend_defer_save_begin() -> "void":
    return _obspython.obs_frontend_defer_save_begin()
obs_frontend_defer_save_begin = _obspython.obs_frontend_defer_save_begin

def obs_frontend_defer_save_end() -> "void":
    return _obspython.obs_frontend_defer_save_end()
obs_frontend_defer_save_end = _obspython.obs_frontend_defer_save_end

def obs_frontend_get_streaming_output() -> "obs_output_t *":
    return _obspython.obs_frontend_get_streaming_output()
obs_frontend_get_streaming_output = _obspython.obs_frontend_get_streaming_output

def obs_frontend_get_recording_output() -> "obs_output_t *":
    return _obspython.obs_frontend_get_recording_output()
obs_frontend_get_recording_output = _obspython.obs_frontend_get_recording_output

def obs_frontend_get_replay_buffer_output() -> "obs_output_t *":
    return _obspython.obs_frontend_get_replay_buffer_output()
obs_frontend_get_replay_buffer_output = _obspython.obs_frontend_get_replay_buffer_output

def obs_frontend_get_profile_config() -> "config_t *":
    return _obspython.obs_frontend_get_profile_config()
obs_frontend_get_profile_config = _obspython.obs_frontend_get_profile_config

def obs_frontend_get_global_config() -> "config_t *":
    return _obspython.obs_frontend_get_global_config()
obs_frontend_get_global_config = _obspython.obs_frontend_get_global_config

def obs_frontend_set_streaming_service(service: 'obs_service_t *') -> "void":
    return _obspython.obs_frontend_set_streaming_service(service)
obs_frontend_set_streaming_service = _obspython.obs_frontend_set_streaming_service

def obs_frontend_get_streaming_service() -> "obs_service_t *":
    return _obspython.obs_frontend_get_streaming_service()
obs_frontend_get_streaming_service = _obspython.obs_frontend_get_streaming_service

def obs_frontend_save_streaming_service() -> "void":
    return _obspython.obs_frontend_save_streaming_service()
obs_frontend_save_streaming_service = _obspython.obs_frontend_save_streaming_service

def obs_frontend_preview_program_mode_active() -> "bool":
    return _obspython.obs_frontend_preview_program_mode_active()
obs_frontend_preview_program_mode_active = _obspython.obs_frontend_preview_program_mode_active

def obs_frontend_set_preview_program_mode(enable: 'bool') -> "void":
    return _obspython.obs_frontend_set_preview_program_mode(enable)
obs_frontend_set_preview_program_mode = _obspython.obs_frontend_set_preview_program_mode

def obs_frontend_set_preview_enabled(enable: 'bool') -> "void":
    return _obspython.obs_frontend_set_preview_enabled(enable)
obs_frontend_set_preview_enabled = _obspython.obs_frontend_set_preview_enabled

def obs_frontend_preview_enabled() -> "bool":
    return _obspython.obs_frontend_preview_enabled()
obs_frontend_preview_enabled = _obspython.obs_frontend_preview_enabled

def obs_frontend_get_current_preview_scene() -> "obs_source_t *":
    return _obspython.obs_frontend_get_current_preview_scene()
obs_frontend_get_current_preview_scene = _obspython.obs_frontend_get_current_preview_scene

def obs_frontend_set_current_preview_scene(scene: 'obs_source_t *') -> "void":
    return _obspython.obs_frontend_set_current_preview_scene(scene)
obs_frontend_set_current_preview_scene = _obspython.obs_frontend_set_current_preview_scene
# This file is compatible with both classic and new-style classes.


