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

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

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

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:
        object.__setattr__(self, 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,)


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


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


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


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



def blog(log_level: 'int', message: 'char const *') -> "void":
    return _obspython.blog(log_level, message)
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_device_loss(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    device_loss_release = property(_obspython.gs_device_loss_device_loss_release_get, _obspython.gs_device_loss_device_loss_release_set)
    device_loss_rebuild = property(_obspython.gs_device_loss_device_loss_rebuild_get, _obspython.gs_device_loss_device_loss_rebuild_set)
    data = property(_obspython.gs_device_loss_data_get, _obspython.gs_device_loss_data_set)

    def __init__(self):
        _obspython.gs_device_loss_swiginit(self, _obspython.new_gs_device_loss())
    __swig_destroy__ = _obspython.delete_gs_device_loss

# Register gs_device_loss in _obspython:
_obspython.gs_device_loss_swigregister(gs_device_loss)

class gs_monitor_info(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    rotation_degrees = property(_obspython.gs_monitor_info_rotation_degrees_get, _obspython.gs_monitor_info_rotation_degrees_set)
    x = property(_obspython.gs_monitor_info_x_get, _obspython.gs_monitor_info_x_set)
    y = property(_obspython.gs_monitor_info_y_get, _obspython.gs_monitor_info_y_set)
    cx = property(_obspython.gs_monitor_info_cx_get, _obspython.gs_monitor_info_cx_set)
    cy = property(_obspython.gs_monitor_info_cy_get, _obspython.gs_monitor_info_cy_set)

    def __init__(self):
        _obspython.gs_monitor_info_swiginit(self, _obspython.new_gs_monitor_info())
    __swig_destroy__ = _obspython.delete_gs_monitor_info

# Register gs_monitor_info in _obspython:
_obspython.gs_monitor_info_swigregister(gs_monitor_info)

class gs_tvertarray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    width = property(_obspython.gs_tvertarray_width_get, _obspython.gs_tvertarray_width_set)
    array = property(_obspython.gs_tvertarray_array_get, _obspython.gs_tvertarray_array_set)

    def __init__(self):
        _obspython.gs_tvertarray_swiginit(self, _obspython.new_gs_tvertarray())
    __swig_destroy__ = _obspython.delete_gs_tvertarray

# Register gs_tvertarray in _obspython:
_obspython.gs_tvertarray_swigregister(gs_tvertarray)

class gs_vb_data(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    num = property(_obspython.gs_vb_data_num_get, _obspython.gs_vb_data_num_set)
    points = property(_obspython.gs_vb_data_points_get, _obspython.gs_vb_data_points_set)
    normals = property(_obspython.gs_vb_data_normals_get, _obspython.gs_vb_data_normals_set)
    tangents = property(_obspython.gs_vb_data_tangents_get, _obspython.gs_vb_data_tangents_set)
    colors = property(_obspython.gs_vb_data_colors_get, _obspython.gs_vb_data_colors_set)
    num_tex = property(_obspython.gs_vb_data_num_tex_get, _obspython.gs_vb_data_num_tex_set)
    tvarray = property(_obspython.gs_vb_data_tvarray_get, _obspython.gs_vb_data_tvarray_set)

    def __init__(self):
        _obspython.gs_vb_data_swiginit(self, _obspython.new_gs_vb_data())
    __swig_destroy__ = _obspython.delete_gs_vb_data

# Register gs_vb_data in _obspython:
_obspython.gs_vb_data_swigregister(gs_vb_data)


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

def gs_vbdata_destroy(data: 'gs_vb_data') -> "void":
    return _obspython.gs_vbdata_destroy(data)
class gs_sampler_info(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    filter = property(_obspython.gs_sampler_info_filter_get, _obspython.gs_sampler_info_filter_set)
    address_u = property(_obspython.gs_sampler_info_address_u_get, _obspython.gs_sampler_info_address_u_set)
    address_v = property(_obspython.gs_sampler_info_address_v_get, _obspython.gs_sampler_info_address_v_set)
    address_w = property(_obspython.gs_sampler_info_address_w_get, _obspython.gs_sampler_info_address_w_set)
    max_anisotropy = property(_obspython.gs_sampler_info_max_anisotropy_get, _obspython.gs_sampler_info_max_anisotropy_set)
    border_color = property(_obspython.gs_sampler_info_border_color_get, _obspython.gs_sampler_info_border_color_set)

    def __init__(self):
        _obspython.gs_sampler_info_swiginit(self, _obspython.new_gs_sampler_info())
    __swig_destroy__ = _obspython.delete_gs_sampler_info

# Register gs_sampler_info in _obspython:
_obspython.gs_sampler_info_swigregister(gs_sampler_info)

class gs_display_mode(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    width = property(_obspython.gs_display_mode_width_get, _obspython.gs_display_mode_width_set)
    height = property(_obspython.gs_display_mode_height_get, _obspython.gs_display_mode_height_set)
    bits = property(_obspython.gs_display_mode_bits_get, _obspython.gs_display_mode_bits_set)
    freq = property(_obspython.gs_display_mode_freq_get, _obspython.gs_display_mode_freq_set)

    def __init__(self):
        _obspython.gs_display_mode_swiginit(self, _obspython.new_gs_display_mode())
    __swig_destroy__ = _obspython.delete_gs_display_mode

# Register gs_display_mode in _obspython:
_obspython.gs_display_mode_swigregister(gs_display_mode)

class gs_rect(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = property(_obspython.gs_rect_x_get, _obspython.gs_rect_x_set)
    y = property(_obspython.gs_rect_y_get, _obspython.gs_rect_y_set)
    cx = property(_obspython.gs_rect_cx_get, _obspython.gs_rect_cx_set)
    cy = property(_obspython.gs_rect_cy_get, _obspython.gs_rect_cy_set)

    def __init__(self):
        _obspython.gs_rect_swiginit(self, _obspython.new_gs_rect())
    __swig_destroy__ = _obspython.delete_gs_rect

# Register gs_rect in _obspython:
_obspython.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)

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

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

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

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

def gs_technique_begin_pass(technique: 'gs_technique_t *', _pass: 'size_t') -> "bool":
    return _obspython.gs_technique_begin_pass(technique, _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)

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

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

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)

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

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)

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)

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

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)

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)

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

def gs_texrender_get_texture(texrender: 'gs_texrender_t const *') -> "gs_texture_t *":
    return _obspython.gs_texrender_get_texture(texrender)
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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _obspython.gs_window_swiginit(self, _obspython.new_gs_window())
    __swig_destroy__ = _obspython.delete_gs_window

# Register gs_window in _obspython:
_obspython.gs_window_swigregister(gs_window)

class gs_init_data(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    window = property(_obspython.gs_init_data_window_get, _obspython.gs_init_data_window_set)
    cx = property(_obspython.gs_init_data_cx_get, _obspython.gs_init_data_cx_set)
    cy = property(_obspython.gs_init_data_cy_get, _obspython.gs_init_data_cy_set)
    num_backbuffers = property(_obspython.gs_init_data_num_backbuffers_get, _obspython.gs_init_data_num_backbuffers_set)
    format = property(_obspython.gs_init_data_format_get, _obspython.gs_init_data_format_set)
    zsformat = property(_obspython.gs_init_data_zsformat_get, _obspython.gs_init_data_zsformat_set)
    adapter = property(_obspython.gs_init_data_adapter_get, _obspython.gs_init_data_adapter_set)

    def __init__(self):
        _obspython.gs_init_data_swiginit(self, _obspython.new_gs_init_data())
    __swig_destroy__ = _obspython.delete_gs_init_data

# Register gs_init_data in _obspython:
_obspython.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()

def gs_get_device_type() -> "int":
    return _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)

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

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

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

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

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

def gs_get_device_obj() -> "void *":
    return _obspython.gs_get_device_obj()

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

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

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

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

def gs_matrix_set(matrix: 'matrix4') -> "void":
    return _obspython.gs_matrix_set(matrix)

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

def gs_matrix_mul(matrix: 'matrix4') -> "void":
    return _obspython.gs_matrix_mul(matrix)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gs_get_effect() -> "gs_effect_t *":
    return _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)

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)

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)

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)

def gs_texture_create_from_file(file: 'char const *') -> "gs_texture_t *":
    return _obspython.gs_texture_create_from_file(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_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)

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)

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)

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

def gs_set_2d_mode() -> "void":
    return _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)

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

def gs_viewport_pop() -> "void":
    return _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)

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)

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

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

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

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

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

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

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

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

def gs_get_height() -> "uint32_t":
    return _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)

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)

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)

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)

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)

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

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)

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)

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

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)

def gs_timer_create() -> "gs_timer_t *":
    return _obspython.gs_timer_create()

def gs_timer_range_create() -> "gs_timer_range_t *":
    return _obspython.gs_timer_range_create()

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

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

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

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

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

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

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

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

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

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

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

def gs_get_zstencil_target() -> "gs_zstencil_t *":
    return _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)

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)

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

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)

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

def gs_begin_frame() -> "void":
    return _obspython.gs_begin_frame()

def gs_begin_scene() -> "void":
    return _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)

def gs_end_scene() -> "void":
    return _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)

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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)

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

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

def gs_set_scissor_rect(rect: 'gs_rect') -> "void":
    return _obspython.gs_set_scissor_rect(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)

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gs_timer_destroy(timer: 'gs_timer_t *') -> "void":
    return _obspython.gs_timer_destroy(timer)

def gs_timer_begin(timer: 'gs_timer_t *') -> "void":
    return _obspython.gs_timer_begin(timer)

def gs_timer_end(timer: 'gs_timer_t *') -> "void":
    return _obspython.gs_timer_end(timer)

def gs_timer_get_data(timer: 'gs_timer_t *', ticks: 'uint64_t *') -> "bool":
    return _obspython.gs_timer_get_data(timer, ticks)

def gs_timer_range_destroy(timer: 'gs_timer_range_t *') -> "void":
    return _obspython.gs_timer_range_destroy(timer)

def gs_timer_range_begin(range: 'gs_timer_range_t *') -> "void":
    return _obspython.gs_timer_range_begin(range)

def gs_timer_range_end(range: 'gs_timer_range_t *') -> "void":
    return _obspython.gs_timer_range_end(range)

def gs_timer_range_get_data(range: 'gs_timer_range_t *', disjoint: 'bool *', frequency: 'uint64_t *') -> "bool":
    return _obspython.gs_timer_range_get_data(range, disjoint, frequency)

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

def gs_debug_marker_begin(color: 'float const [4]', markername: 'char const *') -> "void":
    return _obspython.gs_debug_marker_begin(color, markername)

def gs_debug_marker_begin_format(*args) -> "void":
    return _obspython.gs_debug_marker_begin_format(*args)

def gs_debug_marker_end() -> "void":
    return _obspython.gs_debug_marker_end()

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

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

def gs_get_total_levels(width: 'uint32_t', height: 'uint32_t', depth: 'uint32_t') -> "uint32_t":
    return _obspython.gs_get_total_levels(width, height, depth)
class vec4(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = property(_obspython.vec4_x_get, _obspython.vec4_x_set)
    y = property(_obspython.vec4_y_get, _obspython.vec4_y_set)
    z = property(_obspython.vec4_z_get, _obspython.vec4_z_set)
    w = property(_obspython.vec4_w_get, _obspython.vec4_w_set)
    ptr = property(_obspython.vec4_ptr_get, _obspython.vec4_ptr_set)
    m = property(_obspython.vec4_m_get, _obspython.vec4_m_set)

    def __init__(self):
        _obspython.vec4_swiginit(self, _obspython.new_vec4())
    __swig_destroy__ = _obspython.delete_vec4

# Register vec4 in _obspython:
_obspython.vec4_swigregister(vec4)


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def vec4_transform(dst: 'vec4', v: 'vec4', m: 'matrix4') -> "void":
    return _obspython.vec4_transform(dst, v, m)
class vec3(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = property(_obspython.vec3_x_get, _obspython.vec3_x_set)
    y = property(_obspython.vec3_y_get, _obspython.vec3_y_set)
    z = property(_obspython.vec3_z_get, _obspython.vec3_z_set)
    w = property(_obspython.vec3_w_get, _obspython.vec3_w_set)
    ptr = property(_obspython.vec3_ptr_get, _obspython.vec3_ptr_set)
    m = property(_obspython.vec3_m_get, _obspython.vec3_m_set)

    def __init__(self):
        _obspython.vec3_swiginit(self, _obspython.new_vec3())
    __swig_destroy__ = _obspython.delete_vec3

# Register vec3 in _obspython:
_obspython.vec3_swigregister(vec3)


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def vec3_rand(dst: 'vec3', positive_only: 'int') -> "void":
    return _obspython.vec3_rand(dst, positive_only)
class vec2(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = property(_obspython.vec2_x_get, _obspython.vec2_x_set)
    y = property(_obspython.vec2_y_get, _obspython.vec2_y_set)
    ptr = property(_obspython.vec2_ptr_get, _obspython.vec2_ptr_set)

    def __init__(self):
        _obspython.vec2_swiginit(self, _obspython.new_vec2())
    __swig_destroy__ = _obspython.delete_vec2

# Register vec2 in _obspython:
_obspython.vec2_swigregister(vec2)


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def vec2_norm(dst: 'vec2', v: 'vec2') -> "void":
    return _obspython.vec2_norm(dst, v)
class matrix4(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = property(_obspython.matrix4_x_get, _obspython.matrix4_x_set)
    y = property(_obspython.matrix4_y_get, _obspython.matrix4_y_set)
    z = property(_obspython.matrix4_z_get, _obspython.matrix4_z_set)
    t = property(_obspython.matrix4_t_get, _obspython.matrix4_t_set)

    def __init__(self):
        _obspython.matrix4_swiginit(self, _obspython.new_matrix4())
    __swig_destroy__ = _obspython.delete_matrix4

# Register matrix4 in _obspython:
_obspython.matrix4_swigregister(matrix4)


def matrix4_copy(dst: 'matrix4', m: 'matrix4') -> "void":
    return _obspython.matrix4_copy(dst, m)

def matrix4_identity(dst: 'matrix4') -> "void":
    return _obspython.matrix4_identity(dst)

def matrix4_from_matrix3(dst: 'matrix4', m: 'matrix3') -> "void":
    return _obspython.matrix4_from_matrix3(dst, m)

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

def matrix4_from_axisang(dst: 'matrix4', aa: 'struct axisang const *') -> "void":
    return _obspython.matrix4_from_axisang(dst, aa)

def matrix4_mul(dst: 'matrix4', m1: 'matrix4', m2: 'matrix4') -> "void":
    return _obspython.matrix4_mul(dst, m1, m2)

def matrix4_determinant(m: 'matrix4') -> "float":
    return _obspython.matrix4_determinant(m)

def matrix4_translate3v(dst: 'matrix4', m: 'matrix4', v: 'vec3') -> "void":
    return _obspython.matrix4_translate3v(dst, m, v)

def matrix4_translate4v(dst: 'matrix4', m: 'matrix4', v: 'vec4') -> "void":
    return _obspython.matrix4_translate4v(dst, m, v)

def matrix4_rotate(dst: 'matrix4', m: 'matrix4', q: 'quat') -> "void":
    return _obspython.matrix4_rotate(dst, m, q)

def matrix4_rotate_aa(dst: 'matrix4', m: 'matrix4', aa: 'struct axisang const *') -> "void":
    return _obspython.matrix4_rotate_aa(dst, m, aa)

def matrix4_scale(dst: 'matrix4', m: 'matrix4', v: 'vec3') -> "void":
    return _obspython.matrix4_scale(dst, m, v)

def matrix4_inv(dst: 'matrix4', m: 'matrix4') -> "bool":
    return _obspython.matrix4_inv(dst, m)

def matrix4_transpose(dst: 'matrix4', m: 'matrix4') -> "void":
    return _obspython.matrix4_transpose(dst, m)

def matrix4_translate3v_i(dst: 'matrix4', v: 'vec3', m: 'matrix4') -> "void":
    return _obspython.matrix4_translate3v_i(dst, v, m)

def matrix4_translate4v_i(dst: 'matrix4', v: 'vec4', m: 'matrix4') -> "void":
    return _obspython.matrix4_translate4v_i(dst, v, m)

def matrix4_rotate_i(dst: 'matrix4', q: 'quat', m: 'matrix4') -> "void":
    return _obspython.matrix4_rotate_i(dst, q, m)

def matrix4_rotate_aa_i(dst: 'matrix4', aa: 'struct axisang const *', m: 'matrix4') -> "void":
    return _obspython.matrix4_rotate_aa_i(dst, aa, m)

def matrix4_scale_i(dst: 'matrix4', v: 'vec3', m: 'matrix4') -> "void":
    return _obspython.matrix4_scale_i(dst, v, m)

def matrix4_translate3f(dst: 'matrix4', m: 'matrix4', x: 'float', y: 'float', z: 'float') -> "void":
    return _obspython.matrix4_translate3f(dst, m, x, y, z)

def matrix4_rotate_aa4f(dst: 'matrix4', m: 'matrix4', x: 'float', y: 'float', z: 'float', rot: 'float') -> "void":
    return _obspython.matrix4_rotate_aa4f(dst, m, x, y, z, rot)

def matrix4_scale3f(dst: 'matrix4', m: 'matrix4', x: 'float', y: 'float', z: 'float') -> "void":
    return _obspython.matrix4_scale3f(dst, m, x, y, z)
class matrix3(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = property(_obspython.matrix3_x_get, _obspython.matrix3_x_set)
    y = property(_obspython.matrix3_y_get, _obspython.matrix3_y_set)
    z = property(_obspython.matrix3_z_get, _obspython.matrix3_z_set)
    t = property(_obspython.matrix3_t_get, _obspython.matrix3_t_set)

    def __init__(self):
        _obspython.matrix3_swiginit(self, _obspython.new_matrix3())
    __swig_destroy__ = _obspython.delete_matrix3

# Register matrix3 in _obspython:
_obspython.matrix3_swigregister(matrix3)


def matrix3_copy(dst: 'matrix3', m: 'matrix3') -> "void":
    return _obspython.matrix3_copy(dst, m)

def matrix3_identity(dst: 'matrix3') -> "void":
    return _obspython.matrix3_identity(dst)

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

def matrix3_from_axisang(dst: 'matrix3', aa: 'struct axisang const *') -> "void":
    return _obspython.matrix3_from_axisang(dst, aa)

def matrix3_from_matrix4(dst: 'matrix3', m: 'matrix4') -> "void":
    return _obspython.matrix3_from_matrix4(dst, m)

def matrix3_mul(dst: 'matrix3', m1: 'matrix3', m2: 'matrix3') -> "void":
    return _obspython.matrix3_mul(dst, m1, m2)

def matrix3_translate(dst: 'matrix3', m: 'matrix3', v: 'vec3') -> "void":
    return _obspython.matrix3_translate(dst, m, v)

def matrix3_rotate(dst: 'matrix3', m: 'matrix3', q: 'quat') -> "void":
    return _obspython.matrix3_rotate(dst, m, q)

def matrix3_rotate_aa(dst: 'matrix3', m: 'matrix3', aa: 'struct axisang const *') -> "void":
    return _obspython.matrix3_rotate_aa(dst, m, aa)

def matrix3_scale(dst: 'matrix3', m: 'matrix3', v: 'vec3') -> "void":
    return _obspython.matrix3_scale(dst, m, v)

def matrix3_transpose(dst: 'matrix3', m: 'matrix3') -> "void":
    return _obspython.matrix3_transpose(dst, m)

def matrix3_inv(dst: 'matrix3', m: 'matrix3') -> "void":
    return _obspython.matrix3_inv(dst, m)

def matrix3_mirror(dst: 'matrix3', m: 'matrix3', p: 'struct plane const *') -> "void":
    return _obspython.matrix3_mirror(dst, m, p)

def matrix3_mirrorv(dst: 'matrix3', m: 'matrix3', v: 'vec3') -> "void":
    return _obspython.matrix3_mirrorv(dst, m, v)

def matrix3_translate3f(dst: 'matrix3', m: 'matrix3', x: 'float', y: 'float', z: 'float') -> "void":
    return _obspython.matrix3_translate3f(dst, m, x, y, z)

def matrix3_rotate_aa4f(dst: 'matrix3', m: 'matrix3', x: 'float', y: 'float', z: 'float', rot: 'float') -> "void":
    return _obspython.matrix3_rotate_aa4f(dst, m, x, y, z, rot)

def matrix3_scale3f(dst: 'matrix3', m: 'matrix3', x: 'float', y: 'float', z: 'float') -> "void":
    return _obspython.matrix3_scale3f(dst, m, x, y, z)
class quat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = property(_obspython.quat_x_get, _obspython.quat_x_set)
    y = property(_obspython.quat_y_get, _obspython.quat_y_set)
    z = property(_obspython.quat_z_get, _obspython.quat_z_set)
    w = property(_obspython.quat_w_get, _obspython.quat_w_set)
    ptr = property(_obspython.quat_ptr_get, _obspython.quat_ptr_set)
    m = property(_obspython.quat_m_get, _obspython.quat_m_set)

    def __init__(self):
        _obspython.quat_swiginit(self, _obspython.new_quat())
    __swig_destroy__ = _obspython.delete_quat

# Register quat in _obspython:
_obspython.quat_swigregister(quat)


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)
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
BUILD_CAPTIONS = _obspython.BUILD_CAPTIONS
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()

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

def obs_data_create_from_json_file(json_file: 'char const *') -> "obs_data_t *":
    return _obspython.obs_data_create_from_json_file(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)

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

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

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

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

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)

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

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

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

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)

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)

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

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

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

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

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

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

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

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

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

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

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

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)

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)

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

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

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

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

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)

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)

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

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

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

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

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

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)

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)

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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)

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

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

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

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

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)

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)

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)

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)

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)

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)

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)

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)

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

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

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

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

def obs_data_newref(data: 'obs_data_t *') -> "obs_data_t *":
    return _obspython.obs_data_newref(data)
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_ICON_TYPE_UNKNOWN = _obspython.OBS_ICON_TYPE_UNKNOWN
OBS_ICON_TYPE_IMAGE = _obspython.OBS_ICON_TYPE_IMAGE
OBS_ICON_TYPE_COLOR = _obspython.OBS_ICON_TYPE_COLOR
OBS_ICON_TYPE_SLIDESHOW = _obspython.OBS_ICON_TYPE_SLIDESHOW
OBS_ICON_TYPE_AUDIO_INPUT = _obspython.OBS_ICON_TYPE_AUDIO_INPUT
OBS_ICON_TYPE_AUDIO_OUTPUT = _obspython.OBS_ICON_TYPE_AUDIO_OUTPUT
OBS_ICON_TYPE_DESKTOP_CAPTURE = _obspython.OBS_ICON_TYPE_DESKTOP_CAPTURE
OBS_ICON_TYPE_WINDOW_CAPTURE = _obspython.OBS_ICON_TYPE_WINDOW_CAPTURE
OBS_ICON_TYPE_GAME_CAPTURE = _obspython.OBS_ICON_TYPE_GAME_CAPTURE
OBS_ICON_TYPE_CAMERA = _obspython.OBS_ICON_TYPE_CAMERA
OBS_ICON_TYPE_TEXT = _obspython.OBS_ICON_TYPE_TEXT
OBS_ICON_TYPE_MEDIA = _obspython.OBS_ICON_TYPE_MEDIA
OBS_ICON_TYPE_BROWSER = _obspython.OBS_ICON_TYPE_BROWSER
OBS_ICON_TYPE_CUSTOM = _obspython.OBS_ICON_TYPE_CUSTOM
OBS_MEDIA_STATE_NONE = _obspython.OBS_MEDIA_STATE_NONE
OBS_MEDIA_STATE_PLAYING = _obspython.OBS_MEDIA_STATE_PLAYING
OBS_MEDIA_STATE_OPENING = _obspython.OBS_MEDIA_STATE_OPENING
OBS_MEDIA_STATE_BUFFERING = _obspython.OBS_MEDIA_STATE_BUFFERING
OBS_MEDIA_STATE_PAUSED = _obspython.OBS_MEDIA_STATE_PAUSED
OBS_MEDIA_STATE_STOPPED = _obspython.OBS_MEDIA_STATE_STOPPED
OBS_MEDIA_STATE_ENDED = _obspython.OBS_MEDIA_STATE_ENDED
OBS_MEDIA_STATE_ERROR = _obspython.OBS_MEDIA_STATE_ERROR
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
OBS_SOURCE_CAP_OBSOLETE = _obspython.OBS_SOURCE_CAP_OBSOLETE
OBS_SOURCE_MONITOR_BY_DEFAULT = _obspython.OBS_SOURCE_MONITOR_BY_DEFAULT
OBS_SOURCE_SUBMIX = _obspython.OBS_SOURCE_SUBMIX
OBS_SOURCE_CONTROLLABLE_MEDIA = _obspython.OBS_SOURCE_CONTROLLABLE_MEDIA
class obs_source_audio_mix(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    output = property(_obspython.obs_source_audio_mix_output_get, _obspython.obs_source_audio_mix_output_set)

    def __init__(self):
        _obspython.obs_source_audio_mix_swiginit(self, _obspython.new_obs_source_audio_mix())
    __swig_destroy__ = _obspython.delete_obs_source_audio_mix

# Register obs_source_audio_mix in _obspython:
_obspython.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_PROPERTY_GROUP = _obspython.OBS_PROPERTY_GROUP
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_COMBO_INVALID = _obspython.OBS_COMBO_INVALID
OBS_GROUP_NORMAL = _obspython.OBS_GROUP_NORMAL
OBS_GROUP_CHECKABLE = _obspython.OBS_GROUP_CHECKABLE
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()

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

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

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

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

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

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

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

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

def obs_properties_get_parent(props: 'obs_properties_t *') -> "obs_properties_t *":
    return _obspython.obs_properties_get_parent(props)

def obs_properties_remove_by_name(props: 'obs_properties_t *', property: 'char const *') -> "void":
    return _obspython.obs_properties_remove_by_name(props, property)

def obs_properties_apply_settings(props: 'obs_properties_t *', settings: 'obs_data_t *') -> "void":
    return _obspython.obs_properties_apply_settings(props, 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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

def obs_properties_add_group(props: 'obs_properties_t *', name: 'char const *', description: 'char const *', type: 'enum obs_group_type', group: 'obs_properties_t *') -> "obs_property_t *":
    return _obspython.obs_properties_add_group(props, name, description, type, group)

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)

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

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

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

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

def obs_property_set_description(p: 'obs_property_t *', description: 'char const *') -> "void":
    return _obspython.obs_property_set_description(p, 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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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)

def obs_property_int_set_suffix(p: 'obs_property_t *', suffix: 'char const *') -> "void":
    return _obspython.obs_property_int_set_suffix(p, suffix)

def obs_property_float_set_suffix(p: 'obs_property_t *', suffix: 'char const *') -> "void":
    return _obspython.obs_property_float_set_suffix(p, suffix)

def obs_property_text_set_monospace(p: 'obs_property_t *', monospace: 'bool') -> "void":
    return _obspython.obs_property_text_set_monospace(p, monospace)

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

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)

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)

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)

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)

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)

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)

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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)

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)

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)

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

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)

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)

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

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)

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)

def obs_property_group_type(p: 'obs_property_t *') -> "enum obs_group_type":
    return _obspython.obs_property_group_type(p)

def obs_property_group_content(p: 'obs_property_t *') -> "obs_properties_t *":
    return _obspython.obs_property_group_content(p)
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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    modifiers = property(_obspython.obs_mouse_event_modifiers_get, _obspython.obs_mouse_event_modifiers_set)
    x = property(_obspython.obs_mouse_event_x_get, _obspython.obs_mouse_event_x_set)
    y = property(_obspython.obs_mouse_event_y_get, _obspython.obs_mouse_event_y_set)

    def __init__(self):
        _obspython.obs_mouse_event_swiginit(self, _obspython.new_obs_mouse_event())
    __swig_destroy__ = _obspython.delete_obs_mouse_event

# Register obs_mouse_event in _obspython:
_obspython.obs_mouse_event_swigregister(obs_mouse_event)

class obs_key_event(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    modifiers = property(_obspython.obs_key_event_modifiers_get, _obspython.obs_key_event_modifiers_set)
    text = property(_obspython.obs_key_event_text_get, _obspython.obs_key_event_text_set)
    native_modifiers = property(_obspython.obs_key_event_native_modifiers_get, _obspython.obs_key_event_native_modifiers_set)
    native_scancode = property(_obspython.obs_key_event_native_scancode_get, _obspython.obs_key_event_native_scancode_set)
    native_vkey = property(_obspython.obs_key_event_native_vkey_get, _obspython.obs_key_event_native_vkey_set)

    def __init__(self):
        _obspython.obs_key_event_swiginit(self, _obspython.new_obs_key_event())
    __swig_destroy__ = _obspython.delete_obs_key_event

# Register obs_key_event in _obspython:
_obspython.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    modifiers = property(_obspython.obs_key_combination_modifiers_get, _obspython.obs_key_combination_modifiers_set)
    key = property(_obspython.obs_key_combination_key_get, _obspython.obs_key_combination_key_set)

    def __init__(self):
        _obspython.obs_key_combination_swiginit(self, _obspython.new_obs_key_combination())
    __swig_destroy__ = _obspython.delete_obs_key_combination

# Register obs_key_combination in _obspython:
_obspython.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)

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

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

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

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

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

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)

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

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

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

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

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)

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)

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)

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

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

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

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)

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

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

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

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

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

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)

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

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)

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

def obs_key_combination_is_empty(combo: 'obs_key_combination') -> "bool":
    return _obspython.obs_key_combination_is_empty(combo)
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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    pos = property(_obspython.obs_transform_info_pos_get, _obspython.obs_transform_info_pos_set)
    rot = property(_obspython.obs_transform_info_rot_get, _obspython.obs_transform_info_rot_set)
    scale = property(_obspython.obs_transform_info_scale_get, _obspython.obs_transform_info_scale_set)
    alignment = property(_obspython.obs_transform_info_alignment_get, _obspython.obs_transform_info_alignment_set)
    bounds_type = property(_obspython.obs_transform_info_bounds_type_get, _obspython.obs_transform_info_bounds_type_set)
    bounds_alignment = property(_obspython.obs_transform_info_bounds_alignment_get, _obspython.obs_transform_info_bounds_alignment_set)
    bounds = property(_obspython.obs_transform_info_bounds_get, _obspython.obs_transform_info_bounds_set)

    def __init__(self):
        _obspython.obs_transform_info_swiginit(self, _obspython.new_obs_transform_info())
    __swig_destroy__ = _obspython.delete_obs_transform_info

# Register obs_transform_info in _obspython:
_obspython.obs_transform_info_swigregister(obs_transform_info)

class obs_video_info(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    fps_num = property(_obspython.obs_video_info_fps_num_get, _obspython.obs_video_info_fps_num_set)
    fps_den = property(_obspython.obs_video_info_fps_den_get, _obspython.obs_video_info_fps_den_set)
    base_width = property(_obspython.obs_video_info_base_width_get, _obspython.obs_video_info_base_width_set)
    base_height = property(_obspython.obs_video_info_base_height_get, _obspython.obs_video_info_base_height_set)
    output_width = property(_obspython.obs_video_info_output_width_get, _obspython.obs_video_info_output_width_set)
    output_height = property(_obspython.obs_video_info_output_height_get, _obspython.obs_video_info_output_height_set)
    output_format = property(_obspython.obs_video_info_output_format_get, _obspython.obs_video_info_output_format_set)
    adapter = property(_obspython.obs_video_info_adapter_get, _obspython.obs_video_info_adapter_set)
    gpu_conversion = property(_obspython.obs_video_info_gpu_conversion_get, _obspython.obs_video_info_gpu_conversion_set)
    colorspace = property(_obspython.obs_video_info_colorspace_get, _obspython.obs_video_info_colorspace_set)
    range = property(_obspython.obs_video_info_range_get, _obspython.obs_video_info_range_set)
    scale_type = property(_obspython.obs_video_info_scale_type_get, _obspython.obs_video_info_scale_type_set)

    def __init__(self):
        _obspython.obs_video_info_swiginit(self, _obspython.new_obs_video_info())
    __swig_destroy__ = _obspython.delete_obs_video_info

# Register obs_video_info in _obspython:
_obspython.obs_video_info_swigregister(obs_video_info)

class obs_audio_info(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    samples_per_sec = property(_obspython.obs_audio_info_samples_per_sec_get, _obspython.obs_audio_info_samples_per_sec_set)
    speakers = property(_obspython.obs_audio_info_speakers_get, _obspython.obs_audio_info_speakers_set)

    def __init__(self):
        _obspython.obs_audio_info_swiginit(self, _obspython.new_obs_audio_info())
    __swig_destroy__ = _obspython.delete_obs_audio_info

# Register obs_audio_info in _obspython:
_obspython.obs_audio_info_swigregister(obs_audio_info)

class obs_audio_data(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    data = property(_obspython.obs_audio_data_data_get, _obspython.obs_audio_data_data_set)
    frames = property(_obspython.obs_audio_data_frames_get, _obspython.obs_audio_data_frames_set)
    timestamp = property(_obspython.obs_audio_data_timestamp_get, _obspython.obs_audio_data_timestamp_set)

    def __init__(self):
        _obspython.obs_audio_data_swiginit(self, _obspython.new_obs_audio_data())
    __swig_destroy__ = _obspython.delete_obs_audio_data

# Register obs_audio_data in _obspython:
_obspython.obs_audio_data_swigregister(obs_audio_data)

class obs_source_audio(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    data = property(_obspython.obs_source_audio_data_get, _obspython.obs_source_audio_data_set)
    frames = property(_obspython.obs_source_audio_frames_get, _obspython.obs_source_audio_frames_set)
    speakers = property(_obspython.obs_source_audio_speakers_get, _obspython.obs_source_audio_speakers_set)
    format = property(_obspython.obs_source_audio_format_get, _obspython.obs_source_audio_format_set)
    samples_per_sec = property(_obspython.obs_source_audio_samples_per_sec_get, _obspython.obs_source_audio_samples_per_sec_set)
    timestamp = property(_obspython.obs_source_audio_timestamp_get, _obspython.obs_source_audio_timestamp_set)

    def __init__(self):
        _obspython.obs_source_audio_swiginit(self, _obspython.new_obs_source_audio())
    __swig_destroy__ = _obspython.delete_obs_source_audio

# Register obs_source_audio in _obspython:
_obspython.obs_source_audio_swigregister(obs_source_audio)

class obs_source_frame(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    data = property(_obspython.obs_source_frame_data_get, _obspython.obs_source_frame_data_set)
    linesize = property(_obspython.obs_source_frame_linesize_get, _obspython.obs_source_frame_linesize_set)
    width = property(_obspython.obs_source_frame_width_get, _obspython.obs_source_frame_width_set)
    height = property(_obspython.obs_source_frame_height_get, _obspython.obs_source_frame_height_set)
    timestamp = property(_obspython.obs_source_frame_timestamp_get, _obspython.obs_source_frame_timestamp_set)
    format = property(_obspython.obs_source_frame_format_get, _obspython.obs_source_frame_format_set)
    color_matrix = property(_obspython.obs_source_frame_color_matrix_get, _obspython.obs_source_frame_color_matrix_set)
    full_range = property(_obspython.obs_source_frame_full_range_get, _obspython.obs_source_frame_full_range_set)
    color_range_min = property(_obspython.obs_source_frame_color_range_min_get, _obspython.obs_source_frame_color_range_min_set)
    color_range_max = property(_obspython.obs_source_frame_color_range_max_get, _obspython.obs_source_frame_color_range_max_set)
    flip = property(_obspython.obs_source_frame_flip_get, _obspython.obs_source_frame_flip_set)
    refs = property(_obspython.obs_source_frame_refs_get, _obspython.obs_source_frame_refs_set)
    prev_frame = property(_obspython.obs_source_frame_prev_frame_get, _obspython.obs_source_frame_prev_frame_set)

    def __init__(self):
        _obspython.obs_source_frame_swiginit(self, _obspython.new_obs_source_frame())
    __swig_destroy__ = _obspython.delete_obs_source_frame

# Register obs_source_frame in _obspython:
_obspython.obs_source_frame_swigregister(obs_source_frame)

class obs_source_frame2(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    data = property(_obspython.obs_source_frame2_data_get, _obspython.obs_source_frame2_data_set)
    linesize = property(_obspython.obs_source_frame2_linesize_get, _obspython.obs_source_frame2_linesize_set)
    width = property(_obspython.obs_source_frame2_width_get, _obspython.obs_source_frame2_width_set)
    height = property(_obspython.obs_source_frame2_height_get, _obspython.obs_source_frame2_height_set)
    timestamp = property(_obspython.obs_source_frame2_timestamp_get, _obspython.obs_source_frame2_timestamp_set)
    format = property(_obspython.obs_source_frame2_format_get, _obspython.obs_source_frame2_format_set)
    range = property(_obspython.obs_source_frame2_range_get, _obspython.obs_source_frame2_range_set)
    color_matrix = property(_obspython.obs_source_frame2_color_matrix_get, _obspython.obs_source_frame2_color_matrix_set)
    color_range_min = property(_obspython.obs_source_frame2_color_range_min_get, _obspython.obs_source_frame2_color_range_min_set)
    color_range_max = property(_obspython.obs_source_frame2_color_range_max_get, _obspython.obs_source_frame2_color_range_max_set)
    flip = property(_obspython.obs_source_frame2_flip_get, _obspython.obs_source_frame2_flip_set)

    def __init__(self):
        _obspython.obs_source_frame2_swiginit(self, _obspython.new_obs_source_frame2())
    __swig_destroy__ = _obspython.delete_obs_source_frame2

# Register obs_source_frame2 in _obspython:
_obspython.obs_source_frame2_swigregister(obs_source_frame2)

class obs_cmdline_args(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    argc = property(_obspython.obs_cmdline_args_argc_get, _obspython.obs_cmdline_args_argc_set)
    argv = property(_obspython.obs_cmdline_args_argv_get, _obspython.obs_cmdline_args_argv_set)

    def __init__(self):
        _obspython.obs_cmdline_args_swiginit(self, _obspython.new_obs_cmdline_args())
    __swig_destroy__ = _obspython.delete_obs_cmdline_args

# Register obs_cmdline_args in _obspython:
_obspython.obs_cmdline_args_swigregister(obs_cmdline_args)


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

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

def obs_remove_data_path(path: 'char const *') -> "bool":
    return _obspython.obs_remove_data_path(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)

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

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

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

def obs_get_version_string() -> "char const *":
    return _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)

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

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

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

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

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

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

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

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

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)

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

def obs_log_loaded_modules() -> "void":
    return _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)

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

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

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

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

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

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

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

def obs_post_load_modules() -> "void":
    return _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)

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)

def obs_find_module_file(module: 'obs_module_t *', file: 'char const *') -> "char *":
    return _obspython.obs_find_module_file(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)

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

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

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

def obs_get_latest_input_type_id(unversioned_id: 'char const *') -> "char const *":
    return _obspython.obs_get_latest_input_type_id(unversioned_id)

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

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

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

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

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

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

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

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

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

def obs_video_active() -> "bool":
    return _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)

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

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

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

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

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

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

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

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

def obs_get_service_by_name(name: 'char const *') -> "obs_service_t *":
    return _obspython.obs_get_service_by_name(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)

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

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

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

def obs_render_main_texture_src_color_only() -> "void":
    return _obspython.obs_render_main_texture_src_color_only()

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

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

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

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

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

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

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

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)

def obs_save_sources() -> "obs_data_array_t *":
    return _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_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)

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

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

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

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

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

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

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)

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

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

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

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

def obs_get_frame_interval_ns() -> "uint64_t":
    return _obspython.obs_get_frame_interval_ns()

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

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

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

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

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

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

def obs_queue_task(type: 'enum obs_task_type', task: 'obs_task_t', param: 'void *', wait: 'bool') -> "void":
    return _obspython.obs_queue_task(type, task, param, wait)

def obs_set_ui_task_handler(handler: 'obs_task_handler_t') -> "void":
    return _obspython.obs_set_ui_task_handler(handler)

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

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

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)

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

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

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)

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

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

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)

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)

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

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

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

def obs_display_size(display: 'obs_display_t *', width: 'uint32_t *', height: 'uint32_t *') -> "void":
    return _obspython.obs_display_size(display, width, height)

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

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)

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)

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)

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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)

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

def obs_source_showing(source: 'obs_source_t const *') -> "bool":
    return _obspython.obs_source_showing(source)
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)

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

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

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

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

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

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

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

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)

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)

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

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

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

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

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

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

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

def obs_source_get_push_to_mute_delay(source: 'obs_source_t *') -> "uint64_t":
    return _obspython.obs_source_get_push_to_mute_delay(source)

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)

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

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

def obs_source_get_push_to_talk_delay(source: 'obs_source_t *') -> "uint64_t":
    return _obspython.obs_source_get_push_to_talk_delay(source)

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)

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)

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

def obs_source_get_deinterlace_mode(source: 'obs_source_t const *') -> "enum obs_deinterlace_mode":
    return _obspython.obs_source_get_deinterlace_mode(source)

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)

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

def obs_source_get_monitoring_type(source: 'obs_source_t const *') -> "enum obs_monitoring_type":
    return _obspython.obs_source_get_monitoring_type(source)

def obs_source_get_private_settings(item: 'obs_source_t *') -> "obs_data_t *":
    return _obspython.obs_source_get_private_settings(item)

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

def obs_source_draw_set_color_matrix(color_matrix: 'matrix4', 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)

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)

def obs_source_output_video(source: 'obs_source_t *', frame: 'obs_source_frame') -> "void":
    return _obspython.obs_source_output_video(source, frame)

def obs_source_output_video2(source: 'obs_source_t *', frame: 'obs_source_frame2') -> "void":
    return _obspython.obs_source_output_video2(source, frame)

def obs_source_set_async_rotation(source: 'obs_source_t *', rotation: 'long') -> "void":
    return _obspython.obs_source_set_async_rotation(source, rotation)

def obs_source_preload_video(source: 'obs_source_t *', frame: 'obs_source_frame') -> "void":
    return _obspython.obs_source_preload_video(source, frame)

def obs_source_preload_video2(source: 'obs_source_t *', frame: 'obs_source_frame2') -> "void":
    return _obspython.obs_source_preload_video2(source, frame)

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

def obs_source_output_audio(source: 'obs_source_t *', audio: 'obs_source_audio') -> "void":
    return _obspython.obs_source_output_audio(source, audio)

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

def obs_source_get_frame(source: 'obs_source_t *') -> "struct obs_source_frame *":
    return _obspython.obs_source_get_frame(source)

def obs_source_release_frame(source: 'obs_source_t *', frame: 'obs_source_frame') -> "void":
    return _obspython.obs_source_release_frame(source, 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)

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)

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)

def obs_source_skip_video_filter(filter: 'obs_source_t *') -> "void":
    return _obspython.obs_source_skip_video_filter(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)

def obs_source_remove_active_child(parent: 'obs_source_t *', child: 'obs_source_t *') -> "void":
    return _obspython.obs_source_remove_active_child(parent, 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)

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)

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)

def obs_source_send_focus(source: 'obs_source_t *', focus: 'bool') -> "void":
    return _obspython.obs_source_send_focus(source, 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)

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

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

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

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

def obs_source_get_audio_timestamp(source: 'obs_source_t const *') -> "uint64_t":
    return _obspython.obs_source_get_audio_timestamp(source)

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)

def obs_source_set_async_unbuffered(source: 'obs_source_t *', unbuffered: 'bool') -> "void":
    return _obspython.obs_source_set_async_unbuffered(source, unbuffered)

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

def obs_source_set_async_decoupled(source: 'obs_source_t *', decouple: 'bool') -> "void":
    return _obspython.obs_source_set_async_decoupled(source, decouple)

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

def obs_source_set_audio_active(source: 'obs_source_t *', show: 'bool') -> "void":
    return _obspython.obs_source_set_audio_active(source, show)

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

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

def obs_source_media_play_pause(source: 'obs_source_t *', pause: 'bool') -> "void":
    return _obspython.obs_source_media_play_pause(source, pause)

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

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

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

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

def obs_source_media_get_duration(source: 'obs_source_t *') -> "int64_t":
    return _obspython.obs_source_media_get_duration(source)

def obs_source_media_get_time(source: 'obs_source_t *') -> "int64_t":
    return _obspython.obs_source_media_get_time(source)

def obs_source_media_set_time(source: 'obs_source_t *', ms: 'int64_t') -> "void":
    return _obspython.obs_source_media_set_time(source, ms)

def obs_source_media_get_state(source: 'obs_source_t *') -> "enum obs_media_state":
    return _obspython.obs_source_media_get_state(source)

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

def obs_source_media_ended(source: 'obs_source_t *') -> "void":
    return _obspython.obs_source_media_ended(source)
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)

def obs_transition_clear(transition: 'obs_source_t *') -> "void":
    return _obspython.obs_transition_clear(transition)

def obs_transition_get_active_source(transition: 'obs_source_t *') -> "obs_source_t *":
    return _obspython.obs_transition_get_active_source(transition)
OBS_TRANSITION_MODE_AUTO = _obspython.OBS_TRANSITION_MODE_AUTO
OBS_TRANSITION_MODE_MANUAL = _obspython.OBS_TRANSITION_MODE_MANUAL

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)

def obs_transition_set(transition: 'obs_source_t *', source: 'obs_source_t *') -> "void":
    return _obspython.obs_transition_set(transition, source)

def obs_transition_set_manual_time(transition: 'obs_source_t *', t: 'float') -> "void":
    return _obspython.obs_transition_set_manual_time(transition, t)

def obs_transition_set_manual_torque(transition: 'obs_source_t *', torque: 'float', clamp: 'float') -> "void":
    return _obspython.obs_transition_set_manual_torque(transition, torque, clamp)
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)

def obs_transition_get_scale_type(transition: 'obs_source_t const *') -> "enum obs_transition_scale_type":
    return _obspython.obs_transition_get_scale_type(transition)

def obs_transition_set_alignment(transition: 'obs_source_t *', alignment: 'uint32_t') -> "void":
    return _obspython.obs_transition_set_alignment(transition, alignment)

def obs_transition_get_alignment(transition: 'obs_source_t const *') -> "uint32_t":
    return _obspython.obs_transition_get_alignment(transition)

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)

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)

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)

def obs_transition_fixed(transition: 'obs_source_t *') -> "bool":
    return _obspython.obs_transition_fixed(transition)

def obs_transition_get_time(transition: 'obs_source_t *') -> "float":
    return _obspython.obs_transition_get_time(transition)

def obs_transition_force_stop(transition: 'obs_source_t *') -> "void":
    return _obspython.obs_transition_force_stop(transition)

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)

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)

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)

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)

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)

def obs_scene_create(name: 'char const *') -> "obs_scene_t *":
    return _obspython.obs_scene_create(name)

def obs_scene_create_private(name: 'char const *') -> "obs_scene_t *":
    return _obspython.obs_scene_create_private(name)
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)

def obs_scene_addref(scene: 'obs_scene_t *') -> "void":
    return _obspython.obs_scene_addref(scene)

def obs_scene_release(scene: 'obs_scene_t *') -> "void":
    return _obspython.obs_scene_release(scene)

def obs_scene_get_source(scene: 'obs_scene_t const *') -> "obs_source_t *":
    return _obspython.obs_scene_get_source(scene)

def obs_scene_from_source(source: 'obs_source_t const *') -> "obs_scene_t *":
    return _obspython.obs_scene_from_source(source)

def obs_scene_find_source(scene: 'obs_scene_t *', name: 'char const *') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_find_source(scene, name)

def obs_scene_find_source_recursive(scene: 'obs_scene_t *', name: 'char const *') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_find_source_recursive(scene, name)

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)

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)

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)
class obs_sceneitem_order_info(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    group = property(_obspython.obs_sceneitem_order_info_group_get, _obspython.obs_sceneitem_order_info_group_set)
    item = property(_obspython.obs_sceneitem_order_info_item_get, _obspython.obs_sceneitem_order_info_item_set)

    def __init__(self):
        _obspython.obs_sceneitem_order_info_swiginit(self, _obspython.new_obs_sceneitem_order_info())
    __swig_destroy__ = _obspython.delete_obs_sceneitem_order_info

# Register obs_sceneitem_order_info in _obspython:
_obspython.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)

def obs_scene_add(scene: 'obs_scene_t *', source: 'obs_source_t *') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_add(scene, source)

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)

def obs_sceneitem_addref(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_addref(item)

def obs_sceneitem_release(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_release(item)

def obs_sceneitem_remove(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_remove(item)

def obs_sceneitem_get_scene(item: 'obs_sceneitem_t const *') -> "obs_scene_t *":
    return _obspython.obs_sceneitem_get_scene(item)

def obs_sceneitem_get_source(item: 'obs_sceneitem_t const *') -> "obs_source_t *":
    return _obspython.obs_sceneitem_get_source(item)

def obs_sceneitem_select(item: 'obs_sceneitem_t *', select: 'bool') -> "void":
    return _obspython.obs_sceneitem_select(item, select)

def obs_sceneitem_selected(item: 'obs_sceneitem_t const *') -> "bool":
    return _obspython.obs_sceneitem_selected(item)

def obs_sceneitem_locked(item: 'obs_sceneitem_t const *') -> "bool":
    return _obspython.obs_sceneitem_locked(item)

def obs_sceneitem_set_locked(item: 'obs_sceneitem_t *', lock: 'bool') -> "bool":
    return _obspython.obs_sceneitem_set_locked(item, lock)

def obs_sceneitem_set_pos(item: 'obs_sceneitem_t *', pos: 'vec2') -> "void":
    return _obspython.obs_sceneitem_set_pos(item, pos)

def obs_sceneitem_set_rot(item: 'obs_sceneitem_t *', rot_deg: 'float') -> "void":
    return _obspython.obs_sceneitem_set_rot(item, rot_deg)

def obs_sceneitem_set_scale(item: 'obs_sceneitem_t *', scale: 'vec2') -> "void":
    return _obspython.obs_sceneitem_set_scale(item, scale)

def obs_sceneitem_set_alignment(item: 'obs_sceneitem_t *', alignment: 'uint32_t') -> "void":
    return _obspython.obs_sceneitem_set_alignment(item, alignment)

def obs_sceneitem_set_order(item: 'obs_sceneitem_t *', movement: 'enum obs_order_movement') -> "void":
    return _obspython.obs_sceneitem_set_order(item, movement)

def obs_sceneitem_set_order_position(item: 'obs_sceneitem_t *', position: 'int') -> "void":
    return _obspython.obs_sceneitem_set_order_position(item, 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)

def obs_sceneitem_set_bounds_alignment(item: 'obs_sceneitem_t *', alignment: 'uint32_t') -> "void":
    return _obspython.obs_sceneitem_set_bounds_alignment(item, alignment)

def obs_sceneitem_set_bounds(item: 'obs_sceneitem_t *', bounds: 'vec2') -> "void":
    return _obspython.obs_sceneitem_set_bounds(item, bounds)

def obs_sceneitem_get_id(item: 'obs_sceneitem_t const *') -> "int64_t":
    return _obspython.obs_sceneitem_get_id(item)

def obs_sceneitem_get_pos(item: 'obs_sceneitem_t const *', pos: 'vec2') -> "void":
    return _obspython.obs_sceneitem_get_pos(item, pos)

def obs_sceneitem_get_rot(item: 'obs_sceneitem_t const *') -> "float":
    return _obspython.obs_sceneitem_get_rot(item)

def obs_sceneitem_get_scale(item: 'obs_sceneitem_t const *', scale: 'vec2') -> "void":
    return _obspython.obs_sceneitem_get_scale(item, scale)

def obs_sceneitem_get_alignment(item: 'obs_sceneitem_t const *') -> "uint32_t":
    return _obspython.obs_sceneitem_get_alignment(item)

def obs_sceneitem_get_bounds_type(item: 'obs_sceneitem_t const *') -> "enum obs_bounds_type":
    return _obspython.obs_sceneitem_get_bounds_type(item)

def obs_sceneitem_get_bounds_alignment(item: 'obs_sceneitem_t const *') -> "uint32_t":
    return _obspython.obs_sceneitem_get_bounds_alignment(item)

def obs_sceneitem_get_bounds(item: 'obs_sceneitem_t const *', bounds: 'vec2') -> "void":
    return _obspython.obs_sceneitem_get_bounds(item, bounds)

def obs_sceneitem_get_info(item: 'obs_sceneitem_t const *', info: 'obs_transform_info') -> "void":
    return _obspython.obs_sceneitem_get_info(item, info)

def obs_sceneitem_set_info(item: 'obs_sceneitem_t *', info: 'obs_transform_info') -> "void":
    return _obspython.obs_sceneitem_set_info(item, info)

def obs_sceneitem_get_draw_transform(item: 'obs_sceneitem_t const *', transform: 'matrix4') -> "void":
    return _obspython.obs_sceneitem_get_draw_transform(item, transform)

def obs_sceneitem_get_box_transform(item: 'obs_sceneitem_t const *', transform: 'matrix4') -> "void":
    return _obspython.obs_sceneitem_get_box_transform(item, transform)

def obs_sceneitem_get_box_scale(item: 'obs_sceneitem_t const *', scale: 'vec2') -> "void":
    return _obspython.obs_sceneitem_get_box_scale(item, scale)

def obs_sceneitem_visible(item: 'obs_sceneitem_t const *') -> "bool":
    return _obspython.obs_sceneitem_visible(item)

def obs_sceneitem_set_visible(item: 'obs_sceneitem_t *', visible: 'bool') -> "bool":
    return _obspython.obs_sceneitem_set_visible(item, visible)
class obs_sceneitem_crop(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    left = property(_obspython.obs_sceneitem_crop_left_get, _obspython.obs_sceneitem_crop_left_set)
    top = property(_obspython.obs_sceneitem_crop_top_get, _obspython.obs_sceneitem_crop_top_set)
    right = property(_obspython.obs_sceneitem_crop_right_get, _obspython.obs_sceneitem_crop_right_set)
    bottom = property(_obspython.obs_sceneitem_crop_bottom_get, _obspython.obs_sceneitem_crop_bottom_set)

    def __init__(self):
        _obspython.obs_sceneitem_crop_swiginit(self, _obspython.new_obs_sceneitem_crop())
    __swig_destroy__ = _obspython.delete_obs_sceneitem_crop

# Register obs_sceneitem_crop in _obspython:
_obspython.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)

def obs_sceneitem_get_crop(item: 'obs_sceneitem_t const *', crop: 'obs_sceneitem_crop') -> "void":
    return _obspython.obs_sceneitem_get_crop(item, 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)

def obs_sceneitem_get_scale_filter(item: 'obs_sceneitem_t *') -> "enum obs_scale_type":
    return _obspython.obs_sceneitem_get_scale_filter(item)

def obs_sceneitem_force_update_transform(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_force_update_transform(item)

def obs_sceneitem_defer_update_begin(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_defer_update_begin(item)

def obs_sceneitem_defer_update_end(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_defer_update_end(item)

def obs_sceneitem_get_private_settings(item: 'obs_sceneitem_t *') -> "obs_data_t *":
    return _obspython.obs_sceneitem_get_private_settings(item)

def obs_scene_add_group(scene: 'obs_scene_t *', name: 'char const *') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_add_group(scene, name)

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)

def obs_scene_add_group2(scene: 'obs_scene_t *', name: 'char const *', signal: 'bool') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_add_group2(scene, name, signal)

def obs_scene_insert_group2(scene: 'obs_scene_t *', name: 'char const *', items: 'obs_sceneitem_t **', count: 'size_t', signal: 'bool') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_insert_group2(scene, name, items, count, signal)

def obs_scene_get_group(scene: 'obs_scene_t *', name: 'char const *') -> "obs_sceneitem_t *":
    return _obspython.obs_scene_get_group(scene, name)

def obs_sceneitem_is_group(item: 'obs_sceneitem_t *') -> "bool":
    return _obspython.obs_sceneitem_is_group(item)

def obs_sceneitem_group_get_scene(group: 'obs_sceneitem_t const *') -> "obs_scene_t *":
    return _obspython.obs_sceneitem_group_get_scene(group)

def obs_sceneitem_group_ungroup(group: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_group_ungroup(group)

def obs_sceneitem_group_ungroup2(group: 'obs_sceneitem_t *', signal: 'bool') -> "void":
    return _obspython.obs_sceneitem_group_ungroup2(group, signal)

def obs_sceneitem_group_add_item(group: 'obs_sceneitem_t *', item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_group_add_item(group, 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)

def obs_sceneitem_get_group(scene: 'obs_scene_t *', item: 'obs_sceneitem_t *') -> "obs_sceneitem_t *":
    return _obspython.obs_sceneitem_get_group(scene, item)

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

def obs_scene_is_group(scene: 'obs_scene_t const *') -> "bool":
    return _obspython.obs_scene_is_group(scene)

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)

def obs_group_from_source(source: 'obs_source_t const *') -> "obs_scene_t *":
    return _obspython.obs_group_from_source(source)

def obs_sceneitem_defer_group_resize_begin(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_defer_group_resize_begin(item)

def obs_sceneitem_defer_group_resize_end(item: 'obs_sceneitem_t *') -> "void":
    return _obspython.obs_sceneitem_defer_group_resize_end(item)

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

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)

def obs_output_addref(output: 'obs_output_t *') -> "void":
    return _obspython.obs_output_addref(output)

def obs_output_release(output: 'obs_output_t *') -> "void":
    return _obspython.obs_output_release(output)

def obs_weak_output_addref(weak: 'obs_weak_output_t *') -> "void":
    return _obspython.obs_weak_output_addref(weak)

def obs_weak_output_release(weak: 'obs_weak_output_t *') -> "void":
    return _obspython.obs_weak_output_release(weak)

def obs_output_get_ref(output: 'obs_output_t *') -> "obs_output_t *":
    return _obspython.obs_output_get_ref(output)

def obs_output_get_weak_output(output: 'obs_output_t *') -> "obs_weak_output_t *":
    return _obspython.obs_output_get_weak_output(output)

def obs_weak_output_get_output(weak: 'obs_weak_output_t *') -> "obs_output_t *":
    return _obspython.obs_weak_output_get_output(weak)

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)

def obs_output_get_name(output: 'obs_output_t const *') -> "char const *":
    return _obspython.obs_output_get_name(output)

def obs_output_start(output: 'obs_output_t *') -> "bool":
    return _obspython.obs_output_start(output)

def obs_output_stop(output: 'obs_output_t *') -> "void":
    return _obspython.obs_output_stop(output)
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)

def obs_output_get_delay(output: 'obs_output_t const *') -> "uint32_t":
    return _obspython.obs_output_get_delay(output)

def obs_output_get_active_delay(output: 'obs_output_t const *') -> "uint32_t":
    return _obspython.obs_output_get_active_delay(output)

def obs_output_force_stop(output: 'obs_output_t *') -> "void":
    return _obspython.obs_output_force_stop(output)

def obs_output_active(output: 'obs_output_t const *') -> "bool":
    return _obspython.obs_output_active(output)

def obs_output_get_flags(output: 'obs_output_t const *') -> "uint32_t":
    return _obspython.obs_output_get_flags(output)

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

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

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

def obs_output_properties(output: 'obs_output_t const *') -> "obs_properties_t *":
    return _obspython.obs_output_properties(output)

def obs_output_update(output: 'obs_output_t *', settings: 'obs_data_t *') -> "void":
    return _obspython.obs_output_update(output, settings)

def obs_output_can_pause(output: 'obs_output_t const *') -> "bool":
    return _obspython.obs_output_can_pause(output)

def obs_output_pause(output: 'obs_output_t *', pause: 'bool') -> "bool":
    return _obspython.obs_output_pause(output, pause)

def obs_output_paused(output: 'obs_output_t const *') -> "bool":
    return _obspython.obs_output_paused(output)

def obs_output_get_settings(output: 'obs_output_t const *') -> "obs_data_t *":
    return _obspython.obs_output_get_settings(output)

def obs_output_get_signal_handler(output: 'obs_output_t const *') -> "signal_handler_t *":
    return _obspython.obs_output_get_signal_handler(output)

def obs_output_get_proc_handler(output: 'obs_output_t const *') -> "proc_handler_t *":
    return _obspython.obs_output_get_proc_handler(output)

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)

def obs_output_audio(output: 'obs_output_t const *') -> "audio_t *":
    return _obspython.obs_output_audio(output)

def obs_output_set_mixer(output: 'obs_output_t *', mixer_idx: 'size_t') -> "void":
    return _obspython.obs_output_set_mixer(output, mixer_idx)

def obs_output_get_mixer(output: 'obs_output_t const *') -> "size_t":
    return _obspython.obs_output_get_mixer(output)

def obs_output_set_mixers(output: 'obs_output_t *', mixers: 'size_t') -> "void":
    return _obspython.obs_output_set_mixers(output, mixers)

def obs_output_get_mixers(output: 'obs_output_t const *') -> "size_t":
    return _obspython.obs_output_get_mixers(output)

def obs_output_set_video_encoder(output: 'obs_output_t *', encoder: 'obs_encoder_t *') -> "void":
    return _obspython.obs_output_set_video_encoder(output, 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)

def obs_output_get_video_encoder(output: 'obs_output_t const *') -> "obs_encoder_t *":
    return _obspython.obs_output_get_video_encoder(output)

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)

def obs_output_set_service(output: 'obs_output_t *', service: 'obs_service_t *') -> "void":
    return _obspython.obs_output_set_service(output, service)

def obs_output_get_service(output: 'obs_output_t const *') -> "obs_service_t *":
    return _obspython.obs_output_get_service(output)

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)

def obs_output_get_total_bytes(output: 'obs_output_t const *') -> "uint64_t":
    return _obspython.obs_output_get_total_bytes(output)

def obs_output_get_frames_dropped(output: 'obs_output_t const *') -> "int":
    return _obspython.obs_output_get_frames_dropped(output)

def obs_output_get_total_frames(output: 'obs_output_t const *') -> "int":
    return _obspython.obs_output_get_total_frames(output)

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)

def obs_output_get_width(output: 'obs_output_t const *') -> "uint32_t":
    return _obspython.obs_output_get_width(output)

def obs_output_get_height(output: 'obs_output_t const *') -> "uint32_t":
    return _obspython.obs_output_get_height(output)

def obs_output_get_id(output: 'obs_output_t const *') -> "char const *":
    return _obspython.obs_output_get_id(output)

def obs_output_get_congestion(output: 'obs_output_t *') -> "float":
    return _obspython.obs_output_get_congestion(output)

def obs_output_get_connect_time_ms(output: 'obs_output_t *') -> "int":
    return _obspython.obs_output_get_connect_time_ms(output)

def obs_output_reconnecting(output: 'obs_output_t const *') -> "bool":
    return _obspython.obs_output_reconnecting(output)

def obs_output_set_last_error(output: 'obs_output_t *', message: 'char const *') -> "void":
    return _obspython.obs_output_set_last_error(output, message)

def obs_output_get_last_error(output: 'obs_output_t *') -> "char const *":
    return _obspython.obs_output_get_last_error(output)

def obs_output_get_supported_video_codecs(output: 'obs_output_t const *') -> "char const *":
    return _obspython.obs_output_get_supported_video_codecs(output)

def obs_output_get_supported_audio_codecs(output: 'obs_output_t const *') -> "char const *":
    return _obspython.obs_output_get_supported_audio_codecs(output)

def obs_output_get_type_data(output: 'obs_output_t *') -> "void *":
    return _obspython.obs_output_get_type_data(output)

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)

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)

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)

def obs_output_initialize_encoders(output: 'obs_output_t *', flags: 'uint32_t') -> "bool":
    return _obspython.obs_output_initialize_encoders(output, flags)

def obs_output_begin_data_capture(output: 'obs_output_t *', flags: 'uint32_t') -> "bool":
    return _obspython.obs_output_begin_data_capture(output, flags)

def obs_output_end_data_capture(output: 'obs_output_t *') -> "void":
    return _obspython.obs_output_end_data_capture(output)

def obs_output_signal_stop(output: 'obs_output_t *', code: 'int') -> "void":
    return _obspython.obs_output_signal_stop(output, code)

def obs_output_get_pause_offset(output: 'obs_output_t *') -> "uint64_t":
    return _obspython.obs_output_get_pause_offset(output)

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

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)

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)

def obs_encoder_addref(encoder: 'obs_encoder_t *') -> "void":
    return _obspython.obs_encoder_addref(encoder)

def obs_encoder_release(encoder: 'obs_encoder_t *') -> "void":
    return _obspython.obs_encoder_release(encoder)

def obs_weak_encoder_addref(weak: 'obs_weak_encoder_t *') -> "void":
    return _obspython.obs_weak_encoder_addref(weak)

def obs_weak_encoder_release(weak: 'obs_weak_encoder_t *') -> "void":
    return _obspython.obs_weak_encoder_release(weak)

def obs_encoder_get_ref(encoder: 'obs_encoder_t *') -> "obs_encoder_t *":
    return _obspython.obs_encoder_get_ref(encoder)

def obs_encoder_get_weak_encoder(encoder: 'obs_encoder_t *') -> "obs_weak_encoder_t *":
    return _obspython.obs_encoder_get_weak_encoder(encoder)

def obs_weak_encoder_get_encoder(weak: 'obs_weak_encoder_t *') -> "obs_encoder_t *":
    return _obspython.obs_weak_encoder_get_encoder(weak)

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)

def obs_encoder_set_name(encoder: 'obs_encoder_t *', name: 'char const *') -> "void":
    return _obspython.obs_encoder_set_name(encoder, name)

def obs_encoder_get_name(encoder: 'obs_encoder_t const *') -> "char const *":
    return _obspython.obs_encoder_get_name(encoder)

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

def obs_get_encoder_type(id: 'char const *') -> "enum obs_encoder_type":
    return _obspython.obs_get_encoder_type(id)

def obs_encoder_get_codec(encoder: 'obs_encoder_t const *') -> "char const *":
    return _obspython.obs_encoder_get_codec(encoder)

def obs_encoder_get_type(encoder: 'obs_encoder_t const *') -> "enum obs_encoder_type":
    return _obspython.obs_encoder_get_type(encoder)

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)

def obs_encoder_scaling_enabled(encoder: 'obs_encoder_t const *') -> "bool":
    return _obspython.obs_encoder_scaling_enabled(encoder)

def obs_encoder_get_width(encoder: 'obs_encoder_t const *') -> "uint32_t":
    return _obspython.obs_encoder_get_width(encoder)

def obs_encoder_get_height(encoder: 'obs_encoder_t const *') -> "uint32_t":
    return _obspython.obs_encoder_get_height(encoder)

def obs_encoder_get_sample_rate(encoder: 'obs_encoder_t const *') -> "uint32_t":
    return _obspython.obs_encoder_get_sample_rate(encoder)

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)

def obs_encoder_get_preferred_video_format(encoder: 'obs_encoder_t const *') -> "enum video_format":
    return _obspython.obs_encoder_get_preferred_video_format(encoder)

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

def obs_encoder_get_defaults(encoder: 'obs_encoder_t const *') -> "obs_data_t *":
    return _obspython.obs_encoder_get_defaults(encoder)

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

def obs_encoder_properties(encoder: 'obs_encoder_t const *') -> "obs_properties_t *":
    return _obspython.obs_encoder_properties(encoder)

def obs_encoder_update(encoder: 'obs_encoder_t *', settings: 'obs_data_t *') -> "void":
    return _obspython.obs_encoder_update(encoder, settings)

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)

def obs_encoder_get_settings(encoder: 'obs_encoder_t const *') -> "obs_data_t *":
    return _obspython.obs_encoder_get_settings(encoder)

def obs_encoder_set_video(encoder: 'obs_encoder_t *', video: 'video_t *') -> "void":
    return _obspython.obs_encoder_set_video(encoder, video)

def obs_encoder_set_audio(encoder: 'obs_encoder_t *', audio: 'audio_t *') -> "void":
    return _obspython.obs_encoder_set_audio(encoder, audio)

def obs_encoder_video(encoder: 'obs_encoder_t const *') -> "video_t *":
    return _obspython.obs_encoder_video(encoder)

def obs_encoder_audio(encoder: 'obs_encoder_t const *') -> "audio_t *":
    return _obspython.obs_encoder_audio(encoder)

def obs_encoder_active(encoder: 'obs_encoder_t const *') -> "bool":
    return _obspython.obs_encoder_active(encoder)

def obs_encoder_get_type_data(encoder: 'obs_encoder_t *') -> "void *":
    return _obspython.obs_encoder_get_type_data(encoder)

def obs_encoder_get_id(encoder: 'obs_encoder_t const *') -> "char const *":
    return _obspython.obs_encoder_get_id(encoder)

def obs_get_encoder_caps(encoder_id: 'char const *') -> "uint32_t":
    return _obspython.obs_get_encoder_caps(encoder_id)

def obs_encoder_get_caps(encoder: 'obs_encoder_t const *') -> "uint32_t":
    return _obspython.obs_encoder_get_caps(encoder)

def obs_encoder_packet_ref(dst: 'struct encoder_packet *', src: 'struct encoder_packet *') -> "void":
    return _obspython.obs_encoder_packet_ref(dst, src)

def obs_encoder_packet_release(packet: 'struct encoder_packet *') -> "void":
    return _obspython.obs_encoder_packet_release(packet)

def obs_encoder_create_rerouted(encoder: 'obs_encoder_t *', reroute_id: 'char const *') -> "void *":
    return _obspython.obs_encoder_create_rerouted(encoder, reroute_id)

def obs_encoder_paused(output: 'obs_encoder_t const *') -> "bool":
    return _obspython.obs_encoder_paused(output)

def obs_encoder_get_last_error(encoder: 'obs_encoder_t *') -> "char const *":
    return _obspython.obs_encoder_get_last_error(encoder)

def obs_encoder_set_last_error(encoder: 'obs_encoder_t *', message: 'char const *') -> "void":
    return _obspython.obs_encoder_set_last_error(encoder, message)

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

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)

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)

def obs_service_addref(service: 'obs_service_t *') -> "void":
    return _obspython.obs_service_addref(service)

def obs_service_release(service: 'obs_service_t *') -> "void":
    return _obspython.obs_service_release(service)

def obs_weak_service_addref(weak: 'obs_weak_service_t *') -> "void":
    return _obspython.obs_weak_service_addref(weak)

def obs_weak_service_release(weak: 'obs_weak_service_t *') -> "void":
    return _obspython.obs_weak_service_release(weak)

def obs_service_get_ref(service: 'obs_service_t *') -> "obs_service_t *":
    return _obspython.obs_service_get_ref(service)

def obs_service_get_weak_service(service: 'obs_service_t *') -> "obs_weak_service_t *":
    return _obspython.obs_service_get_weak_service(service)

def obs_weak_service_get_service(weak: 'obs_weak_service_t *') -> "obs_service_t *":
    return _obspython.obs_weak_service_get_service(weak)

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)

def obs_service_get_name(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_name(service)

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

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

def obs_service_properties(service: 'obs_service_t const *') -> "obs_properties_t *":
    return _obspython.obs_service_properties(service)

def obs_service_get_type(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_type(service)

def obs_service_update(service: 'obs_service_t *', settings: 'obs_data_t *') -> "void":
    return _obspython.obs_service_update(service, settings)

def obs_service_get_settings(service: 'obs_service_t const *') -> "obs_data_t *":
    return _obspython.obs_service_get_settings(service)

def obs_service_get_url(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_url(service)

def obs_service_get_key(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_key(service)

def obs_service_get_username(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_username(service)

def obs_service_get_password(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_password(service)

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)

def obs_service_get_type_data(service: 'obs_service_t *') -> "void *":
    return _obspython.obs_service_get_type_data(service)

def obs_service_get_id(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_id(service)

def obs_service_get_output_type(service: 'obs_service_t const *') -> "char const *":
    return _obspython.obs_service_get_output_type(service)

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)

def obs_source_frame_free(frame: 'obs_source_frame') -> "void":
    return _obspython.obs_source_frame_free(frame)

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)

def obs_source_frame_destroy(frame: 'obs_source_frame') -> "void":
    return _obspython.obs_source_frame_destroy(frame)

def obs_source_frame_copy(dst: 'obs_source_frame', src: 'obs_source_frame') -> "void":
    return _obspython.obs_source_frame_copy(dst, src)

def obs_source_get_icon_type(id: 'char const *') -> "enum obs_icon_type":
    return _obspython.obs_source_get_icon_type(id)
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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    stack = property(_obspython.calldata_stack_get, _obspython.calldata_stack_set)
    size = property(_obspython.calldata_size_get, _obspython.calldata_size_set)
    capacity = property(_obspython.calldata_capacity_get, _obspython.calldata_capacity_set)
    fixed = property(_obspython.calldata_fixed_get, _obspython.calldata_fixed_set)

    def __init__(self):
        _obspython.calldata_swiginit(self, _obspython.new_calldata())
    __swig_destroy__ = _obspython.delete_calldata

# Register calldata in _obspython:
_obspython.calldata_swigregister(calldata)


def calldata_init(data: 'calldata') -> "void":
    return _obspython.calldata_init(data)

def calldata_clear(data: 'calldata') -> "void":
    return _obspython.calldata_clear(data)

def calldata_init_fixed(data: 'calldata', stack: 'uint8_t *', size: 'size_t') -> "void":
    return _obspython.calldata_init_fixed(data, stack, size)

def calldata_free(data: 'calldata') -> "void":
    return _obspython.calldata_free(data)

def calldata_get_data(data: 'calldata', name: 'char const *', out: 'void *', size: 'size_t') -> "bool":
    return _obspython.calldata_get_data(data, name, out, size)

def calldata_set_data(data: 'calldata', name: 'char const *', _in: 'void const *', new_size: 'size_t') -> "void":
    return _obspython.calldata_set_data(data, name, _in, new_size)

def calldata_create() -> "calldata_t *":
    return _obspython.calldata_create()

def calldata_destroy(cd: 'calldata') -> "void":
    return _obspython.calldata_destroy(cd)

def calldata_get_int(data: 'calldata', name: 'char const *', val: 'long long *') -> "bool":
    return _obspython.calldata_get_int(data, name, val)

def calldata_get_float(data: 'calldata', name: 'char const *', val: 'double *') -> "bool":
    return _obspython.calldata_get_float(data, name, val)

def calldata_get_bool(data: 'calldata', name: 'char const *', val: 'bool *') -> "bool":
    return _obspython.calldata_get_bool(data, name, val)

def calldata_get_ptr(data: 'calldata', name: 'char const *', p_ptr: 'void *') -> "bool":
    return _obspython.calldata_get_ptr(data, name, p_ptr)

def calldata_get_string(data: 'calldata', name: 'char const *', str: 'char const **') -> "bool":
    return _obspython.calldata_get_string(data, name, str)

def calldata_int(data: 'calldata', name: 'char const *') -> "long long":
    return _obspython.calldata_int(data, name)

def calldata_float(data: 'calldata', name: 'char const *') -> "double":
    return _obspython.calldata_float(data, name)

def calldata_bool(data: 'calldata', name: 'char const *') -> "bool":
    return _obspython.calldata_bool(data, name)

def calldata_ptr(data: 'calldata', name: 'char const *') -> "void *":
    return _obspython.calldata_ptr(data, name)

def calldata_string(data: 'calldata', name: 'char const *') -> "char const *":
    return _obspython.calldata_string(data, name)

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

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

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

def calldata_set_ptr(data: 'calldata', name: 'char const *', ptr: 'void *') -> "void":
    return _obspython.calldata_set_ptr(data, name, ptr)

def calldata_set_string(data: 'calldata', name: 'char const *', str: 'char const *') -> "void":
    return _obspython.calldata_set_string(data, name, str)

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

def proc_handler_destroy(handler: 'proc_handler_t *') -> "void":
    return _obspython.proc_handler_destroy(handler)

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)

def proc_handler_call(handler: 'proc_handler_t *', name: 'char const *', params: 'calldata') -> "bool":
    return _obspython.proc_handler_call(handler, name, params)

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

def signal_handler_destroy(handler: 'signal_handler_t *') -> "void":
    return _obspython.signal_handler_destroy(handler)

def signal_handler_add(handler: 'signal_handler_t *', signal_decl: 'char const *') -> "bool":
    return _obspython.signal_handler_add(handler, signal_decl)

def signal_handler_add_array(handler: 'signal_handler_t *', signal_decls: 'char const **') -> "bool":
    return _obspython.signal_handler_add_array(handler, signal_decls)

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)

def signal_handler_signal(handler: 'signal_handler_t *', signal: 'char const *', params: 'calldata') -> "void":
    return _obspython.signal_handler_signal(handler, signal, params)
class base_allocator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    malloc = property(_obspython.base_allocator_malloc_get, _obspython.base_allocator_malloc_set)
    realloc = property(_obspython.base_allocator_realloc_get, _obspython.base_allocator_realloc_set)
    free = property(_obspython.base_allocator_free_get, _obspython.base_allocator_free_set)

    def __init__(self):
        _obspython.base_allocator_swiginit(self, _obspython.new_base_allocator())
    __swig_destroy__ = _obspython.delete_base_allocator

# Register base_allocator in _obspython:
_obspython.base_allocator_swigregister(base_allocator)


def base_set_allocator(defs: 'base_allocator') -> "void":
    return _obspython.base_set_allocator(defs)

def bmalloc(size: 'size_t') -> "void *":
    return _obspython.bmalloc(size)

def brealloc(ptr: 'void *', size: 'size_t') -> "void *":
    return _obspython.brealloc(ptr, size)

def bfree(ptr: 'void *') -> "void":
    return _obspython.bfree(ptr)

def base_get_alignment() -> "int":
    return _obspython.base_get_alignment()

def bnum_allocs() -> "long":
    return _obspython.bnum_allocs()

def bmemdup(ptr: 'void const *', size: 'size_t') -> "void *":
    return _obspython.bmemdup(ptr, size)

def bzalloc(size: 'size_t') -> "void *":
    return _obspython.bzalloc(size)

def bstrdup_n(str: 'char const *', n: 'size_t') -> "char *":
    return _obspython.bstrdup_n(str, n)

def bwstrdup_n(str: 'wchar_t const *', n: 'size_t') -> "wchar_t *":
    return _obspython.bwstrdup_n(str, n)

def bstrdup(str: 'char const *') -> "char *":
    return _obspython.bstrdup(str)

def bwstrdup(str: 'wchar_t const *') -> "wchar_t *":
    return _obspython.bwstrdup(str)
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)

def base_set_log_handler(handler: 'log_handler_t', param: 'void *') -> "void":
    return _obspython.base_set_log_handler(handler, param)

def base_set_crash_handler(handler: 'void (*)(char const *,va_list,void *)', param: 'void *') -> "void":
    return _obspython.base_set_crash_handler(handler, param)
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
OBS_FRONTEND_EVENT_RECORDING_PAUSED = _obspython.OBS_FRONTEND_EVENT_RECORDING_PAUSED
OBS_FRONTEND_EVENT_RECORDING_UNPAUSED = _obspython.OBS_FRONTEND_EVENT_RECORDING_UNPAUSED
OBS_FRONTEND_EVENT_TRANSITION_DURATION_CHANGED = _obspython.OBS_FRONTEND_EVENT_TRANSITION_DURATION_CHANGED

def obs_frontend_streaming_start() -> "void":
    return _obspython.obs_frontend_streaming_start()

def obs_frontend_streaming_stop() -> "void":
    return _obspython.obs_frontend_streaming_stop()

def obs_frontend_streaming_active() -> "bool":
    return _obspython.obs_frontend_streaming_active()

def obs_frontend_recording_start() -> "void":
    return _obspython.obs_frontend_recording_start()

def obs_frontend_recording_stop() -> "void":
    return _obspython.obs_frontend_recording_stop()

def obs_frontend_recording_active() -> "bool":
    return _obspython.obs_frontend_recording_active()

def obs_frontend_recording_pause(pause: 'bool') -> "void":
    return _obspython.obs_frontend_recording_pause(pause)

def obs_frontend_recording_paused() -> "bool":
    return _obspython.obs_frontend_recording_paused()

def obs_frontend_replay_buffer_start() -> "void":
    return _obspython.obs_frontend_replay_buffer_start()

def obs_frontend_replay_buffer_save() -> "void":
    return _obspython.obs_frontend_replay_buffer_save()

def obs_frontend_replay_buffer_stop() -> "void":
    return _obspython.obs_frontend_replay_buffer_stop()

def obs_frontend_replay_buffer_active() -> "bool":
    return _obspython.obs_frontend_replay_buffer_active()

def obs_frontend_open_projector(type: 'char const *', monitor: 'int', geometry: 'char const *', name: 'char const *') -> "void":
    return _obspython.obs_frontend_open_projector(type, monitor, geometry, name)

def obs_frontend_save() -> "void":
    return _obspython.obs_frontend_save()

def obs_frontend_defer_save_begin() -> "void":
    return _obspython.obs_frontend_defer_save_begin()

def obs_frontend_defer_save_end() -> "void":
    return _obspython.obs_frontend_defer_save_end()

def obs_frontend_get_streaming_output() -> "obs_output_t *":
    return _obspython.obs_frontend_get_streaming_output()

def obs_frontend_get_recording_output() -> "obs_output_t *":
    return _obspython.obs_frontend_get_recording_output()

def obs_frontend_get_replay_buffer_output() -> "obs_output_t *":
    return _obspython.obs_frontend_get_replay_buffer_output()

def obs_frontend_get_profile_config() -> "config_t *":
    return _obspython.obs_frontend_get_profile_config()

def obs_frontend_get_global_config() -> "config_t *":
    return _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)

def obs_frontend_get_streaming_service() -> "obs_service_t *":
    return _obspython.obs_frontend_get_streaming_service()

def obs_frontend_save_streaming_service() -> "void":
    return _obspython.obs_frontend_save_streaming_service()

def obs_frontend_preview_program_mode_active() -> "bool":
    return _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)

def obs_frontend_preview_program_trigger_transition() -> "void":
    return _obspython.obs_frontend_preview_program_trigger_transition()

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

def obs_frontend_preview_enabled() -> "bool":
    return _obspython.obs_frontend_preview_enabled()

def obs_frontend_get_current_preview_scene() -> "obs_source_t *":
    return _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)


