MT4ManagerAPI.py

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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_MT4ManagerAPI')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_MT4ManagerAPI')
    _MT4ManagerAPI = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_MT4ManagerAPI', [dirname(__file__)])
        except ImportError:
            import _MT4ManagerAPI
            return _MT4ManagerAPI
        try:
            _mod = imp.load_module('_MT4ManagerAPI', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _MT4ManagerAPI = swig_import_helper()
    del swig_import_helper
else:
    import _MT4ManagerAPI
del _swig_python_version_info

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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

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

class intArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, intArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, intArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _MT4ManagerAPI.new_intArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_intArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _MT4ManagerAPI.intArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _MT4ManagerAPI.intArray___setitem__(self, index, value)

    def cast(self):
        return _MT4ManagerAPI.intArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_MT4ManagerAPI.intArray_frompointer)
    else:
        frompointer = _MT4ManagerAPI.intArray_frompointer
intArray_swigregister = _MT4ManagerAPI.intArray_swigregister
intArray_swigregister(intArray)

def intArray_frompointer(t):
    return _MT4ManagerAPI.intArray_frompointer(t)
intArray_frompointer = _MT4ManagerAPI.intArray_frompointer

class UserRecordArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UserRecordArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UserRecordArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _MT4ManagerAPI.new_UserRecordArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_UserRecordArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _MT4ManagerAPI.UserRecordArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _MT4ManagerAPI.UserRecordArray___setitem__(self, index, value)

    def cast(self):
        return _MT4ManagerAPI.UserRecordArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_MT4ManagerAPI.UserRecordArray_frompointer)
    else:
        frompointer = _MT4ManagerAPI.UserRecordArray_frompointer
UserRecordArray_swigregister = _MT4ManagerAPI.UserRecordArray_swigregister
UserRecordArray_swigregister(UserRecordArray)

def UserRecordArray_frompointer(t):
    return _MT4ManagerAPI.UserRecordArray_frompointer(t)
UserRecordArray_frompointer = _MT4ManagerAPI.UserRecordArray_frompointer

class TradeRecordArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TradeRecordArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TradeRecordArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _MT4ManagerAPI.new_TradeRecordArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_TradeRecordArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _MT4ManagerAPI.TradeRecordArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _MT4ManagerAPI.TradeRecordArray___setitem__(self, index, value)

    def cast(self):
        return _MT4ManagerAPI.TradeRecordArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_MT4ManagerAPI.TradeRecordArray_frompointer)
    else:
        frompointer = _MT4ManagerAPI.TradeRecordArray_frompointer
TradeRecordArray_swigregister = _MT4ManagerAPI.TradeRecordArray_swigregister
TradeRecordArray_swigregister(TradeRecordArray)

def TradeRecordArray_frompointer(t):
    return _MT4ManagerAPI.TradeRecordArray_frompointer(t)
TradeRecordArray_frompointer = _MT4ManagerAPI.TradeRecordArray_frompointer

class OnlineRecordArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OnlineRecordArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OnlineRecordArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _MT4ManagerAPI.new_OnlineRecordArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_OnlineRecordArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _MT4ManagerAPI.OnlineRecordArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _MT4ManagerAPI.OnlineRecordArray___setitem__(self, index, value)

    def cast(self):
        return _MT4ManagerAPI.OnlineRecordArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_MT4ManagerAPI.OnlineRecordArray_frompointer)
    else:
        frompointer = _MT4ManagerAPI.OnlineRecordArray_frompointer
OnlineRecordArray_swigregister = _MT4ManagerAPI.OnlineRecordArray_swigregister
OnlineRecordArray_swigregister(OnlineRecordArray)

def OnlineRecordArray_frompointer(t):
    return _MT4ManagerAPI.OnlineRecordArray_frompointer(t)
OnlineRecordArray_frompointer = _MT4ManagerAPI.OnlineRecordArray_frompointer

class MarginLevelArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MarginLevelArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MarginLevelArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _MT4ManagerAPI.new_MarginLevelArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_MarginLevelArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _MT4ManagerAPI.MarginLevelArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _MT4ManagerAPI.MarginLevelArray___setitem__(self, index, value)

    def cast(self):
        return _MT4ManagerAPI.MarginLevelArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_MT4ManagerAPI.MarginLevelArray_frompointer)
    else:
        frompointer = _MT4ManagerAPI.MarginLevelArray_frompointer
MarginLevelArray_swigregister = _MT4ManagerAPI.MarginLevelArray_swigregister
MarginLevelArray_swigregister(MarginLevelArray)

def MarginLevelArray_frompointer(t):
    return _MT4ManagerAPI.MarginLevelArray_frompointer(t)
MarginLevelArray_frompointer = _MT4ManagerAPI.MarginLevelArray_frompointer

class ConGroupArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConGroupArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConGroupArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _MT4ManagerAPI.new_ConGroupArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConGroupArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _MT4ManagerAPI.ConGroupArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _MT4ManagerAPI.ConGroupArray___setitem__(self, index, value)

    def cast(self):
        return _MT4ManagerAPI.ConGroupArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_MT4ManagerAPI.ConGroupArray_frompointer)
    else:
        frompointer = _MT4ManagerAPI.ConGroupArray_frompointer
ConGroupArray_swigregister = _MT4ManagerAPI.ConGroupArray_swigregister
ConGroupArray_swigregister(ConGroupArray)

def ConGroupArray_frompointer(t):
    return _MT4ManagerAPI.ConGroupArray_frompointer(t)
ConGroupArray_frompointer = _MT4ManagerAPI.ConGroupArray_frompointer

class ConSymbolArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConSymbolArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConSymbolArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _MT4ManagerAPI.new_ConSymbolArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConSymbolArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _MT4ManagerAPI.ConSymbolArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _MT4ManagerAPI.ConSymbolArray___setitem__(self, index, value)

    def cast(self):
        return _MT4ManagerAPI.ConSymbolArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_MT4ManagerAPI.ConSymbolArray_frompointer)
    else:
        frompointer = _MT4ManagerAPI.ConSymbolArray_frompointer
ConSymbolArray_swigregister = _MT4ManagerAPI.ConSymbolArray_swigregister
ConSymbolArray_swigregister(ConSymbolArray)

def ConSymbolArray_frompointer(t):
    return _MT4ManagerAPI.ConSymbolArray_frompointer(t)
ConSymbolArray_frompointer = _MT4ManagerAPI.ConSymbolArray_frompointer

class SymbolSummaryArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SymbolSummaryArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SymbolSummaryArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _MT4ManagerAPI.new_SymbolSummaryArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_SymbolSummaryArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _MT4ManagerAPI.SymbolSummaryArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _MT4ManagerAPI.SymbolSummaryArray___setitem__(self, index, value)

    def cast(self):
        return _MT4ManagerAPI.SymbolSummaryArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_MT4ManagerAPI.SymbolSummaryArray_frompointer)
    else:
        frompointer = _MT4ManagerAPI.SymbolSummaryArray_frompointer
SymbolSummaryArray_swigregister = _MT4ManagerAPI.SymbolSummaryArray_swigregister
SymbolSummaryArray_swigregister(SymbolSummaryArray)

def SymbolSummaryArray_frompointer(t):
    return _MT4ManagerAPI.SymbolSummaryArray_frompointer(t)
SymbolSummaryArray_frompointer = _MT4ManagerAPI.SymbolSummaryArray_frompointer

class intp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, intp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, intp, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _MT4ManagerAPI.new_intp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_intp
    __del__ = lambda self: None

    def assign(self, value):
        return _MT4ManagerAPI.intp_assign(self, value)

    def value(self):
        return _MT4ManagerAPI.intp_value(self)

    def cast(self):
        return _MT4ManagerAPI.intp_cast(self)
    if _newclass:
        frompointer = staticmethod(_MT4ManagerAPI.intp_frompointer)
    else:
        frompointer = _MT4ManagerAPI.intp_frompointer
intp_swigregister = _MT4ManagerAPI.intp_swigregister
intp_swigregister(intp)

def intp_frompointer(t):
    return _MT4ManagerAPI.intp_frompointer(t)
intp_frompointer = _MT4ManagerAPI.intp_frompointer

class GUID(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GUID, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GUID, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Data1"] = _MT4ManagerAPI.GUID_Data1_set
    __swig_getmethods__["Data1"] = _MT4ManagerAPI.GUID_Data1_get
    if _newclass:
        Data1 = _swig_property(_MT4ManagerAPI.GUID_Data1_get, _MT4ManagerAPI.GUID_Data1_set)
    __swig_setmethods__["Data2"] = _MT4ManagerAPI.GUID_Data2_set
    __swig_getmethods__["Data2"] = _MT4ManagerAPI.GUID_Data2_get
    if _newclass:
        Data2 = _swig_property(_MT4ManagerAPI.GUID_Data2_get, _MT4ManagerAPI.GUID_Data2_set)
    __swig_setmethods__["Data3"] = _MT4ManagerAPI.GUID_Data3_set
    __swig_getmethods__["Data3"] = _MT4ManagerAPI.GUID_Data3_get
    if _newclass:
        Data3 = _swig_property(_MT4ManagerAPI.GUID_Data3_get, _MT4ManagerAPI.GUID_Data3_set)
    __swig_setmethods__["Data4"] = _MT4ManagerAPI.GUID_Data4_set
    __swig_getmethods__["Data4"] = _MT4ManagerAPI.GUID_Data4_get
    if _newclass:
        Data4 = _swig_property(_MT4ManagerAPI.GUID_Data4_get, _MT4ManagerAPI.GUID_Data4_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_GUID()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_GUID
    __del__ = lambda self: None
GUID_swigregister = _MT4ManagerAPI.GUID_swigregister
GUID_swigregister(GUID)


def InlineIsEqualGUID(rguid1, rguid2):
    return _MT4ManagerAPI.InlineIsEqualGUID(rguid1, rguid2)
InlineIsEqualGUID = _MT4ManagerAPI.InlineIsEqualGUID

def IsEqualGUID(rguid1, rguid2):
    return _MT4ManagerAPI.IsEqualGUID(rguid1, rguid2)
IsEqualGUID = _MT4ManagerAPI.IsEqualGUID
ManAPIProgramVersion = _MT4ManagerAPI.ManAPIProgramVersion
ManAPIProgramBuild = _MT4ManagerAPI.ManAPIProgramBuild
CONFIG_ALL = _MT4ManagerAPI.CONFIG_ALL
CONFIG_COMMON = _MT4ManagerAPI.CONFIG_COMMON
CONFIG_ACCESS = _MT4ManagerAPI.CONFIG_ACCESS
CONFIG_SERVERS = _MT4ManagerAPI.CONFIG_SERVERS
CONFIG_TIME = _MT4ManagerAPI.CONFIG_TIME
CONFIG_HOLIDAYS = _MT4ManagerAPI.CONFIG_HOLIDAYS
CONFIG_SYMBOLS = _MT4ManagerAPI.CONFIG_SYMBOLS
CONFIG_SYMB_GROUPS = _MT4ManagerAPI.CONFIG_SYMB_GROUPS
CONFIG_GROUPS = _MT4ManagerAPI.CONFIG_GROUPS
CONFIG_MANAGERS = _MT4ManagerAPI.CONFIG_MANAGERS
CONFIG_DATAFEEDS = _MT4ManagerAPI.CONFIG_DATAFEEDS
CONFIG_BACKUP = _MT4ManagerAPI.CONFIG_BACKUP
CONFIG_LIVEUPDATE = _MT4ManagerAPI.CONFIG_LIVEUPDATE
CONFIG_SYNC = _MT4ManagerAPI.CONFIG_SYNC
CONFIG_PLUGINS = _MT4ManagerAPI.CONFIG_PLUGINS
CONFIG_END = _MT4ManagerAPI.CONFIG_END
class ConCommon(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConCommon, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConCommon, name)
    __repr__ = _swig_repr
    __swig_setmethods__["owner"] = _MT4ManagerAPI.ConCommon_owner_set
    __swig_getmethods__["owner"] = _MT4ManagerAPI.ConCommon_owner_get
    if _newclass:
        owner = _swig_property(_MT4ManagerAPI.ConCommon_owner_get, _MT4ManagerAPI.ConCommon_owner_set)
    __swig_setmethods__["name"] = _MT4ManagerAPI.ConCommon_name_set
    __swig_getmethods__["name"] = _MT4ManagerAPI.ConCommon_name_get
    if _newclass:
        name = _swig_property(_MT4ManagerAPI.ConCommon_name_get, _MT4ManagerAPI.ConCommon_name_set)
    __swig_setmethods__["address"] = _MT4ManagerAPI.ConCommon_address_set
    __swig_getmethods__["address"] = _MT4ManagerAPI.ConCommon_address_get
    if _newclass:
        address = _swig_property(_MT4ManagerAPI.ConCommon_address_get, _MT4ManagerAPI.ConCommon_address_set)
    __swig_setmethods__["port"] = _MT4ManagerAPI.ConCommon_port_set
    __swig_getmethods__["port"] = _MT4ManagerAPI.ConCommon_port_get
    if _newclass:
        port = _swig_property(_MT4ManagerAPI.ConCommon_port_get, _MT4ManagerAPI.ConCommon_port_set)
    __swig_setmethods__["timeout"] = _MT4ManagerAPI.ConCommon_timeout_set
    __swig_getmethods__["timeout"] = _MT4ManagerAPI.ConCommon_timeout_get
    if _newclass:
        timeout = _swig_property(_MT4ManagerAPI.ConCommon_timeout_get, _MT4ManagerAPI.ConCommon_timeout_set)
    __swig_setmethods__["typeofdemo"] = _MT4ManagerAPI.ConCommon_typeofdemo_set
    __swig_getmethods__["typeofdemo"] = _MT4ManagerAPI.ConCommon_typeofdemo_get
    if _newclass:
        typeofdemo = _swig_property(_MT4ManagerAPI.ConCommon_typeofdemo_get, _MT4ManagerAPI.ConCommon_typeofdemo_set)
    __swig_setmethods__["timeofdemo"] = _MT4ManagerAPI.ConCommon_timeofdemo_set
    __swig_getmethods__["timeofdemo"] = _MT4ManagerAPI.ConCommon_timeofdemo_get
    if _newclass:
        timeofdemo = _swig_property(_MT4ManagerAPI.ConCommon_timeofdemo_get, _MT4ManagerAPI.ConCommon_timeofdemo_set)
    __swig_setmethods__["daylightcorrection"] = _MT4ManagerAPI.ConCommon_daylightcorrection_set
    __swig_getmethods__["daylightcorrection"] = _MT4ManagerAPI.ConCommon_daylightcorrection_get
    if _newclass:
        daylightcorrection = _swig_property(_MT4ManagerAPI.ConCommon_daylightcorrection_get, _MT4ManagerAPI.ConCommon_daylightcorrection_set)
    __swig_setmethods__["internal"] = _MT4ManagerAPI.ConCommon_internal_set
    __swig_getmethods__["internal"] = _MT4ManagerAPI.ConCommon_internal_get
    if _newclass:
        internal = _swig_property(_MT4ManagerAPI.ConCommon_internal_get, _MT4ManagerAPI.ConCommon_internal_set)
    __swig_setmethods__["timezone"] = _MT4ManagerAPI.ConCommon_timezone_set
    __swig_getmethods__["timezone"] = _MT4ManagerAPI.ConCommon_timezone_get
    if _newclass:
        timezone = _swig_property(_MT4ManagerAPI.ConCommon_timezone_get, _MT4ManagerAPI.ConCommon_timezone_set)
    __swig_setmethods__["timesync"] = _MT4ManagerAPI.ConCommon_timesync_set
    __swig_getmethods__["timesync"] = _MT4ManagerAPI.ConCommon_timesync_get
    if _newclass:
        timesync = _swig_property(_MT4ManagerAPI.ConCommon_timesync_get, _MT4ManagerAPI.ConCommon_timesync_set)
    __swig_setmethods__["minclient"] = _MT4ManagerAPI.ConCommon_minclient_set
    __swig_getmethods__["minclient"] = _MT4ManagerAPI.ConCommon_minclient_get
    if _newclass:
        minclient = _swig_property(_MT4ManagerAPI.ConCommon_minclient_get, _MT4ManagerAPI.ConCommon_minclient_set)
    __swig_setmethods__["minapi"] = _MT4ManagerAPI.ConCommon_minapi_set
    __swig_getmethods__["minapi"] = _MT4ManagerAPI.ConCommon_minapi_get
    if _newclass:
        minapi = _swig_property(_MT4ManagerAPI.ConCommon_minapi_get, _MT4ManagerAPI.ConCommon_minapi_set)
    __swig_setmethods__["feeder_timeout"] = _MT4ManagerAPI.ConCommon_feeder_timeout_set
    __swig_getmethods__["feeder_timeout"] = _MT4ManagerAPI.ConCommon_feeder_timeout_get
    if _newclass:
        feeder_timeout = _swig_property(_MT4ManagerAPI.ConCommon_feeder_timeout_get, _MT4ManagerAPI.ConCommon_feeder_timeout_set)
    __swig_setmethods__["keepemails"] = _MT4ManagerAPI.ConCommon_keepemails_set
    __swig_getmethods__["keepemails"] = _MT4ManagerAPI.ConCommon_keepemails_get
    if _newclass:
        keepemails = _swig_property(_MT4ManagerAPI.ConCommon_keepemails_get, _MT4ManagerAPI.ConCommon_keepemails_set)
    __swig_setmethods__["endhour"] = _MT4ManagerAPI.ConCommon_endhour_set
    __swig_getmethods__["endhour"] = _MT4ManagerAPI.ConCommon_endhour_get
    if _newclass:
        endhour = _swig_property(_MT4ManagerAPI.ConCommon_endhour_get, _MT4ManagerAPI.ConCommon_endhour_set)
    __swig_setmethods__["endminute"] = _MT4ManagerAPI.ConCommon_endminute_set
    __swig_getmethods__["endminute"] = _MT4ManagerAPI.ConCommon_endminute_get
    if _newclass:
        endminute = _swig_property(_MT4ManagerAPI.ConCommon_endminute_get, _MT4ManagerAPI.ConCommon_endminute_set)
    __swig_setmethods__["optimization_time"] = _MT4ManagerAPI.ConCommon_optimization_time_set
    __swig_getmethods__["optimization_time"] = _MT4ManagerAPI.ConCommon_optimization_time_get
    if _newclass:
        optimization_time = _swig_property(_MT4ManagerAPI.ConCommon_optimization_time_get, _MT4ManagerAPI.ConCommon_optimization_time_set)
    __swig_setmethods__["optimization_lasttime"] = _MT4ManagerAPI.ConCommon_optimization_lasttime_set
    __swig_getmethods__["optimization_lasttime"] = _MT4ManagerAPI.ConCommon_optimization_lasttime_get
    if _newclass:
        optimization_lasttime = _swig_property(_MT4ManagerAPI.ConCommon_optimization_lasttime_get, _MT4ManagerAPI.ConCommon_optimization_lasttime_set)
    __swig_setmethods__["optimization_counter"] = _MT4ManagerAPI.ConCommon_optimization_counter_set
    __swig_getmethods__["optimization_counter"] = _MT4ManagerAPI.ConCommon_optimization_counter_get
    if _newclass:
        optimization_counter = _swig_property(_MT4ManagerAPI.ConCommon_optimization_counter_get, _MT4ManagerAPI.ConCommon_optimization_counter_set)
    __swig_setmethods__["optimization_unused"] = _MT4ManagerAPI.ConCommon_optimization_unused_set
    __swig_getmethods__["optimization_unused"] = _MT4ManagerAPI.ConCommon_optimization_unused_get
    if _newclass:
        optimization_unused = _swig_property(_MT4ManagerAPI.ConCommon_optimization_unused_get, _MT4ManagerAPI.ConCommon_optimization_unused_set)
    __swig_setmethods__["antiflood"] = _MT4ManagerAPI.ConCommon_antiflood_set
    __swig_getmethods__["antiflood"] = _MT4ManagerAPI.ConCommon_antiflood_get
    if _newclass:
        antiflood = _swig_property(_MT4ManagerAPI.ConCommon_antiflood_get, _MT4ManagerAPI.ConCommon_antiflood_set)
    __swig_setmethods__["floodcontrol"] = _MT4ManagerAPI.ConCommon_floodcontrol_set
    __swig_getmethods__["floodcontrol"] = _MT4ManagerAPI.ConCommon_floodcontrol_get
    if _newclass:
        floodcontrol = _swig_property(_MT4ManagerAPI.ConCommon_floodcontrol_get, _MT4ManagerAPI.ConCommon_floodcontrol_set)
    __swig_setmethods__["liveupdate_mode"] = _MT4ManagerAPI.ConCommon_liveupdate_mode_set
    __swig_getmethods__["liveupdate_mode"] = _MT4ManagerAPI.ConCommon_liveupdate_mode_get
    if _newclass:
        liveupdate_mode = _swig_property(_MT4ManagerAPI.ConCommon_liveupdate_mode_get, _MT4ManagerAPI.ConCommon_liveupdate_mode_set)
    __swig_setmethods__["lastorder"] = _MT4ManagerAPI.ConCommon_lastorder_set
    __swig_getmethods__["lastorder"] = _MT4ManagerAPI.ConCommon_lastorder_get
    if _newclass:
        lastorder = _swig_property(_MT4ManagerAPI.ConCommon_lastorder_get, _MT4ManagerAPI.ConCommon_lastorder_set)
    __swig_setmethods__["lastlogin"] = _MT4ManagerAPI.ConCommon_lastlogin_set
    __swig_getmethods__["lastlogin"] = _MT4ManagerAPI.ConCommon_lastlogin_get
    if _newclass:
        lastlogin = _swig_property(_MT4ManagerAPI.ConCommon_lastlogin_get, _MT4ManagerAPI.ConCommon_lastlogin_set)
    __swig_setmethods__["lostlogin"] = _MT4ManagerAPI.ConCommon_lostlogin_set
    __swig_getmethods__["lostlogin"] = _MT4ManagerAPI.ConCommon_lostlogin_get
    if _newclass:
        lostlogin = _swig_property(_MT4ManagerAPI.ConCommon_lostlogin_get, _MT4ManagerAPI.ConCommon_lostlogin_set)
    __swig_setmethods__["rollovers_mode"] = _MT4ManagerAPI.ConCommon_rollovers_mode_set
    __swig_getmethods__["rollovers_mode"] = _MT4ManagerAPI.ConCommon_rollovers_mode_get
    if _newclass:
        rollovers_mode = _swig_property(_MT4ManagerAPI.ConCommon_rollovers_mode_get, _MT4ManagerAPI.ConCommon_rollovers_mode_set)
    __swig_setmethods__["path_database"] = _MT4ManagerAPI.ConCommon_path_database_set
    __swig_getmethods__["path_database"] = _MT4ManagerAPI.ConCommon_path_database_get
    if _newclass:
        path_database = _swig_property(_MT4ManagerAPI.ConCommon_path_database_get, _MT4ManagerAPI.ConCommon_path_database_set)
    __swig_setmethods__["path_history"] = _MT4ManagerAPI.ConCommon_path_history_set
    __swig_getmethods__["path_history"] = _MT4ManagerAPI.ConCommon_path_history_get
    if _newclass:
        path_history = _swig_property(_MT4ManagerAPI.ConCommon_path_history_get, _MT4ManagerAPI.ConCommon_path_history_set)
    __swig_setmethods__["path_log"] = _MT4ManagerAPI.ConCommon_path_log_set
    __swig_getmethods__["path_log"] = _MT4ManagerAPI.ConCommon_path_log_get
    if _newclass:
        path_log = _swig_property(_MT4ManagerAPI.ConCommon_path_log_get, _MT4ManagerAPI.ConCommon_path_log_set)
    __swig_setmethods__["overnight_last_day"] = _MT4ManagerAPI.ConCommon_overnight_last_day_set
    __swig_getmethods__["overnight_last_day"] = _MT4ManagerAPI.ConCommon_overnight_last_day_get
    if _newclass:
        overnight_last_day = _swig_property(_MT4ManagerAPI.ConCommon_overnight_last_day_get, _MT4ManagerAPI.ConCommon_overnight_last_day_set)
    __swig_setmethods__["overnight_last_time"] = _MT4ManagerAPI.ConCommon_overnight_last_time_set
    __swig_getmethods__["overnight_last_time"] = _MT4ManagerAPI.ConCommon_overnight_last_time_get
    if _newclass:
        overnight_last_time = _swig_property(_MT4ManagerAPI.ConCommon_overnight_last_time_get, _MT4ManagerAPI.ConCommon_overnight_last_time_set)
    __swig_setmethods__["overnight_prev_time"] = _MT4ManagerAPI.ConCommon_overnight_prev_time_set
    __swig_getmethods__["overnight_prev_time"] = _MT4ManagerAPI.ConCommon_overnight_prev_time_get
    if _newclass:
        overnight_prev_time = _swig_property(_MT4ManagerAPI.ConCommon_overnight_prev_time_get, _MT4ManagerAPI.ConCommon_overnight_prev_time_set)
    __swig_setmethods__["overmonth_last_month"] = _MT4ManagerAPI.ConCommon_overmonth_last_month_set
    __swig_getmethods__["overmonth_last_month"] = _MT4ManagerAPI.ConCommon_overmonth_last_month_get
    if _newclass:
        overmonth_last_month = _swig_property(_MT4ManagerAPI.ConCommon_overmonth_last_month_get, _MT4ManagerAPI.ConCommon_overmonth_last_month_set)
    __swig_setmethods__["adapters"] = _MT4ManagerAPI.ConCommon_adapters_set
    __swig_getmethods__["adapters"] = _MT4ManagerAPI.ConCommon_adapters_get
    if _newclass:
        adapters = _swig_property(_MT4ManagerAPI.ConCommon_adapters_get, _MT4ManagerAPI.ConCommon_adapters_set)
    __swig_setmethods__["bind_adresses"] = _MT4ManagerAPI.ConCommon_bind_adresses_set
    __swig_getmethods__["bind_adresses"] = _MT4ManagerAPI.ConCommon_bind_adresses_get
    if _newclass:
        bind_adresses = _swig_property(_MT4ManagerAPI.ConCommon_bind_adresses_get, _MT4ManagerAPI.ConCommon_bind_adresses_set)
    __swig_setmethods__["server_version"] = _MT4ManagerAPI.ConCommon_server_version_set
    __swig_getmethods__["server_version"] = _MT4ManagerAPI.ConCommon_server_version_get
    if _newclass:
        server_version = _swig_property(_MT4ManagerAPI.ConCommon_server_version_get, _MT4ManagerAPI.ConCommon_server_version_set)
    __swig_setmethods__["server_build"] = _MT4ManagerAPI.ConCommon_server_build_set
    __swig_getmethods__["server_build"] = _MT4ManagerAPI.ConCommon_server_build_get
    if _newclass:
        server_build = _swig_property(_MT4ManagerAPI.ConCommon_server_build_get, _MT4ManagerAPI.ConCommon_server_build_set)
    __swig_setmethods__["web_adresses"] = _MT4ManagerAPI.ConCommon_web_adresses_set
    __swig_getmethods__["web_adresses"] = _MT4ManagerAPI.ConCommon_web_adresses_get
    if _newclass:
        web_adresses = _swig_property(_MT4ManagerAPI.ConCommon_web_adresses_get, _MT4ManagerAPI.ConCommon_web_adresses_set)
    __swig_setmethods__["statement_mode"] = _MT4ManagerAPI.ConCommon_statement_mode_set
    __swig_getmethods__["statement_mode"] = _MT4ManagerAPI.ConCommon_statement_mode_get
    if _newclass:
        statement_mode = _swig_property(_MT4ManagerAPI.ConCommon_statement_mode_get, _MT4ManagerAPI.ConCommon_statement_mode_set)
    __swig_setmethods__["monthly_state_mode"] = _MT4ManagerAPI.ConCommon_monthly_state_mode_set
    __swig_getmethods__["monthly_state_mode"] = _MT4ManagerAPI.ConCommon_monthly_state_mode_get
    if _newclass:
        monthly_state_mode = _swig_property(_MT4ManagerAPI.ConCommon_monthly_state_mode_get, _MT4ManagerAPI.ConCommon_monthly_state_mode_set)
    __swig_setmethods__["keepticks"] = _MT4ManagerAPI.ConCommon_keepticks_set
    __swig_getmethods__["keepticks"] = _MT4ManagerAPI.ConCommon_keepticks_get
    if _newclass:
        keepticks = _swig_property(_MT4ManagerAPI.ConCommon_keepticks_get, _MT4ManagerAPI.ConCommon_keepticks_set)
    __swig_setmethods__["statement_weekend"] = _MT4ManagerAPI.ConCommon_statement_weekend_set
    __swig_getmethods__["statement_weekend"] = _MT4ManagerAPI.ConCommon_statement_weekend_get
    if _newclass:
        statement_weekend = _swig_property(_MT4ManagerAPI.ConCommon_statement_weekend_get, _MT4ManagerAPI.ConCommon_statement_weekend_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConCommon_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConCommon_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConCommon_reserved_get, _MT4ManagerAPI.ConCommon_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConCommon()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConCommon
    __del__ = lambda self: None
ConCommon_swigregister = _MT4ManagerAPI.ConCommon_swigregister
ConCommon_swigregister(ConCommon)

DEMO_DISABLED = _MT4ManagerAPI.DEMO_DISABLED
DEMO_PROLONG = _MT4ManagerAPI.DEMO_PROLONG
DEMO_FIXED = _MT4ManagerAPI.DEMO_FIXED
ROLLOVER_NORMAL = _MT4ManagerAPI.ROLLOVER_NORMAL
ROLLOVER_REOPEN_BY_CLOSE_PRICE = _MT4ManagerAPI.ROLLOVER_REOPEN_BY_CLOSE_PRICE
ROLLOVER_REOPEN_BY_BID = _MT4ManagerAPI.ROLLOVER_REOPEN_BY_BID
LIVE_UPDATE_NO = _MT4ManagerAPI.LIVE_UPDATE_NO
LIVE_UPDATE_ALL = _MT4ManagerAPI.LIVE_UPDATE_ALL
LIVE_UPDATE_NO_SERVER = _MT4ManagerAPI.LIVE_UPDATE_NO_SERVER
STATEMENT_END_DAY = _MT4ManagerAPI.STATEMENT_END_DAY
STATEMENT_START_DAY = _MT4ManagerAPI.STATEMENT_START_DAY
MONTHLY_STATEMENT_END_MONTH = _MT4ManagerAPI.MONTHLY_STATEMENT_END_MONTH
MONTHLY_STATEMENT_START_MONTH = _MT4ManagerAPI.MONTHLY_STATEMENT_START_MONTH
class ConAccess(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConAccess, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConAccess, name)
    __repr__ = _swig_repr
    __swig_setmethods__["action"] = _MT4ManagerAPI.ConAccess_action_set
    __swig_getmethods__["action"] = _MT4ManagerAPI.ConAccess_action_get
    if _newclass:
        action = _swig_property(_MT4ManagerAPI.ConAccess_action_get, _MT4ManagerAPI.ConAccess_action_set)
    __swig_setmethods__["_from"] = _MT4ManagerAPI.ConAccess__from_set
    __swig_getmethods__["_from"] = _MT4ManagerAPI.ConAccess__from_get
    if _newclass:
        _from = _swig_property(_MT4ManagerAPI.ConAccess__from_get, _MT4ManagerAPI.ConAccess__from_set)
    __swig_setmethods__["to"] = _MT4ManagerAPI.ConAccess_to_set
    __swig_getmethods__["to"] = _MT4ManagerAPI.ConAccess_to_get
    if _newclass:
        to = _swig_property(_MT4ManagerAPI.ConAccess_to_get, _MT4ManagerAPI.ConAccess_to_set)
    __swig_setmethods__["comment"] = _MT4ManagerAPI.ConAccess_comment_set
    __swig_getmethods__["comment"] = _MT4ManagerAPI.ConAccess_comment_get
    if _newclass:
        comment = _swig_property(_MT4ManagerAPI.ConAccess_comment_get, _MT4ManagerAPI.ConAccess_comment_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConAccess_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConAccess_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConAccess_reserved_get, _MT4ManagerAPI.ConAccess_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConAccess()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConAccess
    __del__ = lambda self: None
ConAccess_swigregister = _MT4ManagerAPI.ConAccess_swigregister
ConAccess_swigregister(ConAccess)

FW_BLOCK = _MT4ManagerAPI.FW_BLOCK
FW_PERMIT = _MT4ManagerAPI.FW_PERMIT
class ConDataServer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConDataServer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConDataServer, name)
    __repr__ = _swig_repr
    __swig_setmethods__["server"] = _MT4ManagerAPI.ConDataServer_server_set
    __swig_getmethods__["server"] = _MT4ManagerAPI.ConDataServer_server_get
    if _newclass:
        server = _swig_property(_MT4ManagerAPI.ConDataServer_server_get, _MT4ManagerAPI.ConDataServer_server_set)
    __swig_setmethods__["ip"] = _MT4ManagerAPI.ConDataServer_ip_set
    __swig_getmethods__["ip"] = _MT4ManagerAPI.ConDataServer_ip_get
    if _newclass:
        ip = _swig_property(_MT4ManagerAPI.ConDataServer_ip_get, _MT4ManagerAPI.ConDataServer_ip_set)
    __swig_setmethods__["description"] = _MT4ManagerAPI.ConDataServer_description_set
    __swig_getmethods__["description"] = _MT4ManagerAPI.ConDataServer_description_get
    if _newclass:
        description = _swig_property(_MT4ManagerAPI.ConDataServer_description_get, _MT4ManagerAPI.ConDataServer_description_set)
    __swig_setmethods__["isproxy"] = _MT4ManagerAPI.ConDataServer_isproxy_set
    __swig_getmethods__["isproxy"] = _MT4ManagerAPI.ConDataServer_isproxy_get
    if _newclass:
        isproxy = _swig_property(_MT4ManagerAPI.ConDataServer_isproxy_get, _MT4ManagerAPI.ConDataServer_isproxy_set)
    __swig_setmethods__["priority"] = _MT4ManagerAPI.ConDataServer_priority_set
    __swig_getmethods__["priority"] = _MT4ManagerAPI.ConDataServer_priority_get
    if _newclass:
        priority = _swig_property(_MT4ManagerAPI.ConDataServer_priority_get, _MT4ManagerAPI.ConDataServer_priority_set)
    __swig_setmethods__["loading"] = _MT4ManagerAPI.ConDataServer_loading_set
    __swig_getmethods__["loading"] = _MT4ManagerAPI.ConDataServer_loading_get
    if _newclass:
        loading = _swig_property(_MT4ManagerAPI.ConDataServer_loading_get, _MT4ManagerAPI.ConDataServer_loading_set)
    __swig_setmethods__["ip_internal"] = _MT4ManagerAPI.ConDataServer_ip_internal_set
    __swig_getmethods__["ip_internal"] = _MT4ManagerAPI.ConDataServer_ip_internal_get
    if _newclass:
        ip_internal = _swig_property(_MT4ManagerAPI.ConDataServer_ip_internal_get, _MT4ManagerAPI.ConDataServer_ip_internal_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConDataServer_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConDataServer_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConDataServer_reserved_get, _MT4ManagerAPI.ConDataServer_reserved_set)
    __swig_setmethods__["next"] = _MT4ManagerAPI.ConDataServer_next_set
    __swig_getmethods__["next"] = _MT4ManagerAPI.ConDataServer_next_get
    if _newclass:
        next = _swig_property(_MT4ManagerAPI.ConDataServer_next_get, _MT4ManagerAPI.ConDataServer_next_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConDataServer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConDataServer
    __del__ = lambda self: None
ConDataServer_swigregister = _MT4ManagerAPI.ConDataServer_swigregister
ConDataServer_swigregister(ConDataServer)

class ConTime(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConTime, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConTime, name)
    __repr__ = _swig_repr
    __swig_setmethods__["days"] = _MT4ManagerAPI.ConTime_days_set
    __swig_getmethods__["days"] = _MT4ManagerAPI.ConTime_days_get
    if _newclass:
        days = _swig_property(_MT4ManagerAPI.ConTime_days_get, _MT4ManagerAPI.ConTime_days_set)
    __swig_setmethods__["dayscontrol"] = _MT4ManagerAPI.ConTime_dayscontrol_set
    __swig_getmethods__["dayscontrol"] = _MT4ManagerAPI.ConTime_dayscontrol_get
    if _newclass:
        dayscontrol = _swig_property(_MT4ManagerAPI.ConTime_dayscontrol_get, _MT4ManagerAPI.ConTime_dayscontrol_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConTime_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConTime_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConTime_reserved_get, _MT4ManagerAPI.ConTime_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConTime()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConTime
    __del__ = lambda self: None
ConTime_swigregister = _MT4ManagerAPI.ConTime_swigregister
ConTime_swigregister(ConTime)

class ConBackup(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConBackup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConBackup, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fullbackup_path"] = _MT4ManagerAPI.ConBackup_fullbackup_path_set
    __swig_getmethods__["fullbackup_path"] = _MT4ManagerAPI.ConBackup_fullbackup_path_get
    if _newclass:
        fullbackup_path = _swig_property(_MT4ManagerAPI.ConBackup_fullbackup_path_get, _MT4ManagerAPI.ConBackup_fullbackup_path_set)
    __swig_setmethods__["fullbackup_period"] = _MT4ManagerAPI.ConBackup_fullbackup_period_set
    __swig_getmethods__["fullbackup_period"] = _MT4ManagerAPI.ConBackup_fullbackup_period_get
    if _newclass:
        fullbackup_period = _swig_property(_MT4ManagerAPI.ConBackup_fullbackup_period_get, _MT4ManagerAPI.ConBackup_fullbackup_period_set)
    __swig_setmethods__["fullbackup_store"] = _MT4ManagerAPI.ConBackup_fullbackup_store_set
    __swig_getmethods__["fullbackup_store"] = _MT4ManagerAPI.ConBackup_fullbackup_store_get
    if _newclass:
        fullbackup_store = _swig_property(_MT4ManagerAPI.ConBackup_fullbackup_store_get, _MT4ManagerAPI.ConBackup_fullbackup_store_set)
    __swig_setmethods__["fullbackup_lasttime"] = _MT4ManagerAPI.ConBackup_fullbackup_lasttime_set
    __swig_getmethods__["fullbackup_lasttime"] = _MT4ManagerAPI.ConBackup_fullbackup_lasttime_get
    if _newclass:
        fullbackup_lasttime = _swig_property(_MT4ManagerAPI.ConBackup_fullbackup_lasttime_get, _MT4ManagerAPI.ConBackup_fullbackup_lasttime_set)
    __swig_setmethods__["fullbackup_shift"] = _MT4ManagerAPI.ConBackup_fullbackup_shift_set
    __swig_getmethods__["fullbackup_shift"] = _MT4ManagerAPI.ConBackup_fullbackup_shift_get
    if _newclass:
        fullbackup_shift = _swig_property(_MT4ManagerAPI.ConBackup_fullbackup_shift_get, _MT4ManagerAPI.ConBackup_fullbackup_shift_set)
    __swig_setmethods__["external_path"] = _MT4ManagerAPI.ConBackup_external_path_set
    __swig_getmethods__["external_path"] = _MT4ManagerAPI.ConBackup_external_path_get
    if _newclass:
        external_path = _swig_property(_MT4ManagerAPI.ConBackup_external_path_get, _MT4ManagerAPI.ConBackup_external_path_set)
    __swig_setmethods__["archive_period"] = _MT4ManagerAPI.ConBackup_archive_period_set
    __swig_getmethods__["archive_period"] = _MT4ManagerAPI.ConBackup_archive_period_get
    if _newclass:
        archive_period = _swig_property(_MT4ManagerAPI.ConBackup_archive_period_get, _MT4ManagerAPI.ConBackup_archive_period_set)
    __swig_setmethods__["archive_store"] = _MT4ManagerAPI.ConBackup_archive_store_set
    __swig_getmethods__["archive_store"] = _MT4ManagerAPI.ConBackup_archive_store_get
    if _newclass:
        archive_store = _swig_property(_MT4ManagerAPI.ConBackup_archive_store_get, _MT4ManagerAPI.ConBackup_archive_store_set)
    __swig_setmethods__["archive_lasttime"] = _MT4ManagerAPI.ConBackup_archive_lasttime_set
    __swig_getmethods__["archive_lasttime"] = _MT4ManagerAPI.ConBackup_archive_lasttime_get
    if _newclass:
        archive_lasttime = _swig_property(_MT4ManagerAPI.ConBackup_archive_lasttime_get, _MT4ManagerAPI.ConBackup_archive_lasttime_set)
    __swig_setmethods__["export_securities"] = _MT4ManagerAPI.ConBackup_export_securities_set
    __swig_getmethods__["export_securities"] = _MT4ManagerAPI.ConBackup_export_securities_get
    if _newclass:
        export_securities = _swig_property(_MT4ManagerAPI.ConBackup_export_securities_get, _MT4ManagerAPI.ConBackup_export_securities_set)
    __swig_setmethods__["export_path"] = _MT4ManagerAPI.ConBackup_export_path_set
    __swig_getmethods__["export_path"] = _MT4ManagerAPI.ConBackup_export_path_get
    if _newclass:
        export_path = _swig_property(_MT4ManagerAPI.ConBackup_export_path_get, _MT4ManagerAPI.ConBackup_export_path_set)
    __swig_setmethods__["export_period"] = _MT4ManagerAPI.ConBackup_export_period_set
    __swig_getmethods__["export_period"] = _MT4ManagerAPI.ConBackup_export_period_get
    if _newclass:
        export_period = _swig_property(_MT4ManagerAPI.ConBackup_export_period_get, _MT4ManagerAPI.ConBackup_export_period_set)
    __swig_setmethods__["export_lasttime"] = _MT4ManagerAPI.ConBackup_export_lasttime_set
    __swig_getmethods__["export_lasttime"] = _MT4ManagerAPI.ConBackup_export_lasttime_get
    if _newclass:
        export_lasttime = _swig_property(_MT4ManagerAPI.ConBackup_export_lasttime_get, _MT4ManagerAPI.ConBackup_export_lasttime_set)
    __swig_setmethods__["watch_role"] = _MT4ManagerAPI.ConBackup_watch_role_set
    __swig_getmethods__["watch_role"] = _MT4ManagerAPI.ConBackup_watch_role_get
    if _newclass:
        watch_role = _swig_property(_MT4ManagerAPI.ConBackup_watch_role_get, _MT4ManagerAPI.ConBackup_watch_role_set)
    __swig_setmethods__["watch_password"] = _MT4ManagerAPI.ConBackup_watch_password_set
    __swig_getmethods__["watch_password"] = _MT4ManagerAPI.ConBackup_watch_password_get
    if _newclass:
        watch_password = _swig_property(_MT4ManagerAPI.ConBackup_watch_password_get, _MT4ManagerAPI.ConBackup_watch_password_set)
    __swig_setmethods__["watch_opposite"] = _MT4ManagerAPI.ConBackup_watch_opposite_set
    __swig_getmethods__["watch_opposite"] = _MT4ManagerAPI.ConBackup_watch_opposite_get
    if _newclass:
        watch_opposite = _swig_property(_MT4ManagerAPI.ConBackup_watch_opposite_get, _MT4ManagerAPI.ConBackup_watch_opposite_set)
    __swig_setmethods__["watch_ip"] = _MT4ManagerAPI.ConBackup_watch_ip_set
    __swig_getmethods__["watch_ip"] = _MT4ManagerAPI.ConBackup_watch_ip_get
    if _newclass:
        watch_ip = _swig_property(_MT4ManagerAPI.ConBackup_watch_ip_get, _MT4ManagerAPI.ConBackup_watch_ip_set)
    __swig_setmethods__["archive_shift"] = _MT4ManagerAPI.ConBackup_archive_shift_set
    __swig_getmethods__["archive_shift"] = _MT4ManagerAPI.ConBackup_archive_shift_get
    if _newclass:
        archive_shift = _swig_property(_MT4ManagerAPI.ConBackup_archive_shift_get, _MT4ManagerAPI.ConBackup_archive_shift_set)
    __swig_setmethods__["watch_state"] = _MT4ManagerAPI.ConBackup_watch_state_set
    __swig_getmethods__["watch_state"] = _MT4ManagerAPI.ConBackup_watch_state_get
    if _newclass:
        watch_state = _swig_property(_MT4ManagerAPI.ConBackup_watch_state_get, _MT4ManagerAPI.ConBackup_watch_state_set)
    __swig_setmethods__["watch_failover"] = _MT4ManagerAPI.ConBackup_watch_failover_set
    __swig_getmethods__["watch_failover"] = _MT4ManagerAPI.ConBackup_watch_failover_get
    if _newclass:
        watch_failover = _swig_property(_MT4ManagerAPI.ConBackup_watch_failover_get, _MT4ManagerAPI.ConBackup_watch_failover_set)
    __swig_setmethods__["watch_timeout"] = _MT4ManagerAPI.ConBackup_watch_timeout_set
    __swig_getmethods__["watch_timeout"] = _MT4ManagerAPI.ConBackup_watch_timeout_get
    if _newclass:
        watch_timeout = _swig_property(_MT4ManagerAPI.ConBackup_watch_timeout_get, _MT4ManagerAPI.ConBackup_watch_timeout_set)
    __swig_setmethods__["watch_login"] = _MT4ManagerAPI.ConBackup_watch_login_set
    __swig_getmethods__["watch_login"] = _MT4ManagerAPI.ConBackup_watch_login_get
    if _newclass:
        watch_login = _swig_property(_MT4ManagerAPI.ConBackup_watch_login_get, _MT4ManagerAPI.ConBackup_watch_login_set)
    __swig_setmethods__["watch_timestamp"] = _MT4ManagerAPI.ConBackup_watch_timestamp_set
    __swig_getmethods__["watch_timestamp"] = _MT4ManagerAPI.ConBackup_watch_timestamp_get
    if _newclass:
        watch_timestamp = _swig_property(_MT4ManagerAPI.ConBackup_watch_timestamp_get, _MT4ManagerAPI.ConBackup_watch_timestamp_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConBackup()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConBackup
    __del__ = lambda self: None
ConBackup_swigregister = _MT4ManagerAPI.ConBackup_swigregister
ConBackup_swigregister(ConBackup)

WATCH_STAND_ALONE = _MT4ManagerAPI.WATCH_STAND_ALONE
WATCH_MASTER = _MT4ManagerAPI.WATCH_MASTER
WATCH_SLAVE = _MT4ManagerAPI.WATCH_SLAVE
BACKUP_1HOUR = _MT4ManagerAPI.BACKUP_1HOUR
BACKUP_4HOURS = _MT4ManagerAPI.BACKUP_4HOURS
BACKUP_1DAY = _MT4ManagerAPI.BACKUP_1DAY
BU_STORE_1MONTH = _MT4ManagerAPI.BU_STORE_1MONTH
BU_STORE_3MONTHS = _MT4ManagerAPI.BU_STORE_3MONTHS
BU_STORE_6MONTHS = _MT4ManagerAPI.BU_STORE_6MONTHS
BU_STORE_1YEAR = _MT4ManagerAPI.BU_STORE_1YEAR
ARC_BACKUP_DISABLED = _MT4ManagerAPI.ARC_BACKUP_DISABLED
ARC_BACKUP_5MIN = _MT4ManagerAPI.ARC_BACKUP_5MIN
ARC_BACKUP_15MIN = _MT4ManagerAPI.ARC_BACKUP_15MIN
ARC_BACKUP_30MIN = _MT4ManagerAPI.ARC_BACKUP_30MIN
ARC_BACKUP_1HOUR = _MT4ManagerAPI.ARC_BACKUP_1HOUR
ARC_STORE_1DAY = _MT4ManagerAPI.ARC_STORE_1DAY
ARC_STORE_3DAYS = _MT4ManagerAPI.ARC_STORE_3DAYS
ARC_STORE_1WEEK = _MT4ManagerAPI.ARC_STORE_1WEEK
ARC_STORE_2WEEKS = _MT4ManagerAPI.ARC_STORE_2WEEKS
ARC_STORE_1MONTH = _MT4ManagerAPI.ARC_STORE_1MONTH
ARC_STORE_3MONTH = _MT4ManagerAPI.ARC_STORE_3MONTH
ARC_STORE_6MONTH = _MT4ManagerAPI.ARC_STORE_6MONTH
EXPORT_1MIN = _MT4ManagerAPI.EXPORT_1MIN
EXPORT_5MIN = _MT4ManagerAPI.EXPORT_5MIN
EXPORT_15MIN = _MT4ManagerAPI.EXPORT_15MIN
EXPORT_30MIN = _MT4ManagerAPI.EXPORT_30MIN
EXPORT_1HOUR = _MT4ManagerAPI.EXPORT_1HOUR
class ConFeeder(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConFeeder, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConFeeder, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _MT4ManagerAPI.ConFeeder_name_set
    __swig_getmethods__["name"] = _MT4ManagerAPI.ConFeeder_name_get
    if _newclass:
        name = _swig_property(_MT4ManagerAPI.ConFeeder_name_get, _MT4ManagerAPI.ConFeeder_name_set)
    __swig_setmethods__["file"] = _MT4ManagerAPI.ConFeeder_file_set
    __swig_getmethods__["file"] = _MT4ManagerAPI.ConFeeder_file_get
    if _newclass:
        file = _swig_property(_MT4ManagerAPI.ConFeeder_file_get, _MT4ManagerAPI.ConFeeder_file_set)
    __swig_setmethods__["server"] = _MT4ManagerAPI.ConFeeder_server_set
    __swig_getmethods__["server"] = _MT4ManagerAPI.ConFeeder_server_get
    if _newclass:
        server = _swig_property(_MT4ManagerAPI.ConFeeder_server_get, _MT4ManagerAPI.ConFeeder_server_set)
    __swig_setmethods__["login"] = _MT4ManagerAPI.ConFeeder_login_set
    __swig_getmethods__["login"] = _MT4ManagerAPI.ConFeeder_login_get
    if _newclass:
        login = _swig_property(_MT4ManagerAPI.ConFeeder_login_get, _MT4ManagerAPI.ConFeeder_login_set)
    __swig_setmethods__["_pass"] = _MT4ManagerAPI.ConFeeder__pass_set
    __swig_getmethods__["_pass"] = _MT4ManagerAPI.ConFeeder__pass_get
    if _newclass:
        _pass = _swig_property(_MT4ManagerAPI.ConFeeder__pass_get, _MT4ManagerAPI.ConFeeder__pass_set)
    __swig_setmethods__["keywords"] = _MT4ManagerAPI.ConFeeder_keywords_set
    __swig_getmethods__["keywords"] = _MT4ManagerAPI.ConFeeder_keywords_get
    if _newclass:
        keywords = _swig_property(_MT4ManagerAPI.ConFeeder_keywords_get, _MT4ManagerAPI.ConFeeder_keywords_set)
    __swig_setmethods__["enable"] = _MT4ManagerAPI.ConFeeder_enable_set
    __swig_getmethods__["enable"] = _MT4ManagerAPI.ConFeeder_enable_get
    if _newclass:
        enable = _swig_property(_MT4ManagerAPI.ConFeeder_enable_get, _MT4ManagerAPI.ConFeeder_enable_set)
    __swig_setmethods__["mode"] = _MT4ManagerAPI.ConFeeder_mode_set
    __swig_getmethods__["mode"] = _MT4ManagerAPI.ConFeeder_mode_get
    if _newclass:
        mode = _swig_property(_MT4ManagerAPI.ConFeeder_mode_get, _MT4ManagerAPI.ConFeeder_mode_set)
    __swig_setmethods__["timeout"] = _MT4ManagerAPI.ConFeeder_timeout_set
    __swig_getmethods__["timeout"] = _MT4ManagerAPI.ConFeeder_timeout_get
    if _newclass:
        timeout = _swig_property(_MT4ManagerAPI.ConFeeder_timeout_get, _MT4ManagerAPI.ConFeeder_timeout_set)
    __swig_setmethods__["timeout_reconnect"] = _MT4ManagerAPI.ConFeeder_timeout_reconnect_set
    __swig_getmethods__["timeout_reconnect"] = _MT4ManagerAPI.ConFeeder_timeout_reconnect_get
    if _newclass:
        timeout_reconnect = _swig_property(_MT4ManagerAPI.ConFeeder_timeout_reconnect_get, _MT4ManagerAPI.ConFeeder_timeout_reconnect_set)
    __swig_setmethods__["timeout_sleep"] = _MT4ManagerAPI.ConFeeder_timeout_sleep_set
    __swig_getmethods__["timeout_sleep"] = _MT4ManagerAPI.ConFeeder_timeout_sleep_get
    if _newclass:
        timeout_sleep = _swig_property(_MT4ManagerAPI.ConFeeder_timeout_sleep_get, _MT4ManagerAPI.ConFeeder_timeout_sleep_set)
    __swig_setmethods__["attemps_sleep"] = _MT4ManagerAPI.ConFeeder_attemps_sleep_set
    __swig_getmethods__["attemps_sleep"] = _MT4ManagerAPI.ConFeeder_attemps_sleep_get
    if _newclass:
        attemps_sleep = _swig_property(_MT4ManagerAPI.ConFeeder_attemps_sleep_get, _MT4ManagerAPI.ConFeeder_attemps_sleep_set)
    __swig_setmethods__["news_langid"] = _MT4ManagerAPI.ConFeeder_news_langid_set
    __swig_getmethods__["news_langid"] = _MT4ManagerAPI.ConFeeder_news_langid_get
    if _newclass:
        news_langid = _swig_property(_MT4ManagerAPI.ConFeeder_news_langid_get, _MT4ManagerAPI.ConFeeder_news_langid_set)
    __swig_setmethods__["unused"] = _MT4ManagerAPI.ConFeeder_unused_set
    __swig_getmethods__["unused"] = _MT4ManagerAPI.ConFeeder_unused_get
    if _newclass:
        unused = _swig_property(_MT4ManagerAPI.ConFeeder_unused_get, _MT4ManagerAPI.ConFeeder_unused_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConFeeder()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConFeeder
    __del__ = lambda self: None
ConFeeder_swigregister = _MT4ManagerAPI.ConFeeder_swigregister
ConFeeder_swigregister(ConFeeder)

FEED_QUOTES = _MT4ManagerAPI.FEED_QUOTES
FEED_NEWS = _MT4ManagerAPI.FEED_NEWS
FEED_QUOTESNEWS = _MT4ManagerAPI.FEED_QUOTESNEWS
MAX_SEC_GROUPS = _MT4ManagerAPI.MAX_SEC_GROUPS
MAX_SEC_GROPS_MARGIN = _MT4ManagerAPI.MAX_SEC_GROPS_MARGIN
class ConGroupSec(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConGroupSec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConGroupSec, name)
    __repr__ = _swig_repr
    __swig_setmethods__["show"] = _MT4ManagerAPI.ConGroupSec_show_set
    __swig_getmethods__["show"] = _MT4ManagerAPI.ConGroupSec_show_get
    if _newclass:
        show = _swig_property(_MT4ManagerAPI.ConGroupSec_show_get, _MT4ManagerAPI.ConGroupSec_show_set)
    __swig_setmethods__["trade"] = _MT4ManagerAPI.ConGroupSec_trade_set
    __swig_getmethods__["trade"] = _MT4ManagerAPI.ConGroupSec_trade_get
    if _newclass:
        trade = _swig_property(_MT4ManagerAPI.ConGroupSec_trade_get, _MT4ManagerAPI.ConGroupSec_trade_set)
    __swig_setmethods__["execution"] = _MT4ManagerAPI.ConGroupSec_execution_set
    __swig_getmethods__["execution"] = _MT4ManagerAPI.ConGroupSec_execution_get
    if _newclass:
        execution = _swig_property(_MT4ManagerAPI.ConGroupSec_execution_get, _MT4ManagerAPI.ConGroupSec_execution_set)
    __swig_setmethods__["comm_base"] = _MT4ManagerAPI.ConGroupSec_comm_base_set
    __swig_getmethods__["comm_base"] = _MT4ManagerAPI.ConGroupSec_comm_base_get
    if _newclass:
        comm_base = _swig_property(_MT4ManagerAPI.ConGroupSec_comm_base_get, _MT4ManagerAPI.ConGroupSec_comm_base_set)
    __swig_setmethods__["comm_type"] = _MT4ManagerAPI.ConGroupSec_comm_type_set
    __swig_getmethods__["comm_type"] = _MT4ManagerAPI.ConGroupSec_comm_type_get
    if _newclass:
        comm_type = _swig_property(_MT4ManagerAPI.ConGroupSec_comm_type_get, _MT4ManagerAPI.ConGroupSec_comm_type_set)
    __swig_setmethods__["comm_lots"] = _MT4ManagerAPI.ConGroupSec_comm_lots_set
    __swig_getmethods__["comm_lots"] = _MT4ManagerAPI.ConGroupSec_comm_lots_get
    if _newclass:
        comm_lots = _swig_property(_MT4ManagerAPI.ConGroupSec_comm_lots_get, _MT4ManagerAPI.ConGroupSec_comm_lots_set)
    __swig_setmethods__["comm_agent"] = _MT4ManagerAPI.ConGroupSec_comm_agent_set
    __swig_getmethods__["comm_agent"] = _MT4ManagerAPI.ConGroupSec_comm_agent_get
    if _newclass:
        comm_agent = _swig_property(_MT4ManagerAPI.ConGroupSec_comm_agent_get, _MT4ManagerAPI.ConGroupSec_comm_agent_set)
    __swig_setmethods__["comm_agent_type"] = _MT4ManagerAPI.ConGroupSec_comm_agent_type_set
    __swig_getmethods__["comm_agent_type"] = _MT4ManagerAPI.ConGroupSec_comm_agent_type_get
    if _newclass:
        comm_agent_type = _swig_property(_MT4ManagerAPI.ConGroupSec_comm_agent_type_get, _MT4ManagerAPI.ConGroupSec_comm_agent_type_set)
    __swig_setmethods__["spread_diff"] = _MT4ManagerAPI.ConGroupSec_spread_diff_set
    __swig_getmethods__["spread_diff"] = _MT4ManagerAPI.ConGroupSec_spread_diff_get
    if _newclass:
        spread_diff = _swig_property(_MT4ManagerAPI.ConGroupSec_spread_diff_get, _MT4ManagerAPI.ConGroupSec_spread_diff_set)
    __swig_setmethods__["lot_min"] = _MT4ManagerAPI.ConGroupSec_lot_min_set
    __swig_getmethods__["lot_min"] = _MT4ManagerAPI.ConGroupSec_lot_min_get
    if _newclass:
        lot_min = _swig_property(_MT4ManagerAPI.ConGroupSec_lot_min_get, _MT4ManagerAPI.ConGroupSec_lot_min_set)
    __swig_setmethods__["lot_max"] = _MT4ManagerAPI.ConGroupSec_lot_max_set
    __swig_getmethods__["lot_max"] = _MT4ManagerAPI.ConGroupSec_lot_max_get
    if _newclass:
        lot_max = _swig_property(_MT4ManagerAPI.ConGroupSec_lot_max_get, _MT4ManagerAPI.ConGroupSec_lot_max_set)
    __swig_setmethods__["lot_step"] = _MT4ManagerAPI.ConGroupSec_lot_step_set
    __swig_getmethods__["lot_step"] = _MT4ManagerAPI.ConGroupSec_lot_step_get
    if _newclass:
        lot_step = _swig_property(_MT4ManagerAPI.ConGroupSec_lot_step_get, _MT4ManagerAPI.ConGroupSec_lot_step_set)
    __swig_setmethods__["ie_deviation"] = _MT4ManagerAPI.ConGroupSec_ie_deviation_set
    __swig_getmethods__["ie_deviation"] = _MT4ManagerAPI.ConGroupSec_ie_deviation_get
    if _newclass:
        ie_deviation = _swig_property(_MT4ManagerAPI.ConGroupSec_ie_deviation_get, _MT4ManagerAPI.ConGroupSec_ie_deviation_set)
    __swig_setmethods__["confirmation"] = _MT4ManagerAPI.ConGroupSec_confirmation_set
    __swig_getmethods__["confirmation"] = _MT4ManagerAPI.ConGroupSec_confirmation_get
    if _newclass:
        confirmation = _swig_property(_MT4ManagerAPI.ConGroupSec_confirmation_get, _MT4ManagerAPI.ConGroupSec_confirmation_set)
    __swig_setmethods__["trade_rights"] = _MT4ManagerAPI.ConGroupSec_trade_rights_set
    __swig_getmethods__["trade_rights"] = _MT4ManagerAPI.ConGroupSec_trade_rights_get
    if _newclass:
        trade_rights = _swig_property(_MT4ManagerAPI.ConGroupSec_trade_rights_get, _MT4ManagerAPI.ConGroupSec_trade_rights_set)
    __swig_setmethods__["ie_quick_mode"] = _MT4ManagerAPI.ConGroupSec_ie_quick_mode_set
    __swig_getmethods__["ie_quick_mode"] = _MT4ManagerAPI.ConGroupSec_ie_quick_mode_get
    if _newclass:
        ie_quick_mode = _swig_property(_MT4ManagerAPI.ConGroupSec_ie_quick_mode_get, _MT4ManagerAPI.ConGroupSec_ie_quick_mode_set)
    __swig_setmethods__["autocloseout_mode"] = _MT4ManagerAPI.ConGroupSec_autocloseout_mode_set
    __swig_getmethods__["autocloseout_mode"] = _MT4ManagerAPI.ConGroupSec_autocloseout_mode_get
    if _newclass:
        autocloseout_mode = _swig_property(_MT4ManagerAPI.ConGroupSec_autocloseout_mode_get, _MT4ManagerAPI.ConGroupSec_autocloseout_mode_set)
    __swig_setmethods__["comm_tax"] = _MT4ManagerAPI.ConGroupSec_comm_tax_set
    __swig_getmethods__["comm_tax"] = _MT4ManagerAPI.ConGroupSec_comm_tax_get
    if _newclass:
        comm_tax = _swig_property(_MT4ManagerAPI.ConGroupSec_comm_tax_get, _MT4ManagerAPI.ConGroupSec_comm_tax_set)
    __swig_setmethods__["comm_agent_lots"] = _MT4ManagerAPI.ConGroupSec_comm_agent_lots_set
    __swig_getmethods__["comm_agent_lots"] = _MT4ManagerAPI.ConGroupSec_comm_agent_lots_get
    if _newclass:
        comm_agent_lots = _swig_property(_MT4ManagerAPI.ConGroupSec_comm_agent_lots_get, _MT4ManagerAPI.ConGroupSec_comm_agent_lots_set)
    __swig_setmethods__["freemargin_mode"] = _MT4ManagerAPI.ConGroupSec_freemargin_mode_set
    __swig_getmethods__["freemargin_mode"] = _MT4ManagerAPI.ConGroupSec_freemargin_mode_get
    if _newclass:
        freemargin_mode = _swig_property(_MT4ManagerAPI.ConGroupSec_freemargin_mode_get, _MT4ManagerAPI.ConGroupSec_freemargin_mode_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConGroupSec_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConGroupSec_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConGroupSec_reserved_get, _MT4ManagerAPI.ConGroupSec_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConGroupSec()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConGroupSec
    __del__ = lambda self: None
ConGroupSec_swigregister = _MT4ManagerAPI.ConGroupSec_swigregister
ConGroupSec_swigregister(ConGroupSec)

class ConGroupMargin(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConGroupMargin, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConGroupMargin, name)
    __repr__ = _swig_repr
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.ConGroupMargin_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.ConGroupMargin_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.ConGroupMargin_symbol_get, _MT4ManagerAPI.ConGroupMargin_symbol_set)
    __swig_setmethods__["swap_long"] = _MT4ManagerAPI.ConGroupMargin_swap_long_set
    __swig_getmethods__["swap_long"] = _MT4ManagerAPI.ConGroupMargin_swap_long_get
    if _newclass:
        swap_long = _swig_property(_MT4ManagerAPI.ConGroupMargin_swap_long_get, _MT4ManagerAPI.ConGroupMargin_swap_long_set)
    __swig_setmethods__["swap_short"] = _MT4ManagerAPI.ConGroupMargin_swap_short_set
    __swig_getmethods__["swap_short"] = _MT4ManagerAPI.ConGroupMargin_swap_short_get
    if _newclass:
        swap_short = _swig_property(_MT4ManagerAPI.ConGroupMargin_swap_short_get, _MT4ManagerAPI.ConGroupMargin_swap_short_set)
    __swig_setmethods__["margin_divider"] = _MT4ManagerAPI.ConGroupMargin_margin_divider_set
    __swig_getmethods__["margin_divider"] = _MT4ManagerAPI.ConGroupMargin_margin_divider_get
    if _newclass:
        margin_divider = _swig_property(_MT4ManagerAPI.ConGroupMargin_margin_divider_get, _MT4ManagerAPI.ConGroupMargin_margin_divider_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConGroupMargin_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConGroupMargin_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConGroupMargin_reserved_get, _MT4ManagerAPI.ConGroupMargin_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConGroupMargin()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConGroupMargin
    __del__ = lambda self: None
ConGroupMargin_swigregister = _MT4ManagerAPI.ConGroupMargin_swigregister
ConGroupMargin_swigregister(ConGroupMargin)

EXECUTION_MANUAL = _MT4ManagerAPI.EXECUTION_MANUAL
EXECUTION_AUTO = _MT4ManagerAPI.EXECUTION_AUTO
EXECUTION_ACTIVITY = _MT4ManagerAPI.EXECUTION_ACTIVITY
COMM_TYPE_MONEY = _MT4ManagerAPI.COMM_TYPE_MONEY
COMM_TYPE_PIPS = _MT4ManagerAPI.COMM_TYPE_PIPS
COMM_TYPE_PERCENT = _MT4ManagerAPI.COMM_TYPE_PERCENT
COMMISSION_PER_LOT = _MT4ManagerAPI.COMMISSION_PER_LOT
COMMISSION_PER_DEAL = _MT4ManagerAPI.COMMISSION_PER_DEAL
TRADE_DENY_NONE = _MT4ManagerAPI.TRADE_DENY_NONE
TRADE_DENY_CLOSEBY = _MT4ManagerAPI.TRADE_DENY_CLOSEBY
TRADE_DENY_MUCLOSEBY = _MT4ManagerAPI.TRADE_DENY_MUCLOSEBY
CLOSE_OUT_NONE = _MT4ManagerAPI.CLOSE_OUT_NONE
CLOSE_OUT_HIHI = _MT4ManagerAPI.CLOSE_OUT_HIHI
CLOSE_OUT_LOLO = _MT4ManagerAPI.CLOSE_OUT_LOLO
CLOSE_OUT_HILO = _MT4ManagerAPI.CLOSE_OUT_HILO
CLOSE_OUT_LOHI = _MT4ManagerAPI.CLOSE_OUT_LOHI
CLOSE_OUT_FIFO = _MT4ManagerAPI.CLOSE_OUT_FIFO
CLOSE_OUT_LIFO = _MT4ManagerAPI.CLOSE_OUT_LIFO
CLOSE_OUT_INTRDAY_FIFO = _MT4ManagerAPI.CLOSE_OUT_INTRDAY_FIFO
class ConGroup(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConGroup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConGroup, name)
    __repr__ = _swig_repr
    __swig_setmethods__["group"] = _MT4ManagerAPI.ConGroup_group_set
    __swig_getmethods__["group"] = _MT4ManagerAPI.ConGroup_group_get
    if _newclass:
        group = _swig_property(_MT4ManagerAPI.ConGroup_group_get, _MT4ManagerAPI.ConGroup_group_set)
    __swig_setmethods__["enable"] = _MT4ManagerAPI.ConGroup_enable_set
    __swig_getmethods__["enable"] = _MT4ManagerAPI.ConGroup_enable_get
    if _newclass:
        enable = _swig_property(_MT4ManagerAPI.ConGroup_enable_get, _MT4ManagerAPI.ConGroup_enable_set)
    __swig_setmethods__["timeout"] = _MT4ManagerAPI.ConGroup_timeout_set
    __swig_getmethods__["timeout"] = _MT4ManagerAPI.ConGroup_timeout_get
    if _newclass:
        timeout = _swig_property(_MT4ManagerAPI.ConGroup_timeout_get, _MT4ManagerAPI.ConGroup_timeout_set)
    __swig_setmethods__["adv_security"] = _MT4ManagerAPI.ConGroup_adv_security_set
    __swig_getmethods__["adv_security"] = _MT4ManagerAPI.ConGroup_adv_security_get
    if _newclass:
        adv_security = _swig_property(_MT4ManagerAPI.ConGroup_adv_security_get, _MT4ManagerAPI.ConGroup_adv_security_set)
    __swig_setmethods__["company"] = _MT4ManagerAPI.ConGroup_company_set
    __swig_getmethods__["company"] = _MT4ManagerAPI.ConGroup_company_get
    if _newclass:
        company = _swig_property(_MT4ManagerAPI.ConGroup_company_get, _MT4ManagerAPI.ConGroup_company_set)
    __swig_setmethods__["signature"] = _MT4ManagerAPI.ConGroup_signature_set
    __swig_getmethods__["signature"] = _MT4ManagerAPI.ConGroup_signature_get
    if _newclass:
        signature = _swig_property(_MT4ManagerAPI.ConGroup_signature_get, _MT4ManagerAPI.ConGroup_signature_set)
    __swig_setmethods__["support_page"] = _MT4ManagerAPI.ConGroup_support_page_set
    __swig_getmethods__["support_page"] = _MT4ManagerAPI.ConGroup_support_page_get
    if _newclass:
        support_page = _swig_property(_MT4ManagerAPI.ConGroup_support_page_get, _MT4ManagerAPI.ConGroup_support_page_set)
    __swig_setmethods__["smtp_server"] = _MT4ManagerAPI.ConGroup_smtp_server_set
    __swig_getmethods__["smtp_server"] = _MT4ManagerAPI.ConGroup_smtp_server_get
    if _newclass:
        smtp_server = _swig_property(_MT4ManagerAPI.ConGroup_smtp_server_get, _MT4ManagerAPI.ConGroup_smtp_server_set)
    __swig_setmethods__["smtp_login"] = _MT4ManagerAPI.ConGroup_smtp_login_set
    __swig_getmethods__["smtp_login"] = _MT4ManagerAPI.ConGroup_smtp_login_get
    if _newclass:
        smtp_login = _swig_property(_MT4ManagerAPI.ConGroup_smtp_login_get, _MT4ManagerAPI.ConGroup_smtp_login_set)
    __swig_setmethods__["smtp_password"] = _MT4ManagerAPI.ConGroup_smtp_password_set
    __swig_getmethods__["smtp_password"] = _MT4ManagerAPI.ConGroup_smtp_password_get
    if _newclass:
        smtp_password = _swig_property(_MT4ManagerAPI.ConGroup_smtp_password_get, _MT4ManagerAPI.ConGroup_smtp_password_set)
    __swig_setmethods__["support_email"] = _MT4ManagerAPI.ConGroup_support_email_set
    __swig_getmethods__["support_email"] = _MT4ManagerAPI.ConGroup_support_email_get
    if _newclass:
        support_email = _swig_property(_MT4ManagerAPI.ConGroup_support_email_get, _MT4ManagerAPI.ConGroup_support_email_set)
    __swig_setmethods__["templates"] = _MT4ManagerAPI.ConGroup_templates_set
    __swig_getmethods__["templates"] = _MT4ManagerAPI.ConGroup_templates_get
    if _newclass:
        templates = _swig_property(_MT4ManagerAPI.ConGroup_templates_get, _MT4ManagerAPI.ConGroup_templates_set)
    __swig_setmethods__["copies"] = _MT4ManagerAPI.ConGroup_copies_set
    __swig_getmethods__["copies"] = _MT4ManagerAPI.ConGroup_copies_get
    if _newclass:
        copies = _swig_property(_MT4ManagerAPI.ConGroup_copies_get, _MT4ManagerAPI.ConGroup_copies_set)
    __swig_setmethods__["reports"] = _MT4ManagerAPI.ConGroup_reports_set
    __swig_getmethods__["reports"] = _MT4ManagerAPI.ConGroup_reports_get
    if _newclass:
        reports = _swig_property(_MT4ManagerAPI.ConGroup_reports_get, _MT4ManagerAPI.ConGroup_reports_set)
    __swig_setmethods__["default_leverage"] = _MT4ManagerAPI.ConGroup_default_leverage_set
    __swig_getmethods__["default_leverage"] = _MT4ManagerAPI.ConGroup_default_leverage_get
    if _newclass:
        default_leverage = _swig_property(_MT4ManagerAPI.ConGroup_default_leverage_get, _MT4ManagerAPI.ConGroup_default_leverage_set)
    __swig_setmethods__["default_deposit"] = _MT4ManagerAPI.ConGroup_default_deposit_set
    __swig_getmethods__["default_deposit"] = _MT4ManagerAPI.ConGroup_default_deposit_get
    if _newclass:
        default_deposit = _swig_property(_MT4ManagerAPI.ConGroup_default_deposit_get, _MT4ManagerAPI.ConGroup_default_deposit_set)
    __swig_setmethods__["maxsecurities"] = _MT4ManagerAPI.ConGroup_maxsecurities_set
    __swig_getmethods__["maxsecurities"] = _MT4ManagerAPI.ConGroup_maxsecurities_get
    if _newclass:
        maxsecurities = _swig_property(_MT4ManagerAPI.ConGroup_maxsecurities_get, _MT4ManagerAPI.ConGroup_maxsecurities_set)
    __swig_setmethods__["secgroups"] = _MT4ManagerAPI.ConGroup_secgroups_set
    __swig_getmethods__["secgroups"] = _MT4ManagerAPI.ConGroup_secgroups_get
    if _newclass:
        secgroups = _swig_property(_MT4ManagerAPI.ConGroup_secgroups_get, _MT4ManagerAPI.ConGroup_secgroups_set)
    __swig_setmethods__["secmargins"] = _MT4ManagerAPI.ConGroup_secmargins_set
    __swig_getmethods__["secmargins"] = _MT4ManagerAPI.ConGroup_secmargins_get
    if _newclass:
        secmargins = _swig_property(_MT4ManagerAPI.ConGroup_secmargins_get, _MT4ManagerAPI.ConGroup_secmargins_set)
    __swig_setmethods__["secmargins_total"] = _MT4ManagerAPI.ConGroup_secmargins_total_set
    __swig_getmethods__["secmargins_total"] = _MT4ManagerAPI.ConGroup_secmargins_total_get
    if _newclass:
        secmargins_total = _swig_property(_MT4ManagerAPI.ConGroup_secmargins_total_get, _MT4ManagerAPI.ConGroup_secmargins_total_set)
    __swig_setmethods__["currency"] = _MT4ManagerAPI.ConGroup_currency_set
    __swig_getmethods__["currency"] = _MT4ManagerAPI.ConGroup_currency_get
    if _newclass:
        currency = _swig_property(_MT4ManagerAPI.ConGroup_currency_get, _MT4ManagerAPI.ConGroup_currency_set)
    __swig_setmethods__["credit"] = _MT4ManagerAPI.ConGroup_credit_set
    __swig_getmethods__["credit"] = _MT4ManagerAPI.ConGroup_credit_get
    if _newclass:
        credit = _swig_property(_MT4ManagerAPI.ConGroup_credit_get, _MT4ManagerAPI.ConGroup_credit_set)
    __swig_setmethods__["margin_call"] = _MT4ManagerAPI.ConGroup_margin_call_set
    __swig_getmethods__["margin_call"] = _MT4ManagerAPI.ConGroup_margin_call_get
    if _newclass:
        margin_call = _swig_property(_MT4ManagerAPI.ConGroup_margin_call_get, _MT4ManagerAPI.ConGroup_margin_call_set)
    __swig_setmethods__["margin_mode"] = _MT4ManagerAPI.ConGroup_margin_mode_set
    __swig_getmethods__["margin_mode"] = _MT4ManagerAPI.ConGroup_margin_mode_get
    if _newclass:
        margin_mode = _swig_property(_MT4ManagerAPI.ConGroup_margin_mode_get, _MT4ManagerAPI.ConGroup_margin_mode_set)
    __swig_setmethods__["margin_stopout"] = _MT4ManagerAPI.ConGroup_margin_stopout_set
    __swig_getmethods__["margin_stopout"] = _MT4ManagerAPI.ConGroup_margin_stopout_get
    if _newclass:
        margin_stopout = _swig_property(_MT4ManagerAPI.ConGroup_margin_stopout_get, _MT4ManagerAPI.ConGroup_margin_stopout_set)
    __swig_setmethods__["interestrate"] = _MT4ManagerAPI.ConGroup_interestrate_set
    __swig_getmethods__["interestrate"] = _MT4ManagerAPI.ConGroup_interestrate_get
    if _newclass:
        interestrate = _swig_property(_MT4ManagerAPI.ConGroup_interestrate_get, _MT4ManagerAPI.ConGroup_interestrate_set)
    __swig_setmethods__["use_swap"] = _MT4ManagerAPI.ConGroup_use_swap_set
    __swig_getmethods__["use_swap"] = _MT4ManagerAPI.ConGroup_use_swap_get
    if _newclass:
        use_swap = _swig_property(_MT4ManagerAPI.ConGroup_use_swap_get, _MT4ManagerAPI.ConGroup_use_swap_set)
    __swig_setmethods__["news"] = _MT4ManagerAPI.ConGroup_news_set
    __swig_getmethods__["news"] = _MT4ManagerAPI.ConGroup_news_get
    if _newclass:
        news = _swig_property(_MT4ManagerAPI.ConGroup_news_get, _MT4ManagerAPI.ConGroup_news_set)
    __swig_setmethods__["rights"] = _MT4ManagerAPI.ConGroup_rights_set
    __swig_getmethods__["rights"] = _MT4ManagerAPI.ConGroup_rights_get
    if _newclass:
        rights = _swig_property(_MT4ManagerAPI.ConGroup_rights_get, _MT4ManagerAPI.ConGroup_rights_set)
    __swig_setmethods__["check_ie_prices"] = _MT4ManagerAPI.ConGroup_check_ie_prices_set
    __swig_getmethods__["check_ie_prices"] = _MT4ManagerAPI.ConGroup_check_ie_prices_get
    if _newclass:
        check_ie_prices = _swig_property(_MT4ManagerAPI.ConGroup_check_ie_prices_get, _MT4ManagerAPI.ConGroup_check_ie_prices_set)
    __swig_setmethods__["maxpositions"] = _MT4ManagerAPI.ConGroup_maxpositions_set
    __swig_getmethods__["maxpositions"] = _MT4ManagerAPI.ConGroup_maxpositions_get
    if _newclass:
        maxpositions = _swig_property(_MT4ManagerAPI.ConGroup_maxpositions_get, _MT4ManagerAPI.ConGroup_maxpositions_set)
    __swig_setmethods__["close_reopen"] = _MT4ManagerAPI.ConGroup_close_reopen_set
    __swig_getmethods__["close_reopen"] = _MT4ManagerAPI.ConGroup_close_reopen_get
    if _newclass:
        close_reopen = _swig_property(_MT4ManagerAPI.ConGroup_close_reopen_get, _MT4ManagerAPI.ConGroup_close_reopen_set)
    __swig_setmethods__["hedge_prohibited"] = _MT4ManagerAPI.ConGroup_hedge_prohibited_set
    __swig_getmethods__["hedge_prohibited"] = _MT4ManagerAPI.ConGroup_hedge_prohibited_get
    if _newclass:
        hedge_prohibited = _swig_property(_MT4ManagerAPI.ConGroup_hedge_prohibited_get, _MT4ManagerAPI.ConGroup_hedge_prohibited_set)
    __swig_setmethods__["close_fifo"] = _MT4ManagerAPI.ConGroup_close_fifo_set
    __swig_getmethods__["close_fifo"] = _MT4ManagerAPI.ConGroup_close_fifo_get
    if _newclass:
        close_fifo = _swig_property(_MT4ManagerAPI.ConGroup_close_fifo_get, _MT4ManagerAPI.ConGroup_close_fifo_set)
    __swig_setmethods__["hedge_largeleg"] = _MT4ManagerAPI.ConGroup_hedge_largeleg_set
    __swig_getmethods__["hedge_largeleg"] = _MT4ManagerAPI.ConGroup_hedge_largeleg_get
    if _newclass:
        hedge_largeleg = _swig_property(_MT4ManagerAPI.ConGroup_hedge_largeleg_get, _MT4ManagerAPI.ConGroup_hedge_largeleg_set)
    __swig_setmethods__["unused_rights"] = _MT4ManagerAPI.ConGroup_unused_rights_set
    __swig_getmethods__["unused_rights"] = _MT4ManagerAPI.ConGroup_unused_rights_get
    if _newclass:
        unused_rights = _swig_property(_MT4ManagerAPI.ConGroup_unused_rights_get, _MT4ManagerAPI.ConGroup_unused_rights_set)
    __swig_setmethods__["securities_hash"] = _MT4ManagerAPI.ConGroup_securities_hash_set
    __swig_getmethods__["securities_hash"] = _MT4ManagerAPI.ConGroup_securities_hash_get
    if _newclass:
        securities_hash = _swig_property(_MT4ManagerAPI.ConGroup_securities_hash_get, _MT4ManagerAPI.ConGroup_securities_hash_set)
    __swig_setmethods__["margin_type"] = _MT4ManagerAPI.ConGroup_margin_type_set
    __swig_getmethods__["margin_type"] = _MT4ManagerAPI.ConGroup_margin_type_get
    if _newclass:
        margin_type = _swig_property(_MT4ManagerAPI.ConGroup_margin_type_get, _MT4ManagerAPI.ConGroup_margin_type_set)
    __swig_setmethods__["archive_period"] = _MT4ManagerAPI.ConGroup_archive_period_set
    __swig_getmethods__["archive_period"] = _MT4ManagerAPI.ConGroup_archive_period_get
    if _newclass:
        archive_period = _swig_property(_MT4ManagerAPI.ConGroup_archive_period_get, _MT4ManagerAPI.ConGroup_archive_period_set)
    __swig_setmethods__["archive_max_balance"] = _MT4ManagerAPI.ConGroup_archive_max_balance_set
    __swig_getmethods__["archive_max_balance"] = _MT4ManagerAPI.ConGroup_archive_max_balance_get
    if _newclass:
        archive_max_balance = _swig_property(_MT4ManagerAPI.ConGroup_archive_max_balance_get, _MT4ManagerAPI.ConGroup_archive_max_balance_set)
    __swig_setmethods__["stopout_skip_hedged"] = _MT4ManagerAPI.ConGroup_stopout_skip_hedged_set
    __swig_getmethods__["stopout_skip_hedged"] = _MT4ManagerAPI.ConGroup_stopout_skip_hedged_get
    if _newclass:
        stopout_skip_hedged = _swig_property(_MT4ManagerAPI.ConGroup_stopout_skip_hedged_get, _MT4ManagerAPI.ConGroup_stopout_skip_hedged_set)
    __swig_setmethods__["archive_pending_period"] = _MT4ManagerAPI.ConGroup_archive_pending_period_set
    __swig_getmethods__["archive_pending_period"] = _MT4ManagerAPI.ConGroup_archive_pending_period_get
    if _newclass:
        archive_pending_period = _swig_property(_MT4ManagerAPI.ConGroup_archive_pending_period_get, _MT4ManagerAPI.ConGroup_archive_pending_period_set)
    __swig_setmethods__["news_languages"] = _MT4ManagerAPI.ConGroup_news_languages_set
    __swig_getmethods__["news_languages"] = _MT4ManagerAPI.ConGroup_news_languages_get
    if _newclass:
        news_languages = _swig_property(_MT4ManagerAPI.ConGroup_news_languages_get, _MT4ManagerAPI.ConGroup_news_languages_set)
    __swig_setmethods__["news_languages_total"] = _MT4ManagerAPI.ConGroup_news_languages_total_set
    __swig_getmethods__["news_languages_total"] = _MT4ManagerAPI.ConGroup_news_languages_total_get
    if _newclass:
        news_languages_total = _swig_property(_MT4ManagerAPI.ConGroup_news_languages_total_get, _MT4ManagerAPI.ConGroup_news_languages_total_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConGroup_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConGroup_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConGroup_reserved_get, _MT4ManagerAPI.ConGroup_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConGroup()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConGroup
    __del__ = lambda self: None
ConGroup_swigregister = _MT4ManagerAPI.ConGroup_swigregister
ConGroup_swigregister(ConGroup)

MARGIN_MODE_DONT_USE = _MT4ManagerAPI.MARGIN_MODE_DONT_USE
MARGIN_MODE_USE_ALL = _MT4ManagerAPI.MARGIN_MODE_USE_ALL
MARGIN_MODE_USE_PROFIT = _MT4ManagerAPI.MARGIN_MODE_USE_PROFIT
MARGIN_MODE_USE_LOSS = _MT4ManagerAPI.MARGIN_MODE_USE_LOSS
MARGIN_TYPE_PERCENT = _MT4ManagerAPI.MARGIN_TYPE_PERCENT
MARGIN_TYPE_CURRENCY = _MT4ManagerAPI.MARGIN_TYPE_CURRENCY
NEWS_NO = _MT4ManagerAPI.NEWS_NO
NEWS_TOPICS = _MT4ManagerAPI.NEWS_TOPICS
NEWS_FULL = _MT4ManagerAPI.NEWS_FULL
ALLOW_FLAG_EMAIL = _MT4ManagerAPI.ALLOW_FLAG_EMAIL
ALLOW_FLAG_TRAILING = _MT4ManagerAPI.ALLOW_FLAG_TRAILING
ALLOW_FLAG_ADVISOR = _MT4ManagerAPI.ALLOW_FLAG_ADVISOR
ALLOW_FLAG_EXPIRATION = _MT4ManagerAPI.ALLOW_FLAG_EXPIRATION
ALLOW_FLAG_SIGNALS_ALL = _MT4ManagerAPI.ALLOW_FLAG_SIGNALS_ALL
ALLOW_FLAG_SIGNALS_OWN = _MT4ManagerAPI.ALLOW_FLAG_SIGNALS_OWN
class ConHoliday(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConHoliday, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConHoliday, name)
    __repr__ = _swig_repr
    __swig_setmethods__["year"] = _MT4ManagerAPI.ConHoliday_year_set
    __swig_getmethods__["year"] = _MT4ManagerAPI.ConHoliday_year_get
    if _newclass:
        year = _swig_property(_MT4ManagerAPI.ConHoliday_year_get, _MT4ManagerAPI.ConHoliday_year_set)
    __swig_setmethods__["month"] = _MT4ManagerAPI.ConHoliday_month_set
    __swig_getmethods__["month"] = _MT4ManagerAPI.ConHoliday_month_get
    if _newclass:
        month = _swig_property(_MT4ManagerAPI.ConHoliday_month_get, _MT4ManagerAPI.ConHoliday_month_set)
    __swig_setmethods__["day"] = _MT4ManagerAPI.ConHoliday_day_set
    __swig_getmethods__["day"] = _MT4ManagerAPI.ConHoliday_day_get
    if _newclass:
        day = _swig_property(_MT4ManagerAPI.ConHoliday_day_get, _MT4ManagerAPI.ConHoliday_day_set)
    __swig_setmethods__["_from"] = _MT4ManagerAPI.ConHoliday__from_set
    __swig_getmethods__["_from"] = _MT4ManagerAPI.ConHoliday__from_get
    if _newclass:
        _from = _swig_property(_MT4ManagerAPI.ConHoliday__from_get, _MT4ManagerAPI.ConHoliday__from_set)
    __swig_setmethods__["to"] = _MT4ManagerAPI.ConHoliday_to_set
    __swig_getmethods__["to"] = _MT4ManagerAPI.ConHoliday_to_get
    if _newclass:
        to = _swig_property(_MT4ManagerAPI.ConHoliday_to_get, _MT4ManagerAPI.ConHoliday_to_set)
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.ConHoliday_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.ConHoliday_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.ConHoliday_symbol_get, _MT4ManagerAPI.ConHoliday_symbol_set)
    __swig_setmethods__["description"] = _MT4ManagerAPI.ConHoliday_description_set
    __swig_getmethods__["description"] = _MT4ManagerAPI.ConHoliday_description_get
    if _newclass:
        description = _swig_property(_MT4ManagerAPI.ConHoliday_description_get, _MT4ManagerAPI.ConHoliday_description_set)
    __swig_setmethods__["enable"] = _MT4ManagerAPI.ConHoliday_enable_set
    __swig_getmethods__["enable"] = _MT4ManagerAPI.ConHoliday_enable_get
    if _newclass:
        enable = _swig_property(_MT4ManagerAPI.ConHoliday_enable_get, _MT4ManagerAPI.ConHoliday_enable_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConHoliday_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConHoliday_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConHoliday_reserved_get, _MT4ManagerAPI.ConHoliday_reserved_set)
    __swig_setmethods__["next"] = _MT4ManagerAPI.ConHoliday_next_set
    __swig_getmethods__["next"] = _MT4ManagerAPI.ConHoliday_next_get
    if _newclass:
        next = _swig_property(_MT4ManagerAPI.ConHoliday_next_get, _MT4ManagerAPI.ConHoliday_next_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConHoliday()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConHoliday
    __del__ = lambda self: None
ConHoliday_swigregister = _MT4ManagerAPI.ConHoliday_swigregister
ConHoliday_swigregister(ConHoliday)

LIVE_FILES_MAX = _MT4ManagerAPI.LIVE_FILES_MAX
class LiveInfoFile(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LiveInfoFile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LiveInfoFile, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file"] = _MT4ManagerAPI.LiveInfoFile_file_set
    __swig_getmethods__["file"] = _MT4ManagerAPI.LiveInfoFile_file_get
    if _newclass:
        file = _swig_property(_MT4ManagerAPI.LiveInfoFile_file_get, _MT4ManagerAPI.LiveInfoFile_file_set)
    __swig_setmethods__["size"] = _MT4ManagerAPI.LiveInfoFile_size_set
    __swig_getmethods__["size"] = _MT4ManagerAPI.LiveInfoFile_size_get
    if _newclass:
        size = _swig_property(_MT4ManagerAPI.LiveInfoFile_size_get, _MT4ManagerAPI.LiveInfoFile_size_set)
    __swig_setmethods__["hash"] = _MT4ManagerAPI.LiveInfoFile_hash_set
    __swig_getmethods__["hash"] = _MT4ManagerAPI.LiveInfoFile_hash_get
    if _newclass:
        hash = _swig_property(_MT4ManagerAPI.LiveInfoFile_hash_get, _MT4ManagerAPI.LiveInfoFile_hash_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.LiveInfoFile_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.LiveInfoFile_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.LiveInfoFile_reserved_get, _MT4ManagerAPI.LiveInfoFile_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_LiveInfoFile()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_LiveInfoFile
    __del__ = lambda self: None
LiveInfoFile_swigregister = _MT4ManagerAPI.LiveInfoFile_swigregister
LiveInfoFile_swigregister(LiveInfoFile)

class ConLiveUpdate(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConLiveUpdate, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConLiveUpdate, name)
    __repr__ = _swig_repr
    __swig_setmethods__["company"] = _MT4ManagerAPI.ConLiveUpdate_company_set
    __swig_getmethods__["company"] = _MT4ManagerAPI.ConLiveUpdate_company_get
    if _newclass:
        company = _swig_property(_MT4ManagerAPI.ConLiveUpdate_company_get, _MT4ManagerAPI.ConLiveUpdate_company_set)
    __swig_setmethods__["path"] = _MT4ManagerAPI.ConLiveUpdate_path_set
    __swig_getmethods__["path"] = _MT4ManagerAPI.ConLiveUpdate_path_get
    if _newclass:
        path = _swig_property(_MT4ManagerAPI.ConLiveUpdate_path_get, _MT4ManagerAPI.ConLiveUpdate_path_set)
    __swig_setmethods__["version"] = _MT4ManagerAPI.ConLiveUpdate_version_set
    __swig_getmethods__["version"] = _MT4ManagerAPI.ConLiveUpdate_version_get
    if _newclass:
        version = _swig_property(_MT4ManagerAPI.ConLiveUpdate_version_get, _MT4ManagerAPI.ConLiveUpdate_version_set)
    __swig_setmethods__["build"] = _MT4ManagerAPI.ConLiveUpdate_build_set
    __swig_getmethods__["build"] = _MT4ManagerAPI.ConLiveUpdate_build_get
    if _newclass:
        build = _swig_property(_MT4ManagerAPI.ConLiveUpdate_build_get, _MT4ManagerAPI.ConLiveUpdate_build_set)
    __swig_setmethods__["maxconnect"] = _MT4ManagerAPI.ConLiveUpdate_maxconnect_set
    __swig_getmethods__["maxconnect"] = _MT4ManagerAPI.ConLiveUpdate_maxconnect_get
    if _newclass:
        maxconnect = _swig_property(_MT4ManagerAPI.ConLiveUpdate_maxconnect_get, _MT4ManagerAPI.ConLiveUpdate_maxconnect_set)
    __swig_setmethods__["connections"] = _MT4ManagerAPI.ConLiveUpdate_connections_set
    __swig_getmethods__["connections"] = _MT4ManagerAPI.ConLiveUpdate_connections_get
    if _newclass:
        connections = _swig_property(_MT4ManagerAPI.ConLiveUpdate_connections_get, _MT4ManagerAPI.ConLiveUpdate_connections_set)
    __swig_setmethods__["type"] = _MT4ManagerAPI.ConLiveUpdate_type_set
    __swig_getmethods__["type"] = _MT4ManagerAPI.ConLiveUpdate_type_get
    if _newclass:
        type = _swig_property(_MT4ManagerAPI.ConLiveUpdate_type_get, _MT4ManagerAPI.ConLiveUpdate_type_set)
    __swig_setmethods__["enable"] = _MT4ManagerAPI.ConLiveUpdate_enable_set
    __swig_getmethods__["enable"] = _MT4ManagerAPI.ConLiveUpdate_enable_get
    if _newclass:
        enable = _swig_property(_MT4ManagerAPI.ConLiveUpdate_enable_get, _MT4ManagerAPI.ConLiveUpdate_enable_set)
    __swig_setmethods__["totalfiles"] = _MT4ManagerAPI.ConLiveUpdate_totalfiles_set
    __swig_getmethods__["totalfiles"] = _MT4ManagerAPI.ConLiveUpdate_totalfiles_get
    if _newclass:
        totalfiles = _swig_property(_MT4ManagerAPI.ConLiveUpdate_totalfiles_get, _MT4ManagerAPI.ConLiveUpdate_totalfiles_set)
    __swig_setmethods__["files"] = _MT4ManagerAPI.ConLiveUpdate_files_set
    __swig_getmethods__["files"] = _MT4ManagerAPI.ConLiveUpdate_files_get
    if _newclass:
        files = _swig_property(_MT4ManagerAPI.ConLiveUpdate_files_get, _MT4ManagerAPI.ConLiveUpdate_files_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConLiveUpdate_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConLiveUpdate_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConLiveUpdate_reserved_get, _MT4ManagerAPI.ConLiveUpdate_reserved_set)
    __swig_setmethods__["next"] = _MT4ManagerAPI.ConLiveUpdate_next_set
    __swig_getmethods__["next"] = _MT4ManagerAPI.ConLiveUpdate_next_get
    if _newclass:
        next = _swig_property(_MT4ManagerAPI.ConLiveUpdate_next_get, _MT4ManagerAPI.ConLiveUpdate_next_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConLiveUpdate()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConLiveUpdate
    __del__ = lambda self: None
ConLiveUpdate_swigregister = _MT4ManagerAPI.ConLiveUpdate_swigregister
ConLiveUpdate_swigregister(ConLiveUpdate)

LIVE_UPDATE_CLIENT = _MT4ManagerAPI.LIVE_UPDATE_CLIENT
LIVE_UPDATE_MANAGER = _MT4ManagerAPI.LIVE_UPDATE_MANAGER
LIVE_UPDATE_ADMIN = _MT4ManagerAPI.LIVE_UPDATE_ADMIN
LIVE_UPDATE_DATACENTER = _MT4ManagerAPI.LIVE_UPDATE_DATACENTER
LIVE_UPDATE_CLIENT_PPC2002 = _MT4ManagerAPI.LIVE_UPDATE_CLIENT_PPC2002
LIVE_UPDATE_CLIENT_PPC2003 = _MT4ManagerAPI.LIVE_UPDATE_CLIENT_PPC2003
LIVE_UPDATE_MULTI = _MT4ManagerAPI.LIVE_UPDATE_MULTI
LIVE_UPDATE_WD = _MT4ManagerAPI.LIVE_UPDATE_WD
LIVE_UPDATE_CLIENT_PHONE = _MT4ManagerAPI.LIVE_UPDATE_CLIENT_PHONE
LIVE_UPDATE_LAST = _MT4ManagerAPI.LIVE_UPDATE_LAST
class ConManagerSec(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConManagerSec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConManagerSec, name)
    __repr__ = _swig_repr
    __swig_setmethods__["internal"] = _MT4ManagerAPI.ConManagerSec_internal_set
    __swig_getmethods__["internal"] = _MT4ManagerAPI.ConManagerSec_internal_get
    if _newclass:
        internal = _swig_property(_MT4ManagerAPI.ConManagerSec_internal_get, _MT4ManagerAPI.ConManagerSec_internal_set)
    __swig_setmethods__["enable"] = _MT4ManagerAPI.ConManagerSec_enable_set
    __swig_getmethods__["enable"] = _MT4ManagerAPI.ConManagerSec_enable_get
    if _newclass:
        enable = _swig_property(_MT4ManagerAPI.ConManagerSec_enable_get, _MT4ManagerAPI.ConManagerSec_enable_set)
    __swig_setmethods__["minimum_lots"] = _MT4ManagerAPI.ConManagerSec_minimum_lots_set
    __swig_getmethods__["minimum_lots"] = _MT4ManagerAPI.ConManagerSec_minimum_lots_get
    if _newclass:
        minimum_lots = _swig_property(_MT4ManagerAPI.ConManagerSec_minimum_lots_get, _MT4ManagerAPI.ConManagerSec_minimum_lots_set)
    __swig_setmethods__["maximum_lots"] = _MT4ManagerAPI.ConManagerSec_maximum_lots_set
    __swig_getmethods__["maximum_lots"] = _MT4ManagerAPI.ConManagerSec_maximum_lots_get
    if _newclass:
        maximum_lots = _swig_property(_MT4ManagerAPI.ConManagerSec_maximum_lots_get, _MT4ManagerAPI.ConManagerSec_maximum_lots_set)
    __swig_setmethods__["unused"] = _MT4ManagerAPI.ConManagerSec_unused_set
    __swig_getmethods__["unused"] = _MT4ManagerAPI.ConManagerSec_unused_get
    if _newclass:
        unused = _swig_property(_MT4ManagerAPI.ConManagerSec_unused_get, _MT4ManagerAPI.ConManagerSec_unused_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConManagerSec()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConManagerSec
    __del__ = lambda self: None
ConManagerSec_swigregister = _MT4ManagerAPI.ConManagerSec_swigregister
ConManagerSec_swigregister(ConManagerSec)

class ConManager(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConManager, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConManager, name)
    __repr__ = _swig_repr
    __swig_setmethods__["login"] = _MT4ManagerAPI.ConManager_login_set
    __swig_getmethods__["login"] = _MT4ManagerAPI.ConManager_login_get
    if _newclass:
        login = _swig_property(_MT4ManagerAPI.ConManager_login_get, _MT4ManagerAPI.ConManager_login_set)
    __swig_setmethods__["manager"] = _MT4ManagerAPI.ConManager_manager_set
    __swig_getmethods__["manager"] = _MT4ManagerAPI.ConManager_manager_get
    if _newclass:
        manager = _swig_property(_MT4ManagerAPI.ConManager_manager_get, _MT4ManagerAPI.ConManager_manager_set)
    __swig_setmethods__["money"] = _MT4ManagerAPI.ConManager_money_set
    __swig_getmethods__["money"] = _MT4ManagerAPI.ConManager_money_get
    if _newclass:
        money = _swig_property(_MT4ManagerAPI.ConManager_money_get, _MT4ManagerAPI.ConManager_money_set)
    __swig_setmethods__["online"] = _MT4ManagerAPI.ConManager_online_set
    __swig_getmethods__["online"] = _MT4ManagerAPI.ConManager_online_get
    if _newclass:
        online = _swig_property(_MT4ManagerAPI.ConManager_online_get, _MT4ManagerAPI.ConManager_online_set)
    __swig_setmethods__["riskman"] = _MT4ManagerAPI.ConManager_riskman_set
    __swig_getmethods__["riskman"] = _MT4ManagerAPI.ConManager_riskman_get
    if _newclass:
        riskman = _swig_property(_MT4ManagerAPI.ConManager_riskman_get, _MT4ManagerAPI.ConManager_riskman_set)
    __swig_setmethods__["broker"] = _MT4ManagerAPI.ConManager_broker_set
    __swig_getmethods__["broker"] = _MT4ManagerAPI.ConManager_broker_get
    if _newclass:
        broker = _swig_property(_MT4ManagerAPI.ConManager_broker_get, _MT4ManagerAPI.ConManager_broker_set)
    __swig_setmethods__["admin"] = _MT4ManagerAPI.ConManager_admin_set
    __swig_getmethods__["admin"] = _MT4ManagerAPI.ConManager_admin_get
    if _newclass:
        admin = _swig_property(_MT4ManagerAPI.ConManager_admin_get, _MT4ManagerAPI.ConManager_admin_set)
    __swig_setmethods__["logs"] = _MT4ManagerAPI.ConManager_logs_set
    __swig_getmethods__["logs"] = _MT4ManagerAPI.ConManager_logs_get
    if _newclass:
        logs = _swig_property(_MT4ManagerAPI.ConManager_logs_get, _MT4ManagerAPI.ConManager_logs_set)
    __swig_setmethods__["reports"] = _MT4ManagerAPI.ConManager_reports_set
    __swig_getmethods__["reports"] = _MT4ManagerAPI.ConManager_reports_get
    if _newclass:
        reports = _swig_property(_MT4ManagerAPI.ConManager_reports_get, _MT4ManagerAPI.ConManager_reports_set)
    __swig_setmethods__["trades"] = _MT4ManagerAPI.ConManager_trades_set
    __swig_getmethods__["trades"] = _MT4ManagerAPI.ConManager_trades_get
    if _newclass:
        trades = _swig_property(_MT4ManagerAPI.ConManager_trades_get, _MT4ManagerAPI.ConManager_trades_set)
    __swig_setmethods__["market_watch"] = _MT4ManagerAPI.ConManager_market_watch_set
    __swig_getmethods__["market_watch"] = _MT4ManagerAPI.ConManager_market_watch_get
    if _newclass:
        market_watch = _swig_property(_MT4ManagerAPI.ConManager_market_watch_get, _MT4ManagerAPI.ConManager_market_watch_set)
    __swig_setmethods__["email"] = _MT4ManagerAPI.ConManager_email_set
    __swig_getmethods__["email"] = _MT4ManagerAPI.ConManager_email_get
    if _newclass:
        email = _swig_property(_MT4ManagerAPI.ConManager_email_get, _MT4ManagerAPI.ConManager_email_set)
    __swig_setmethods__["user_details"] = _MT4ManagerAPI.ConManager_user_details_set
    __swig_getmethods__["user_details"] = _MT4ManagerAPI.ConManager_user_details_get
    if _newclass:
        user_details = _swig_property(_MT4ManagerAPI.ConManager_user_details_get, _MT4ManagerAPI.ConManager_user_details_set)
    __swig_setmethods__["see_trades"] = _MT4ManagerAPI.ConManager_see_trades_set
    __swig_getmethods__["see_trades"] = _MT4ManagerAPI.ConManager_see_trades_get
    if _newclass:
        see_trades = _swig_property(_MT4ManagerAPI.ConManager_see_trades_get, _MT4ManagerAPI.ConManager_see_trades_set)
    __swig_setmethods__["news"] = _MT4ManagerAPI.ConManager_news_set
    __swig_getmethods__["news"] = _MT4ManagerAPI.ConManager_news_get
    if _newclass:
        news = _swig_property(_MT4ManagerAPI.ConManager_news_get, _MT4ManagerAPI.ConManager_news_set)
    __swig_setmethods__["plugins"] = _MT4ManagerAPI.ConManager_plugins_set
    __swig_getmethods__["plugins"] = _MT4ManagerAPI.ConManager_plugins_get
    if _newclass:
        plugins = _swig_property(_MT4ManagerAPI.ConManager_plugins_get, _MT4ManagerAPI.ConManager_plugins_set)
    __swig_setmethods__["server_reports"] = _MT4ManagerAPI.ConManager_server_reports_set
    __swig_getmethods__["server_reports"] = _MT4ManagerAPI.ConManager_server_reports_get
    if _newclass:
        server_reports = _swig_property(_MT4ManagerAPI.ConManager_server_reports_get, _MT4ManagerAPI.ConManager_server_reports_set)
    __swig_setmethods__["techsupport"] = _MT4ManagerAPI.ConManager_techsupport_set
    __swig_getmethods__["techsupport"] = _MT4ManagerAPI.ConManager_techsupport_get
    if _newclass:
        techsupport = _swig_property(_MT4ManagerAPI.ConManager_techsupport_get, _MT4ManagerAPI.ConManager_techsupport_set)
    __swig_setmethods__["unused"] = _MT4ManagerAPI.ConManager_unused_set
    __swig_getmethods__["unused"] = _MT4ManagerAPI.ConManager_unused_get
    if _newclass:
        unused = _swig_property(_MT4ManagerAPI.ConManager_unused_get, _MT4ManagerAPI.ConManager_unused_set)
    __swig_setmethods__["ipfilter"] = _MT4ManagerAPI.ConManager_ipfilter_set
    __swig_getmethods__["ipfilter"] = _MT4ManagerAPI.ConManager_ipfilter_get
    if _newclass:
        ipfilter = _swig_property(_MT4ManagerAPI.ConManager_ipfilter_get, _MT4ManagerAPI.ConManager_ipfilter_set)
    __swig_setmethods__["ip_from"] = _MT4ManagerAPI.ConManager_ip_from_set
    __swig_getmethods__["ip_from"] = _MT4ManagerAPI.ConManager_ip_from_get
    if _newclass:
        ip_from = _swig_property(_MT4ManagerAPI.ConManager_ip_from_get, _MT4ManagerAPI.ConManager_ip_from_set)
    __swig_setmethods__["ip_to"] = _MT4ManagerAPI.ConManager_ip_to_set
    __swig_getmethods__["ip_to"] = _MT4ManagerAPI.ConManager_ip_to_get
    if _newclass:
        ip_to = _swig_property(_MT4ManagerAPI.ConManager_ip_to_get, _MT4ManagerAPI.ConManager_ip_to_set)
    __swig_setmethods__["mailbox"] = _MT4ManagerAPI.ConManager_mailbox_set
    __swig_getmethods__["mailbox"] = _MT4ManagerAPI.ConManager_mailbox_get
    if _newclass:
        mailbox = _swig_property(_MT4ManagerAPI.ConManager_mailbox_get, _MT4ManagerAPI.ConManager_mailbox_set)
    __swig_setmethods__["groups"] = _MT4ManagerAPI.ConManager_groups_set
    __swig_getmethods__["groups"] = _MT4ManagerAPI.ConManager_groups_get
    if _newclass:
        groups = _swig_property(_MT4ManagerAPI.ConManager_groups_get, _MT4ManagerAPI.ConManager_groups_set)
    __swig_setmethods__["secgroups"] = _MT4ManagerAPI.ConManager_secgroups_set
    __swig_getmethods__["secgroups"] = _MT4ManagerAPI.ConManager_secgroups_get
    if _newclass:
        secgroups = _swig_property(_MT4ManagerAPI.ConManager_secgroups_get, _MT4ManagerAPI.ConManager_secgroups_set)
    __swig_setmethods__["exp_time"] = _MT4ManagerAPI.ConManager_exp_time_set
    __swig_getmethods__["exp_time"] = _MT4ManagerAPI.ConManager_exp_time_get
    if _newclass:
        exp_time = _swig_property(_MT4ManagerAPI.ConManager_exp_time_get, _MT4ManagerAPI.ConManager_exp_time_set)
    __swig_setmethods__["name"] = _MT4ManagerAPI.ConManager_name_set
    __swig_getmethods__["name"] = _MT4ManagerAPI.ConManager_name_get
    if _newclass:
        name = _swig_property(_MT4ManagerAPI.ConManager_name_get, _MT4ManagerAPI.ConManager_name_set)
    __swig_setmethods__["info_depth"] = _MT4ManagerAPI.ConManager_info_depth_set
    __swig_getmethods__["info_depth"] = _MT4ManagerAPI.ConManager_info_depth_get
    if _newclass:
        info_depth = _swig_property(_MT4ManagerAPI.ConManager_info_depth_get, _MT4ManagerAPI.ConManager_info_depth_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConManager_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConManager_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConManager_reserved_get, _MT4ManagerAPI.ConManager_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConManager()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConManager
    __del__ = lambda self: None
ConManager_swigregister = _MT4ManagerAPI.ConManager_swigregister
ConManager_swigregister(ConManager)

class ConSession(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConSession, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConSession, name)
    __repr__ = _swig_repr
    __swig_setmethods__["open_hour"] = _MT4ManagerAPI.ConSession_open_hour_set
    __swig_getmethods__["open_hour"] = _MT4ManagerAPI.ConSession_open_hour_get
    if _newclass:
        open_hour = _swig_property(_MT4ManagerAPI.ConSession_open_hour_get, _MT4ManagerAPI.ConSession_open_hour_set)
    __swig_setmethods__["open_min"] = _MT4ManagerAPI.ConSession_open_min_set
    __swig_getmethods__["open_min"] = _MT4ManagerAPI.ConSession_open_min_get
    if _newclass:
        open_min = _swig_property(_MT4ManagerAPI.ConSession_open_min_get, _MT4ManagerAPI.ConSession_open_min_set)
    __swig_setmethods__["close_hour"] = _MT4ManagerAPI.ConSession_close_hour_set
    __swig_getmethods__["close_hour"] = _MT4ManagerAPI.ConSession_close_hour_get
    if _newclass:
        close_hour = _swig_property(_MT4ManagerAPI.ConSession_close_hour_get, _MT4ManagerAPI.ConSession_close_hour_set)
    __swig_setmethods__["close_min"] = _MT4ManagerAPI.ConSession_close_min_set
    __swig_getmethods__["close_min"] = _MT4ManagerAPI.ConSession_close_min_get
    if _newclass:
        close_min = _swig_property(_MT4ManagerAPI.ConSession_close_min_get, _MT4ManagerAPI.ConSession_close_min_set)
    __swig_setmethods__["open"] = _MT4ManagerAPI.ConSession_open_set
    __swig_getmethods__["open"] = _MT4ManagerAPI.ConSession_open_get
    if _newclass:
        open = _swig_property(_MT4ManagerAPI.ConSession_open_get, _MT4ManagerAPI.ConSession_open_set)
    __swig_setmethods__["close"] = _MT4ManagerAPI.ConSession_close_set
    __swig_getmethods__["close"] = _MT4ManagerAPI.ConSession_close_get
    if _newclass:
        close = _swig_property(_MT4ManagerAPI.ConSession_close_get, _MT4ManagerAPI.ConSession_close_set)
    __swig_setmethods__["align"] = _MT4ManagerAPI.ConSession_align_set
    __swig_getmethods__["align"] = _MT4ManagerAPI.ConSession_align_get
    if _newclass:
        align = _swig_property(_MT4ManagerAPI.ConSession_align_get, _MT4ManagerAPI.ConSession_align_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConSession()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConSession
    __del__ = lambda self: None
ConSession_swigregister = _MT4ManagerAPI.ConSession_swigregister
ConSession_swigregister(ConSession)

class ConSessions(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConSessions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConSessions, name)
    __repr__ = _swig_repr
    __swig_setmethods__["quote"] = _MT4ManagerAPI.ConSessions_quote_set
    __swig_getmethods__["quote"] = _MT4ManagerAPI.ConSessions_quote_get
    if _newclass:
        quote = _swig_property(_MT4ManagerAPI.ConSessions_quote_get, _MT4ManagerAPI.ConSessions_quote_set)
    __swig_setmethods__["trade"] = _MT4ManagerAPI.ConSessions_trade_set
    __swig_getmethods__["trade"] = _MT4ManagerAPI.ConSessions_trade_get
    if _newclass:
        trade = _swig_property(_MT4ManagerAPI.ConSessions_trade_get, _MT4ManagerAPI.ConSessions_trade_set)
    __swig_setmethods__["quote_overnight"] = _MT4ManagerAPI.ConSessions_quote_overnight_set
    __swig_getmethods__["quote_overnight"] = _MT4ManagerAPI.ConSessions_quote_overnight_get
    if _newclass:
        quote_overnight = _swig_property(_MT4ManagerAPI.ConSessions_quote_overnight_get, _MT4ManagerAPI.ConSessions_quote_overnight_set)
    __swig_setmethods__["trade_overnight"] = _MT4ManagerAPI.ConSessions_trade_overnight_set
    __swig_getmethods__["trade_overnight"] = _MT4ManagerAPI.ConSessions_trade_overnight_get
    if _newclass:
        trade_overnight = _swig_property(_MT4ManagerAPI.ConSessions_trade_overnight_get, _MT4ManagerAPI.ConSessions_trade_overnight_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConSessions_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConSessions_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConSessions_reserved_get, _MT4ManagerAPI.ConSessions_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConSessions()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConSessions
    __del__ = lambda self: None
ConSessions_swigregister = _MT4ManagerAPI.ConSessions_swigregister
ConSessions_swigregister(ConSessions)

MAX_SYMBOLS = _MT4ManagerAPI.MAX_SYMBOLS
class ConSymbol(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConSymbol, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConSymbol, name)
    __repr__ = _swig_repr
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.ConSymbol_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.ConSymbol_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.ConSymbol_symbol_get, _MT4ManagerAPI.ConSymbol_symbol_set)
    __swig_setmethods__["description"] = _MT4ManagerAPI.ConSymbol_description_set
    __swig_getmethods__["description"] = _MT4ManagerAPI.ConSymbol_description_get
    if _newclass:
        description = _swig_property(_MT4ManagerAPI.ConSymbol_description_get, _MT4ManagerAPI.ConSymbol_description_set)
    __swig_setmethods__["source"] = _MT4ManagerAPI.ConSymbol_source_set
    __swig_getmethods__["source"] = _MT4ManagerAPI.ConSymbol_source_get
    if _newclass:
        source = _swig_property(_MT4ManagerAPI.ConSymbol_source_get, _MT4ManagerAPI.ConSymbol_source_set)
    __swig_setmethods__["currency"] = _MT4ManagerAPI.ConSymbol_currency_set
    __swig_getmethods__["currency"] = _MT4ManagerAPI.ConSymbol_currency_get
    if _newclass:
        currency = _swig_property(_MT4ManagerAPI.ConSymbol_currency_get, _MT4ManagerAPI.ConSymbol_currency_set)
    __swig_setmethods__["type"] = _MT4ManagerAPI.ConSymbol_type_set
    __swig_getmethods__["type"] = _MT4ManagerAPI.ConSymbol_type_get
    if _newclass:
        type = _swig_property(_MT4ManagerAPI.ConSymbol_type_get, _MT4ManagerAPI.ConSymbol_type_set)
    __swig_setmethods__["digits"] = _MT4ManagerAPI.ConSymbol_digits_set
    __swig_getmethods__["digits"] = _MT4ManagerAPI.ConSymbol_digits_get
    if _newclass:
        digits = _swig_property(_MT4ManagerAPI.ConSymbol_digits_get, _MT4ManagerAPI.ConSymbol_digits_set)
    __swig_setmethods__["trade"] = _MT4ManagerAPI.ConSymbol_trade_set
    __swig_getmethods__["trade"] = _MT4ManagerAPI.ConSymbol_trade_get
    if _newclass:
        trade = _swig_property(_MT4ManagerAPI.ConSymbol_trade_get, _MT4ManagerAPI.ConSymbol_trade_set)
    __swig_setmethods__["background_color"] = _MT4ManagerAPI.ConSymbol_background_color_set
    __swig_getmethods__["background_color"] = _MT4ManagerAPI.ConSymbol_background_color_get
    if _newclass:
        background_color = _swig_property(_MT4ManagerAPI.ConSymbol_background_color_get, _MT4ManagerAPI.ConSymbol_background_color_set)
    __swig_setmethods__["count"] = _MT4ManagerAPI.ConSymbol_count_set
    __swig_getmethods__["count"] = _MT4ManagerAPI.ConSymbol_count_get
    if _newclass:
        count = _swig_property(_MT4ManagerAPI.ConSymbol_count_get, _MT4ManagerAPI.ConSymbol_count_set)
    __swig_setmethods__["count_original"] = _MT4ManagerAPI.ConSymbol_count_original_set
    __swig_getmethods__["count_original"] = _MT4ManagerAPI.ConSymbol_count_original_get
    if _newclass:
        count_original = _swig_property(_MT4ManagerAPI.ConSymbol_count_original_get, _MT4ManagerAPI.ConSymbol_count_original_set)
    __swig_setmethods__["external_unused"] = _MT4ManagerAPI.ConSymbol_external_unused_set
    __swig_getmethods__["external_unused"] = _MT4ManagerAPI.ConSymbol_external_unused_get
    if _newclass:
        external_unused = _swig_property(_MT4ManagerAPI.ConSymbol_external_unused_get, _MT4ManagerAPI.ConSymbol_external_unused_set)
    __swig_setmethods__["realtime"] = _MT4ManagerAPI.ConSymbol_realtime_set
    __swig_getmethods__["realtime"] = _MT4ManagerAPI.ConSymbol_realtime_get
    if _newclass:
        realtime = _swig_property(_MT4ManagerAPI.ConSymbol_realtime_get, _MT4ManagerAPI.ConSymbol_realtime_set)
    __swig_setmethods__["starting"] = _MT4ManagerAPI.ConSymbol_starting_set
    __swig_getmethods__["starting"] = _MT4ManagerAPI.ConSymbol_starting_get
    if _newclass:
        starting = _swig_property(_MT4ManagerAPI.ConSymbol_starting_get, _MT4ManagerAPI.ConSymbol_starting_set)
    __swig_setmethods__["expiration"] = _MT4ManagerAPI.ConSymbol_expiration_set
    __swig_getmethods__["expiration"] = _MT4ManagerAPI.ConSymbol_expiration_get
    if _newclass:
        expiration = _swig_property(_MT4ManagerAPI.ConSymbol_expiration_get, _MT4ManagerAPI.ConSymbol_expiration_set)
    __swig_setmethods__["sessions"] = _MT4ManagerAPI.ConSymbol_sessions_set
    __swig_getmethods__["sessions"] = _MT4ManagerAPI.ConSymbol_sessions_get
    if _newclass:
        sessions = _swig_property(_MT4ManagerAPI.ConSymbol_sessions_get, _MT4ManagerAPI.ConSymbol_sessions_set)
    __swig_setmethods__["profit_mode"] = _MT4ManagerAPI.ConSymbol_profit_mode_set
    __swig_getmethods__["profit_mode"] = _MT4ManagerAPI.ConSymbol_profit_mode_get
    if _newclass:
        profit_mode = _swig_property(_MT4ManagerAPI.ConSymbol_profit_mode_get, _MT4ManagerAPI.ConSymbol_profit_mode_set)
    __swig_setmethods__["profit_reserved"] = _MT4ManagerAPI.ConSymbol_profit_reserved_set
    __swig_getmethods__["profit_reserved"] = _MT4ManagerAPI.ConSymbol_profit_reserved_get
    if _newclass:
        profit_reserved = _swig_property(_MT4ManagerAPI.ConSymbol_profit_reserved_get, _MT4ManagerAPI.ConSymbol_profit_reserved_set)
    __swig_setmethods__["filter"] = _MT4ManagerAPI.ConSymbol_filter_set
    __swig_getmethods__["filter"] = _MT4ManagerAPI.ConSymbol_filter_get
    if _newclass:
        filter = _swig_property(_MT4ManagerAPI.ConSymbol_filter_get, _MT4ManagerAPI.ConSymbol_filter_set)
    __swig_setmethods__["filter_counter"] = _MT4ManagerAPI.ConSymbol_filter_counter_set
    __swig_getmethods__["filter_counter"] = _MT4ManagerAPI.ConSymbol_filter_counter_get
    if _newclass:
        filter_counter = _swig_property(_MT4ManagerAPI.ConSymbol_filter_counter_get, _MT4ManagerAPI.ConSymbol_filter_counter_set)
    __swig_setmethods__["filter_limit"] = _MT4ManagerAPI.ConSymbol_filter_limit_set
    __swig_getmethods__["filter_limit"] = _MT4ManagerAPI.ConSymbol_filter_limit_get
    if _newclass:
        filter_limit = _swig_property(_MT4ManagerAPI.ConSymbol_filter_limit_get, _MT4ManagerAPI.ConSymbol_filter_limit_set)
    __swig_setmethods__["filter_smoothing"] = _MT4ManagerAPI.ConSymbol_filter_smoothing_set
    __swig_getmethods__["filter_smoothing"] = _MT4ManagerAPI.ConSymbol_filter_smoothing_get
    if _newclass:
        filter_smoothing = _swig_property(_MT4ManagerAPI.ConSymbol_filter_smoothing_get, _MT4ManagerAPI.ConSymbol_filter_smoothing_set)
    __swig_setmethods__["filter_reserved"] = _MT4ManagerAPI.ConSymbol_filter_reserved_set
    __swig_getmethods__["filter_reserved"] = _MT4ManagerAPI.ConSymbol_filter_reserved_get
    if _newclass:
        filter_reserved = _swig_property(_MT4ManagerAPI.ConSymbol_filter_reserved_get, _MT4ManagerAPI.ConSymbol_filter_reserved_set)
    __swig_setmethods__["logging"] = _MT4ManagerAPI.ConSymbol_logging_set
    __swig_getmethods__["logging"] = _MT4ManagerAPI.ConSymbol_logging_get
    if _newclass:
        logging = _swig_property(_MT4ManagerAPI.ConSymbol_logging_get, _MT4ManagerAPI.ConSymbol_logging_set)
    __swig_setmethods__["spread"] = _MT4ManagerAPI.ConSymbol_spread_set
    __swig_getmethods__["spread"] = _MT4ManagerAPI.ConSymbol_spread_get
    if _newclass:
        spread = _swig_property(_MT4ManagerAPI.ConSymbol_spread_get, _MT4ManagerAPI.ConSymbol_spread_set)
    __swig_setmethods__["spread_balance"] = _MT4ManagerAPI.ConSymbol_spread_balance_set
    __swig_getmethods__["spread_balance"] = _MT4ManagerAPI.ConSymbol_spread_balance_get
    if _newclass:
        spread_balance = _swig_property(_MT4ManagerAPI.ConSymbol_spread_balance_get, _MT4ManagerAPI.ConSymbol_spread_balance_set)
    __swig_setmethods__["exemode"] = _MT4ManagerAPI.ConSymbol_exemode_set
    __swig_getmethods__["exemode"] = _MT4ManagerAPI.ConSymbol_exemode_get
    if _newclass:
        exemode = _swig_property(_MT4ManagerAPI.ConSymbol_exemode_get, _MT4ManagerAPI.ConSymbol_exemode_set)
    __swig_setmethods__["swap_enable"] = _MT4ManagerAPI.ConSymbol_swap_enable_set
    __swig_getmethods__["swap_enable"] = _MT4ManagerAPI.ConSymbol_swap_enable_get
    if _newclass:
        swap_enable = _swig_property(_MT4ManagerAPI.ConSymbol_swap_enable_get, _MT4ManagerAPI.ConSymbol_swap_enable_set)
    __swig_setmethods__["swap_type"] = _MT4ManagerAPI.ConSymbol_swap_type_set
    __swig_getmethods__["swap_type"] = _MT4ManagerAPI.ConSymbol_swap_type_get
    if _newclass:
        swap_type = _swig_property(_MT4ManagerAPI.ConSymbol_swap_type_get, _MT4ManagerAPI.ConSymbol_swap_type_set)
    __swig_setmethods__["swap_long"] = _MT4ManagerAPI.ConSymbol_swap_long_set
    __swig_getmethods__["swap_long"] = _MT4ManagerAPI.ConSymbol_swap_long_get
    if _newclass:
        swap_long = _swig_property(_MT4ManagerAPI.ConSymbol_swap_long_get, _MT4ManagerAPI.ConSymbol_swap_long_set)
    __swig_setmethods__["swap_short"] = _MT4ManagerAPI.ConSymbol_swap_short_set
    __swig_getmethods__["swap_short"] = _MT4ManagerAPI.ConSymbol_swap_short_get
    if _newclass:
        swap_short = _swig_property(_MT4ManagerAPI.ConSymbol_swap_short_get, _MT4ManagerAPI.ConSymbol_swap_short_set)
    __swig_setmethods__["swap_rollover3days"] = _MT4ManagerAPI.ConSymbol_swap_rollover3days_set
    __swig_getmethods__["swap_rollover3days"] = _MT4ManagerAPI.ConSymbol_swap_rollover3days_get
    if _newclass:
        swap_rollover3days = _swig_property(_MT4ManagerAPI.ConSymbol_swap_rollover3days_get, _MT4ManagerAPI.ConSymbol_swap_rollover3days_set)
    __swig_setmethods__["contract_size"] = _MT4ManagerAPI.ConSymbol_contract_size_set
    __swig_getmethods__["contract_size"] = _MT4ManagerAPI.ConSymbol_contract_size_get
    if _newclass:
        contract_size = _swig_property(_MT4ManagerAPI.ConSymbol_contract_size_get, _MT4ManagerAPI.ConSymbol_contract_size_set)
    __swig_setmethods__["tick_value"] = _MT4ManagerAPI.ConSymbol_tick_value_set
    __swig_getmethods__["tick_value"] = _MT4ManagerAPI.ConSymbol_tick_value_get
    if _newclass:
        tick_value = _swig_property(_MT4ManagerAPI.ConSymbol_tick_value_get, _MT4ManagerAPI.ConSymbol_tick_value_set)
    __swig_setmethods__["tick_size"] = _MT4ManagerAPI.ConSymbol_tick_size_set
    __swig_getmethods__["tick_size"] = _MT4ManagerAPI.ConSymbol_tick_size_get
    if _newclass:
        tick_size = _swig_property(_MT4ManagerAPI.ConSymbol_tick_size_get, _MT4ManagerAPI.ConSymbol_tick_size_set)
    __swig_setmethods__["stops_level"] = _MT4ManagerAPI.ConSymbol_stops_level_set
    __swig_getmethods__["stops_level"] = _MT4ManagerAPI.ConSymbol_stops_level_get
    if _newclass:
        stops_level = _swig_property(_MT4ManagerAPI.ConSymbol_stops_level_get, _MT4ManagerAPI.ConSymbol_stops_level_set)
    __swig_setmethods__["gtc_pendings"] = _MT4ManagerAPI.ConSymbol_gtc_pendings_set
    __swig_getmethods__["gtc_pendings"] = _MT4ManagerAPI.ConSymbol_gtc_pendings_get
    if _newclass:
        gtc_pendings = _swig_property(_MT4ManagerAPI.ConSymbol_gtc_pendings_get, _MT4ManagerAPI.ConSymbol_gtc_pendings_set)
    __swig_setmethods__["margin_mode"] = _MT4ManagerAPI.ConSymbol_margin_mode_set
    __swig_getmethods__["margin_mode"] = _MT4ManagerAPI.ConSymbol_margin_mode_get
    if _newclass:
        margin_mode = _swig_property(_MT4ManagerAPI.ConSymbol_margin_mode_get, _MT4ManagerAPI.ConSymbol_margin_mode_set)
    __swig_setmethods__["margin_initial"] = _MT4ManagerAPI.ConSymbol_margin_initial_set
    __swig_getmethods__["margin_initial"] = _MT4ManagerAPI.ConSymbol_margin_initial_get
    if _newclass:
        margin_initial = _swig_property(_MT4ManagerAPI.ConSymbol_margin_initial_get, _MT4ManagerAPI.ConSymbol_margin_initial_set)
    __swig_setmethods__["margin_maintenance"] = _MT4ManagerAPI.ConSymbol_margin_maintenance_set
    __swig_getmethods__["margin_maintenance"] = _MT4ManagerAPI.ConSymbol_margin_maintenance_get
    if _newclass:
        margin_maintenance = _swig_property(_MT4ManagerAPI.ConSymbol_margin_maintenance_get, _MT4ManagerAPI.ConSymbol_margin_maintenance_set)
    __swig_setmethods__["margin_hedged"] = _MT4ManagerAPI.ConSymbol_margin_hedged_set
    __swig_getmethods__["margin_hedged"] = _MT4ManagerAPI.ConSymbol_margin_hedged_get
    if _newclass:
        margin_hedged = _swig_property(_MT4ManagerAPI.ConSymbol_margin_hedged_get, _MT4ManagerAPI.ConSymbol_margin_hedged_set)
    __swig_setmethods__["margin_divider"] = _MT4ManagerAPI.ConSymbol_margin_divider_set
    __swig_getmethods__["margin_divider"] = _MT4ManagerAPI.ConSymbol_margin_divider_get
    if _newclass:
        margin_divider = _swig_property(_MT4ManagerAPI.ConSymbol_margin_divider_get, _MT4ManagerAPI.ConSymbol_margin_divider_set)
    __swig_setmethods__["point"] = _MT4ManagerAPI.ConSymbol_point_set
    __swig_getmethods__["point"] = _MT4ManagerAPI.ConSymbol_point_get
    if _newclass:
        point = _swig_property(_MT4ManagerAPI.ConSymbol_point_get, _MT4ManagerAPI.ConSymbol_point_set)
    __swig_setmethods__["multiply"] = _MT4ManagerAPI.ConSymbol_multiply_set
    __swig_getmethods__["multiply"] = _MT4ManagerAPI.ConSymbol_multiply_get
    if _newclass:
        multiply = _swig_property(_MT4ManagerAPI.ConSymbol_multiply_get, _MT4ManagerAPI.ConSymbol_multiply_set)
    __swig_setmethods__["bid_tickvalue"] = _MT4ManagerAPI.ConSymbol_bid_tickvalue_set
    __swig_getmethods__["bid_tickvalue"] = _MT4ManagerAPI.ConSymbol_bid_tickvalue_get
    if _newclass:
        bid_tickvalue = _swig_property(_MT4ManagerAPI.ConSymbol_bid_tickvalue_get, _MT4ManagerAPI.ConSymbol_bid_tickvalue_set)
    __swig_setmethods__["ask_tickvalue"] = _MT4ManagerAPI.ConSymbol_ask_tickvalue_set
    __swig_getmethods__["ask_tickvalue"] = _MT4ManagerAPI.ConSymbol_ask_tickvalue_get
    if _newclass:
        ask_tickvalue = _swig_property(_MT4ManagerAPI.ConSymbol_ask_tickvalue_get, _MT4ManagerAPI.ConSymbol_ask_tickvalue_set)
    __swig_setmethods__["long_only"] = _MT4ManagerAPI.ConSymbol_long_only_set
    __swig_getmethods__["long_only"] = _MT4ManagerAPI.ConSymbol_long_only_get
    if _newclass:
        long_only = _swig_property(_MT4ManagerAPI.ConSymbol_long_only_get, _MT4ManagerAPI.ConSymbol_long_only_set)
    __swig_setmethods__["instant_max_volume"] = _MT4ManagerAPI.ConSymbol_instant_max_volume_set
    __swig_getmethods__["instant_max_volume"] = _MT4ManagerAPI.ConSymbol_instant_max_volume_get
    if _newclass:
        instant_max_volume = _swig_property(_MT4ManagerAPI.ConSymbol_instant_max_volume_get, _MT4ManagerAPI.ConSymbol_instant_max_volume_set)
    __swig_setmethods__["margin_currency"] = _MT4ManagerAPI.ConSymbol_margin_currency_set
    __swig_getmethods__["margin_currency"] = _MT4ManagerAPI.ConSymbol_margin_currency_get
    if _newclass:
        margin_currency = _swig_property(_MT4ManagerAPI.ConSymbol_margin_currency_get, _MT4ManagerAPI.ConSymbol_margin_currency_set)
    __swig_setmethods__["freeze_level"] = _MT4ManagerAPI.ConSymbol_freeze_level_set
    __swig_getmethods__["freeze_level"] = _MT4ManagerAPI.ConSymbol_freeze_level_get
    if _newclass:
        freeze_level = _swig_property(_MT4ManagerAPI.ConSymbol_freeze_level_get, _MT4ManagerAPI.ConSymbol_freeze_level_set)
    __swig_setmethods__["margin_hedged_strong"] = _MT4ManagerAPI.ConSymbol_margin_hedged_strong_set
    __swig_getmethods__["margin_hedged_strong"] = _MT4ManagerAPI.ConSymbol_margin_hedged_strong_get
    if _newclass:
        margin_hedged_strong = _swig_property(_MT4ManagerAPI.ConSymbol_margin_hedged_strong_get, _MT4ManagerAPI.ConSymbol_margin_hedged_strong_set)
    __swig_setmethods__["value_date"] = _MT4ManagerAPI.ConSymbol_value_date_set
    __swig_getmethods__["value_date"] = _MT4ManagerAPI.ConSymbol_value_date_get
    if _newclass:
        value_date = _swig_property(_MT4ManagerAPI.ConSymbol_value_date_get, _MT4ManagerAPI.ConSymbol_value_date_set)
    __swig_setmethods__["quotes_delay"] = _MT4ManagerAPI.ConSymbol_quotes_delay_set
    __swig_getmethods__["quotes_delay"] = _MT4ManagerAPI.ConSymbol_quotes_delay_get
    if _newclass:
        quotes_delay = _swig_property(_MT4ManagerAPI.ConSymbol_quotes_delay_get, _MT4ManagerAPI.ConSymbol_quotes_delay_set)
    __swig_setmethods__["swap_openprice"] = _MT4ManagerAPI.ConSymbol_swap_openprice_set
    __swig_getmethods__["swap_openprice"] = _MT4ManagerAPI.ConSymbol_swap_openprice_get
    if _newclass:
        swap_openprice = _swig_property(_MT4ManagerAPI.ConSymbol_swap_openprice_get, _MT4ManagerAPI.ConSymbol_swap_openprice_set)
    __swig_setmethods__["unused"] = _MT4ManagerAPI.ConSymbol_unused_set
    __swig_getmethods__["unused"] = _MT4ManagerAPI.ConSymbol_unused_get
    if _newclass:
        unused = _swig_property(_MT4ManagerAPI.ConSymbol_unused_get, _MT4ManagerAPI.ConSymbol_unused_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConSymbol()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConSymbol
    __del__ = lambda self: None
ConSymbol_swigregister = _MT4ManagerAPI.ConSymbol_swigregister
ConSymbol_swigregister(ConSymbol)

EXE_REQUEST = _MT4ManagerAPI.EXE_REQUEST
EXE_INSTANT = _MT4ManagerAPI.EXE_INSTANT
EXE_MARKET = _MT4ManagerAPI.EXE_MARKET
TRADE_NO = _MT4ManagerAPI.TRADE_NO
TRADE_CLOSE = _MT4ManagerAPI.TRADE_CLOSE
TRADE_FULL = _MT4ManagerAPI.TRADE_FULL
SWAP_BY_POINTS = _MT4ManagerAPI.SWAP_BY_POINTS
SWAP_BY_DOLLARS = _MT4ManagerAPI.SWAP_BY_DOLLARS
SWAP_BY_INTEREST = _MT4ManagerAPI.SWAP_BY_INTEREST
SWAP_BY_MARGIN_CURRENCY = _MT4ManagerAPI.SWAP_BY_MARGIN_CURRENCY
PROFIT_CALC_FOREX = _MT4ManagerAPI.PROFIT_CALC_FOREX
PROFIT_CALC_CFD = _MT4ManagerAPI.PROFIT_CALC_CFD
PROFIT_CALC_FUTURES = _MT4ManagerAPI.PROFIT_CALC_FUTURES
MARGIN_CALC_FOREX = _MT4ManagerAPI.MARGIN_CALC_FOREX
MARGIN_CALC_CFD = _MT4ManagerAPI.MARGIN_CALC_CFD
MARGIN_CALC_FUTURES = _MT4ManagerAPI.MARGIN_CALC_FUTURES
MARGIN_CALC_CFDINDEX = _MT4ManagerAPI.MARGIN_CALC_CFDINDEX
MARGIN_CALC_CFDLEVERAGE = _MT4ManagerAPI.MARGIN_CALC_CFDLEVERAGE
ORDERS_DAILY = _MT4ManagerAPI.ORDERS_DAILY
ORDERS_GTC = _MT4ManagerAPI.ORDERS_GTC
ORDERS_DAILY_NO_STOPS = _MT4ManagerAPI.ORDERS_DAILY_NO_STOPS
MAX_SEC_GROUP = _MT4ManagerAPI.MAX_SEC_GROUP
class ConSymbolGroup(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConSymbolGroup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConSymbolGroup, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _MT4ManagerAPI.ConSymbolGroup_name_set
    __swig_getmethods__["name"] = _MT4ManagerAPI.ConSymbolGroup_name_get
    if _newclass:
        name = _swig_property(_MT4ManagerAPI.ConSymbolGroup_name_get, _MT4ManagerAPI.ConSymbolGroup_name_set)
    __swig_setmethods__["description"] = _MT4ManagerAPI.ConSymbolGroup_description_set
    __swig_getmethods__["description"] = _MT4ManagerAPI.ConSymbolGroup_description_get
    if _newclass:
        description = _swig_property(_MT4ManagerAPI.ConSymbolGroup_description_get, _MT4ManagerAPI.ConSymbolGroup_description_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConSymbolGroup()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConSymbolGroup
    __del__ = lambda self: None
ConSymbolGroup_swigregister = _MT4ManagerAPI.ConSymbolGroup_swigregister
ConSymbolGroup_swigregister(ConSymbolGroup)

class ConSync(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConSync, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConSync, name)
    __repr__ = _swig_repr
    __swig_setmethods__["server"] = _MT4ManagerAPI.ConSync_server_set
    __swig_getmethods__["server"] = _MT4ManagerAPI.ConSync_server_get
    if _newclass:
        server = _swig_property(_MT4ManagerAPI.ConSync_server_get, _MT4ManagerAPI.ConSync_server_set)
    __swig_setmethods__["unusedport"] = _MT4ManagerAPI.ConSync_unusedport_set
    __swig_getmethods__["unusedport"] = _MT4ManagerAPI.ConSync_unusedport_get
    if _newclass:
        unusedport = _swig_property(_MT4ManagerAPI.ConSync_unusedport_get, _MT4ManagerAPI.ConSync_unusedport_set)
    __swig_setmethods__["login"] = _MT4ManagerAPI.ConSync_login_set
    __swig_getmethods__["login"] = _MT4ManagerAPI.ConSync_login_get
    if _newclass:
        login = _swig_property(_MT4ManagerAPI.ConSync_login_get, _MT4ManagerAPI.ConSync_login_set)
    __swig_setmethods__["password"] = _MT4ManagerAPI.ConSync_password_set
    __swig_getmethods__["password"] = _MT4ManagerAPI.ConSync_password_get
    if _newclass:
        password = _swig_property(_MT4ManagerAPI.ConSync_password_get, _MT4ManagerAPI.ConSync_password_set)
    __swig_setmethods__["enable"] = _MT4ManagerAPI.ConSync_enable_set
    __swig_getmethods__["enable"] = _MT4ManagerAPI.ConSync_enable_get
    if _newclass:
        enable = _swig_property(_MT4ManagerAPI.ConSync_enable_get, _MT4ManagerAPI.ConSync_enable_set)
    __swig_setmethods__["mode"] = _MT4ManagerAPI.ConSync_mode_set
    __swig_getmethods__["mode"] = _MT4ManagerAPI.ConSync_mode_get
    if _newclass:
        mode = _swig_property(_MT4ManagerAPI.ConSync_mode_get, _MT4ManagerAPI.ConSync_mode_set)
    __swig_setmethods__["_from"] = _MT4ManagerAPI.ConSync__from_set
    __swig_getmethods__["_from"] = _MT4ManagerAPI.ConSync__from_get
    if _newclass:
        _from = _swig_property(_MT4ManagerAPI.ConSync__from_get, _MT4ManagerAPI.ConSync__from_set)
    __swig_setmethods__["to"] = _MT4ManagerAPI.ConSync_to_set
    __swig_getmethods__["to"] = _MT4ManagerAPI.ConSync_to_get
    if _newclass:
        to = _swig_property(_MT4ManagerAPI.ConSync_to_get, _MT4ManagerAPI.ConSync_to_set)
    __swig_setmethods__["securities"] = _MT4ManagerAPI.ConSync_securities_set
    __swig_getmethods__["securities"] = _MT4ManagerAPI.ConSync_securities_get
    if _newclass:
        securities = _swig_property(_MT4ManagerAPI.ConSync_securities_get, _MT4ManagerAPI.ConSync_securities_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConSync_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConSync_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConSync_reserved_get, _MT4ManagerAPI.ConSync_reserved_set)
    __swig_setmethods__["next"] = _MT4ManagerAPI.ConSync_next_set
    __swig_getmethods__["next"] = _MT4ManagerAPI.ConSync_next_get
    if _newclass:
        next = _swig_property(_MT4ManagerAPI.ConSync_next_get, _MT4ManagerAPI.ConSync_next_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConSync()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConSync
    __del__ = lambda self: None
ConSync_swigregister = _MT4ManagerAPI.ConSync_swigregister
ConSync_swigregister(ConSync)

HB_ADD = _MT4ManagerAPI.HB_ADD
HB_UPDATE = _MT4ManagerAPI.HB_UPDATE
HB_INSERT = _MT4ManagerAPI.HB_INSERT
HB_DELETE = _MT4ManagerAPI.HB_DELETE
HB_LAST = _MT4ManagerAPI.HB_LAST
class PluginInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PluginInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PluginInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _MT4ManagerAPI.PluginInfo_name_set
    __swig_getmethods__["name"] = _MT4ManagerAPI.PluginInfo_name_get
    if _newclass:
        name = _swig_property(_MT4ManagerAPI.PluginInfo_name_get, _MT4ManagerAPI.PluginInfo_name_set)
    __swig_setmethods__["version"] = _MT4ManagerAPI.PluginInfo_version_set
    __swig_getmethods__["version"] = _MT4ManagerAPI.PluginInfo_version_get
    if _newclass:
        version = _swig_property(_MT4ManagerAPI.PluginInfo_version_get, _MT4ManagerAPI.PluginInfo_version_set)
    __swig_setmethods__["copyright"] = _MT4ManagerAPI.PluginInfo_copyright_set
    __swig_getmethods__["copyright"] = _MT4ManagerAPI.PluginInfo_copyright_get
    if _newclass:
        copyright = _swig_property(_MT4ManagerAPI.PluginInfo_copyright_get, _MT4ManagerAPI.PluginInfo_copyright_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.PluginInfo_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.PluginInfo_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.PluginInfo_reserved_get, _MT4ManagerAPI.PluginInfo_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_PluginInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_PluginInfo
    __del__ = lambda self: None
PluginInfo_swigregister = _MT4ManagerAPI.PluginInfo_swigregister
PluginInfo_swigregister(PluginInfo)

class PluginCfg(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PluginCfg, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PluginCfg, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _MT4ManagerAPI.PluginCfg_name_set
    __swig_getmethods__["name"] = _MT4ManagerAPI.PluginCfg_name_get
    if _newclass:
        name = _swig_property(_MT4ManagerAPI.PluginCfg_name_get, _MT4ManagerAPI.PluginCfg_name_set)
    __swig_setmethods__["value"] = _MT4ManagerAPI.PluginCfg_value_set
    __swig_getmethods__["value"] = _MT4ManagerAPI.PluginCfg_value_get
    if _newclass:
        value = _swig_property(_MT4ManagerAPI.PluginCfg_value_get, _MT4ManagerAPI.PluginCfg_value_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.PluginCfg_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.PluginCfg_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.PluginCfg_reserved_get, _MT4ManagerAPI.PluginCfg_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_PluginCfg()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_PluginCfg
    __del__ = lambda self: None
PluginCfg_swigregister = _MT4ManagerAPI.PluginCfg_swigregister
PluginCfg_swigregister(PluginCfg)

class ConPlugin(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConPlugin, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConPlugin, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file"] = _MT4ManagerAPI.ConPlugin_file_set
    __swig_getmethods__["file"] = _MT4ManagerAPI.ConPlugin_file_get
    if _newclass:
        file = _swig_property(_MT4ManagerAPI.ConPlugin_file_get, _MT4ManagerAPI.ConPlugin_file_set)
    __swig_setmethods__["info"] = _MT4ManagerAPI.ConPlugin_info_set
    __swig_getmethods__["info"] = _MT4ManagerAPI.ConPlugin_info_get
    if _newclass:
        info = _swig_property(_MT4ManagerAPI.ConPlugin_info_get, _MT4ManagerAPI.ConPlugin_info_set)
    __swig_setmethods__["enabled"] = _MT4ManagerAPI.ConPlugin_enabled_set
    __swig_getmethods__["enabled"] = _MT4ManagerAPI.ConPlugin_enabled_get
    if _newclass:
        enabled = _swig_property(_MT4ManagerAPI.ConPlugin_enabled_get, _MT4ManagerAPI.ConPlugin_enabled_set)
    __swig_setmethods__["configurable"] = _MT4ManagerAPI.ConPlugin_configurable_set
    __swig_getmethods__["configurable"] = _MT4ManagerAPI.ConPlugin_configurable_get
    if _newclass:
        configurable = _swig_property(_MT4ManagerAPI.ConPlugin_configurable_get, _MT4ManagerAPI.ConPlugin_configurable_set)
    __swig_setmethods__["manager_access"] = _MT4ManagerAPI.ConPlugin_manager_access_set
    __swig_getmethods__["manager_access"] = _MT4ManagerAPI.ConPlugin_manager_access_get
    if _newclass:
        manager_access = _swig_property(_MT4ManagerAPI.ConPlugin_manager_access_get, _MT4ManagerAPI.ConPlugin_manager_access_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.ConPlugin_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.ConPlugin_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.ConPlugin_reserved_get, _MT4ManagerAPI.ConPlugin_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConPlugin()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConPlugin
    __del__ = lambda self: None
ConPlugin_swigregister = _MT4ManagerAPI.ConPlugin_swigregister
ConPlugin_swigregister(ConPlugin)

class ConPluginParam(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConPluginParam, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConPluginParam, name)
    __repr__ = _swig_repr
    __swig_setmethods__["plugin"] = _MT4ManagerAPI.ConPluginParam_plugin_set
    __swig_getmethods__["plugin"] = _MT4ManagerAPI.ConPluginParam_plugin_get
    if _newclass:
        plugin = _swig_property(_MT4ManagerAPI.ConPluginParam_plugin_get, _MT4ManagerAPI.ConPluginParam_plugin_set)
    __swig_setmethods__["params"] = _MT4ManagerAPI.ConPluginParam_params_set
    __swig_getmethods__["params"] = _MT4ManagerAPI.ConPluginParam_params_get
    if _newclass:
        params = _swig_property(_MT4ManagerAPI.ConPluginParam_params_get, _MT4ManagerAPI.ConPluginParam_params_set)
    __swig_setmethods__["total"] = _MT4ManagerAPI.ConPluginParam_total_set
    __swig_getmethods__["total"] = _MT4ManagerAPI.ConPluginParam_total_get
    if _newclass:
        total = _swig_property(_MT4ManagerAPI.ConPluginParam_total_get, _MT4ManagerAPI.ConPluginParam_total_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ConPluginParam()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ConPluginParam
    __del__ = lambda self: None
ConPluginParam_swigregister = _MT4ManagerAPI.ConPluginParam_swigregister
ConPluginParam_swigregister(ConPluginParam)

RET_OK = _MT4ManagerAPI.RET_OK
RET_OK_NONE = _MT4ManagerAPI.RET_OK_NONE
RET_ERROR = _MT4ManagerAPI.RET_ERROR
RET_INVALID_DATA = _MT4ManagerAPI.RET_INVALID_DATA
RET_TECH_PROBLEM = _MT4ManagerAPI.RET_TECH_PROBLEM
RET_OLD_VERSION = _MT4ManagerAPI.RET_OLD_VERSION
RET_NO_CONNECT = _MT4ManagerAPI.RET_NO_CONNECT
RET_NOT_ENOUGH_RIGHTS = _MT4ManagerAPI.RET_NOT_ENOUGH_RIGHTS
RET_TOO_FREQUENT = _MT4ManagerAPI.RET_TOO_FREQUENT
RET_MALFUNCTION = _MT4ManagerAPI.RET_MALFUNCTION
RET_GENERATE_KEY = _MT4ManagerAPI.RET_GENERATE_KEY
RET_SECURITY_SESSION = _MT4ManagerAPI.RET_SECURITY_SESSION
RET_ACCOUNT_DISABLED = _MT4ManagerAPI.RET_ACCOUNT_DISABLED
RET_BAD_ACCOUNT_INFO = _MT4ManagerAPI.RET_BAD_ACCOUNT_INFO
RET_PUBLIC_KEY_MISSING = _MT4ManagerAPI.RET_PUBLIC_KEY_MISSING
RET_TRADE_TIMEOUT = _MT4ManagerAPI.RET_TRADE_TIMEOUT
RET_TRADE_BAD_PRICES = _MT4ManagerAPI.RET_TRADE_BAD_PRICES
RET_TRADE_BAD_STOPS = _MT4ManagerAPI.RET_TRADE_BAD_STOPS
RET_TRADE_BAD_VOLUME = _MT4ManagerAPI.RET_TRADE_BAD_VOLUME
RET_TRADE_MARKET_CLOSED = _MT4ManagerAPI.RET_TRADE_MARKET_CLOSED
RET_TRADE_DISABLE = _MT4ManagerAPI.RET_TRADE_DISABLE
RET_TRADE_NO_MONEY = _MT4ManagerAPI.RET_TRADE_NO_MONEY
RET_TRADE_PRICE_CHANGED = _MT4ManagerAPI.RET_TRADE_PRICE_CHANGED
RET_TRADE_OFFQUOTES = _MT4ManagerAPI.RET_TRADE_OFFQUOTES
RET_TRADE_BROKER_BUSY = _MT4ManagerAPI.RET_TRADE_BROKER_BUSY
RET_TRADE_REQUOTE = _MT4ManagerAPI.RET_TRADE_REQUOTE
RET_TRADE_ORDER_LOCKED = _MT4ManagerAPI.RET_TRADE_ORDER_LOCKED
RET_TRADE_LONG_ONLY = _MT4ManagerAPI.RET_TRADE_LONG_ONLY
RET_TRADE_TOO_MANY_REQ = _MT4ManagerAPI.RET_TRADE_TOO_MANY_REQ
RET_TRADE_ACCEPTED = _MT4ManagerAPI.RET_TRADE_ACCEPTED
RET_TRADE_PROCESS = _MT4ManagerAPI.RET_TRADE_PROCESS
RET_TRADE_USER_CANCEL = _MT4ManagerAPI.RET_TRADE_USER_CANCEL
RET_TRADE_MODIFY_DENIED = _MT4ManagerAPI.RET_TRADE_MODIFY_DENIED
RET_TRADE_CONTEXT_BUSY = _MT4ManagerAPI.RET_TRADE_CONTEXT_BUSY
RET_TRADE_EXPIRATION_DENIED = _MT4ManagerAPI.RET_TRADE_EXPIRATION_DENIED
RET_TRADE_TOO_MANY_ORDERS = _MT4ManagerAPI.RET_TRADE_TOO_MANY_ORDERS
RET_TRADE_HEDGE_PROHIBITED = _MT4ManagerAPI.RET_TRADE_HEDGE_PROHIBITED
RET_TRADE_PROHIBITED_BY_FIFO = _MT4ManagerAPI.RET_TRADE_PROHIBITED_BY_FIFO
CLIENT_FLAGS_HIDETICKS = _MT4ManagerAPI.CLIENT_FLAGS_HIDETICKS
CLIENT_FLAGS_HIDENEWS = _MT4ManagerAPI.CLIENT_FLAGS_HIDENEWS
CLIENT_FLAGS_HIDEMAIL = _MT4ManagerAPI.CLIENT_FLAGS_HIDEMAIL
CLIENT_FLAGS_SENDFULLNEWS = _MT4ManagerAPI.CLIENT_FLAGS_SENDFULLNEWS
CLIENT_FLAGS_RESERVED = _MT4ManagerAPI.CLIENT_FLAGS_RESERVED
CLIENT_FLAGS_HIDEONLINE = _MT4ManagerAPI.CLIENT_FLAGS_HIDEONLINE
CLIENT_FLAGS_HIDEUSERS = _MT4ManagerAPI.CLIENT_FLAGS_HIDEUSERS
class FeedDescription(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FeedDescription, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FeedDescription, name)
    __repr__ = _swig_repr
    __swig_setmethods__["version"] = _MT4ManagerAPI.FeedDescription_version_set
    __swig_getmethods__["version"] = _MT4ManagerAPI.FeedDescription_version_get
    if _newclass:
        version = _swig_property(_MT4ManagerAPI.FeedDescription_version_get, _MT4ManagerAPI.FeedDescription_version_set)
    __swig_setmethods__["name"] = _MT4ManagerAPI.FeedDescription_name_set
    __swig_getmethods__["name"] = _MT4ManagerAPI.FeedDescription_name_get
    if _newclass:
        name = _swig_property(_MT4ManagerAPI.FeedDescription_name_get, _MT4ManagerAPI.FeedDescription_name_set)
    __swig_setmethods__["copyright"] = _MT4ManagerAPI.FeedDescription_copyright_set
    __swig_getmethods__["copyright"] = _MT4ManagerAPI.FeedDescription_copyright_get
    if _newclass:
        copyright = _swig_property(_MT4ManagerAPI.FeedDescription_copyright_get, _MT4ManagerAPI.FeedDescription_copyright_set)
    __swig_setmethods__["web"] = _MT4ManagerAPI.FeedDescription_web_set
    __swig_getmethods__["web"] = _MT4ManagerAPI.FeedDescription_web_get
    if _newclass:
        web = _swig_property(_MT4ManagerAPI.FeedDescription_web_get, _MT4ManagerAPI.FeedDescription_web_set)
    __swig_setmethods__["email"] = _MT4ManagerAPI.FeedDescription_email_set
    __swig_getmethods__["email"] = _MT4ManagerAPI.FeedDescription_email_get
    if _newclass:
        email = _swig_property(_MT4ManagerAPI.FeedDescription_email_get, _MT4ManagerAPI.FeedDescription_email_set)
    __swig_setmethods__["server"] = _MT4ManagerAPI.FeedDescription_server_set
    __swig_getmethods__["server"] = _MT4ManagerAPI.FeedDescription_server_get
    if _newclass:
        server = _swig_property(_MT4ManagerAPI.FeedDescription_server_get, _MT4ManagerAPI.FeedDescription_server_set)
    __swig_setmethods__["username"] = _MT4ManagerAPI.FeedDescription_username_set
    __swig_getmethods__["username"] = _MT4ManagerAPI.FeedDescription_username_get
    if _newclass:
        username = _swig_property(_MT4ManagerAPI.FeedDescription_username_get, _MT4ManagerAPI.FeedDescription_username_set)
    __swig_setmethods__["userpass"] = _MT4ManagerAPI.FeedDescription_userpass_set
    __swig_getmethods__["userpass"] = _MT4ManagerAPI.FeedDescription_userpass_get
    if _newclass:
        userpass = _swig_property(_MT4ManagerAPI.FeedDescription_userpass_get, _MT4ManagerAPI.FeedDescription_userpass_set)
    __swig_setmethods__["modes"] = _MT4ManagerAPI.FeedDescription_modes_set
    __swig_getmethods__["modes"] = _MT4ManagerAPI.FeedDescription_modes_get
    if _newclass:
        modes = _swig_property(_MT4ManagerAPI.FeedDescription_modes_get, _MT4ManagerAPI.FeedDescription_modes_set)
    __swig_setmethods__["description"] = _MT4ManagerAPI.FeedDescription_description_set
    __swig_getmethods__["description"] = _MT4ManagerAPI.FeedDescription_description_get
    if _newclass:
        description = _swig_property(_MT4ManagerAPI.FeedDescription_description_get, _MT4ManagerAPI.FeedDescription_description_set)
    __swig_setmethods__["module"] = _MT4ManagerAPI.FeedDescription_module_set
    __swig_getmethods__["module"] = _MT4ManagerAPI.FeedDescription_module_get
    if _newclass:
        module = _swig_property(_MT4ManagerAPI.FeedDescription_module_get, _MT4ManagerAPI.FeedDescription_module_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.FeedDescription_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.FeedDescription_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.FeedDescription_reserved_get, _MT4ManagerAPI.FeedDescription_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_FeedDescription()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_FeedDescription
    __del__ = lambda self: None
FeedDescription_swigregister = _MT4ManagerAPI.FeedDescription_swigregister
FeedDescription_swigregister(FeedDescription)

modeOnlyQuotes = _MT4ManagerAPI.modeOnlyQuotes
modeOnlyNews = _MT4ManagerAPI.modeOnlyNews
modeQuotesAndNews = _MT4ManagerAPI.modeQuotesAndNews
modeQuotesOrNews = _MT4ManagerAPI.modeQuotesOrNews
class ServerFeed(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ServerFeed, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ServerFeed, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file"] = _MT4ManagerAPI.ServerFeed_file_set
    __swig_getmethods__["file"] = _MT4ManagerAPI.ServerFeed_file_get
    if _newclass:
        file = _swig_property(_MT4ManagerAPI.ServerFeed_file_get, _MT4ManagerAPI.ServerFeed_file_set)
    __swig_setmethods__["feed"] = _MT4ManagerAPI.ServerFeed_feed_set
    __swig_getmethods__["feed"] = _MT4ManagerAPI.ServerFeed_feed_get
    if _newclass:
        feed = _swig_property(_MT4ManagerAPI.ServerFeed_feed_get, _MT4ManagerAPI.ServerFeed_feed_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ServerFeed()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ServerFeed
    __del__ = lambda self: None
ServerFeed_swigregister = _MT4ManagerAPI.ServerFeed_swigregister
ServerFeed_swigregister(ServerFeed)

class ChartInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChartInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChartInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.ChartInfo_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.ChartInfo_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.ChartInfo_symbol_get, _MT4ManagerAPI.ChartInfo_symbol_set)
    __swig_setmethods__["period"] = _MT4ManagerAPI.ChartInfo_period_set
    __swig_getmethods__["period"] = _MT4ManagerAPI.ChartInfo_period_get
    if _newclass:
        period = _swig_property(_MT4ManagerAPI.ChartInfo_period_get, _MT4ManagerAPI.ChartInfo_period_set)
    __swig_setmethods__["start"] = _MT4ManagerAPI.ChartInfo_start_set
    __swig_getmethods__["start"] = _MT4ManagerAPI.ChartInfo_start_get
    if _newclass:
        start = _swig_property(_MT4ManagerAPI.ChartInfo_start_get, _MT4ManagerAPI.ChartInfo_start_set)
    __swig_setmethods__["end"] = _MT4ManagerAPI.ChartInfo_end_set
    __swig_getmethods__["end"] = _MT4ManagerAPI.ChartInfo_end_get
    if _newclass:
        end = _swig_property(_MT4ManagerAPI.ChartInfo_end_get, _MT4ManagerAPI.ChartInfo_end_set)
    __swig_setmethods__["timesign"] = _MT4ManagerAPI.ChartInfo_timesign_set
    __swig_getmethods__["timesign"] = _MT4ManagerAPI.ChartInfo_timesign_get
    if _newclass:
        timesign = _swig_property(_MT4ManagerAPI.ChartInfo_timesign_get, _MT4ManagerAPI.ChartInfo_timesign_set)
    __swig_setmethods__["mode"] = _MT4ManagerAPI.ChartInfo_mode_set
    __swig_getmethods__["mode"] = _MT4ManagerAPI.ChartInfo_mode_get
    if _newclass:
        mode = _swig_property(_MT4ManagerAPI.ChartInfo_mode_get, _MT4ManagerAPI.ChartInfo_mode_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ChartInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ChartInfo
    __del__ = lambda self: None
ChartInfo_swigregister = _MT4ManagerAPI.ChartInfo_swigregister
ChartInfo_swigregister(ChartInfo)

PERIOD_M1 = _MT4ManagerAPI.PERIOD_M1
PERIOD_M5 = _MT4ManagerAPI.PERIOD_M5
PERIOD_M15 = _MT4ManagerAPI.PERIOD_M15
PERIOD_M30 = _MT4ManagerAPI.PERIOD_M30
PERIOD_H1 = _MT4ManagerAPI.PERIOD_H1
PERIOD_H4 = _MT4ManagerAPI.PERIOD_H4
PERIOD_D1 = _MT4ManagerAPI.PERIOD_D1
PERIOD_W1 = _MT4ManagerAPI.PERIOD_W1
PERIOD_MN1 = _MT4ManagerAPI.PERIOD_MN1
CHART_RANGE_IN = _MT4ManagerAPI.CHART_RANGE_IN
CHART_RANGE_OUT = _MT4ManagerAPI.CHART_RANGE_OUT
CHART_RANGE_LAST = _MT4ManagerAPI.CHART_RANGE_LAST
class RateInfoOld(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RateInfoOld, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RateInfoOld, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ctm"] = _MT4ManagerAPI.RateInfoOld_ctm_set
    __swig_getmethods__["ctm"] = _MT4ManagerAPI.RateInfoOld_ctm_get
    if _newclass:
        ctm = _swig_property(_MT4ManagerAPI.RateInfoOld_ctm_get, _MT4ManagerAPI.RateInfoOld_ctm_set)
    __swig_setmethods__["open"] = _MT4ManagerAPI.RateInfoOld_open_set
    __swig_getmethods__["open"] = _MT4ManagerAPI.RateInfoOld_open_get
    if _newclass:
        open = _swig_property(_MT4ManagerAPI.RateInfoOld_open_get, _MT4ManagerAPI.RateInfoOld_open_set)
    __swig_setmethods__["high"] = _MT4ManagerAPI.RateInfoOld_high_set
    __swig_getmethods__["high"] = _MT4ManagerAPI.RateInfoOld_high_get
    if _newclass:
        high = _swig_property(_MT4ManagerAPI.RateInfoOld_high_get, _MT4ManagerAPI.RateInfoOld_high_set)
    __swig_setmethods__["low"] = _MT4ManagerAPI.RateInfoOld_low_set
    __swig_getmethods__["low"] = _MT4ManagerAPI.RateInfoOld_low_get
    if _newclass:
        low = _swig_property(_MT4ManagerAPI.RateInfoOld_low_get, _MT4ManagerAPI.RateInfoOld_low_set)
    __swig_setmethods__["close"] = _MT4ManagerAPI.RateInfoOld_close_set
    __swig_getmethods__["close"] = _MT4ManagerAPI.RateInfoOld_close_get
    if _newclass:
        close = _swig_property(_MT4ManagerAPI.RateInfoOld_close_get, _MT4ManagerAPI.RateInfoOld_close_set)
    __swig_setmethods__["vol"] = _MT4ManagerAPI.RateInfoOld_vol_set
    __swig_getmethods__["vol"] = _MT4ManagerAPI.RateInfoOld_vol_get
    if _newclass:
        vol = _swig_property(_MT4ManagerAPI.RateInfoOld_vol_get, _MT4ManagerAPI.RateInfoOld_vol_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_RateInfoOld()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_RateInfoOld
    __del__ = lambda self: None
RateInfoOld_swigregister = _MT4ManagerAPI.RateInfoOld_swigregister
RateInfoOld_swigregister(RateInfoOld)

class RateInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RateInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RateInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ctm"] = _MT4ManagerAPI.RateInfo_ctm_set
    __swig_getmethods__["ctm"] = _MT4ManagerAPI.RateInfo_ctm_get
    if _newclass:
        ctm = _swig_property(_MT4ManagerAPI.RateInfo_ctm_get, _MT4ManagerAPI.RateInfo_ctm_set)
    __swig_setmethods__["open"] = _MT4ManagerAPI.RateInfo_open_set
    __swig_getmethods__["open"] = _MT4ManagerAPI.RateInfo_open_get
    if _newclass:
        open = _swig_property(_MT4ManagerAPI.RateInfo_open_get, _MT4ManagerAPI.RateInfo_open_set)
    __swig_setmethods__["high"] = _MT4ManagerAPI.RateInfo_high_set
    __swig_getmethods__["high"] = _MT4ManagerAPI.RateInfo_high_get
    if _newclass:
        high = _swig_property(_MT4ManagerAPI.RateInfo_high_get, _MT4ManagerAPI.RateInfo_high_set)
    __swig_setmethods__["low"] = _MT4ManagerAPI.RateInfo_low_set
    __swig_getmethods__["low"] = _MT4ManagerAPI.RateInfo_low_get
    if _newclass:
        low = _swig_property(_MT4ManagerAPI.RateInfo_low_get, _MT4ManagerAPI.RateInfo_low_set)
    __swig_setmethods__["close"] = _MT4ManagerAPI.RateInfo_close_set
    __swig_getmethods__["close"] = _MT4ManagerAPI.RateInfo_close_get
    if _newclass:
        close = _swig_property(_MT4ManagerAPI.RateInfo_close_get, _MT4ManagerAPI.RateInfo_close_set)
    __swig_setmethods__["vol"] = _MT4ManagerAPI.RateInfo_vol_set
    __swig_getmethods__["vol"] = _MT4ManagerAPI.RateInfo_vol_get
    if _newclass:
        vol = _swig_property(_MT4ManagerAPI.RateInfo_vol_get, _MT4ManagerAPI.RateInfo_vol_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_RateInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_RateInfo
    __del__ = lambda self: None
RateInfo_swigregister = _MT4ManagerAPI.RateInfo_swigregister
RateInfo_swigregister(RateInfo)

class TickRecord(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TickRecord, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TickRecord, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ctm"] = _MT4ManagerAPI.TickRecord_ctm_set
    __swig_getmethods__["ctm"] = _MT4ManagerAPI.TickRecord_ctm_get
    if _newclass:
        ctm = _swig_property(_MT4ManagerAPI.TickRecord_ctm_get, _MT4ManagerAPI.TickRecord_ctm_set)
    __swig_setmethods__["bid"] = _MT4ManagerAPI.TickRecord_bid_set
    __swig_getmethods__["bid"] = _MT4ManagerAPI.TickRecord_bid_get
    if _newclass:
        bid = _swig_property(_MT4ManagerAPI.TickRecord_bid_get, _MT4ManagerAPI.TickRecord_bid_set)
    __swig_setmethods__["ask"] = _MT4ManagerAPI.TickRecord_ask_set
    __swig_getmethods__["ask"] = _MT4ManagerAPI.TickRecord_ask_get
    if _newclass:
        ask = _swig_property(_MT4ManagerAPI.TickRecord_ask_get, _MT4ManagerAPI.TickRecord_ask_set)
    __swig_setmethods__["datafeed"] = _MT4ManagerAPI.TickRecord_datafeed_set
    __swig_getmethods__["datafeed"] = _MT4ManagerAPI.TickRecord_datafeed_get
    if _newclass:
        datafeed = _swig_property(_MT4ManagerAPI.TickRecord_datafeed_get, _MT4ManagerAPI.TickRecord_datafeed_set)
    __swig_setmethods__["flags"] = _MT4ManagerAPI.TickRecord_flags_set
    __swig_getmethods__["flags"] = _MT4ManagerAPI.TickRecord_flags_get
    if _newclass:
        flags = _swig_property(_MT4ManagerAPI.TickRecord_flags_get, _MT4ManagerAPI.TickRecord_flags_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_TickRecord()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_TickRecord
    __del__ = lambda self: None
TickRecord_swigregister = _MT4ManagerAPI.TickRecord_swigregister
TickRecord_swigregister(TickRecord)

TICK_FLAG_RAW = _MT4ManagerAPI.TICK_FLAG_RAW
TICK_FLAG_NORMAL = _MT4ManagerAPI.TICK_FLAG_NORMAL
TICK_FLAG_ALL = _MT4ManagerAPI.TICK_FLAG_ALL
class TickRequest(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TickRequest, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TickRequest, name)
    __repr__ = _swig_repr
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.TickRequest_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.TickRequest_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.TickRequest_symbol_get, _MT4ManagerAPI.TickRequest_symbol_set)
    __swig_setmethods__["_from"] = _MT4ManagerAPI.TickRequest__from_set
    __swig_getmethods__["_from"] = _MT4ManagerAPI.TickRequest__from_get
    if _newclass:
        _from = _swig_property(_MT4ManagerAPI.TickRequest__from_get, _MT4ManagerAPI.TickRequest__from_set)
    __swig_setmethods__["to"] = _MT4ManagerAPI.TickRequest_to_set
    __swig_getmethods__["to"] = _MT4ManagerAPI.TickRequest_to_get
    if _newclass:
        to = _swig_property(_MT4ManagerAPI.TickRequest_to_get, _MT4ManagerAPI.TickRequest_to_set)
    __swig_setmethods__["flags"] = _MT4ManagerAPI.TickRequest_flags_set
    __swig_getmethods__["flags"] = _MT4ManagerAPI.TickRequest_flags_get
    if _newclass:
        flags = _swig_property(_MT4ManagerAPI.TickRequest_flags_get, _MT4ManagerAPI.TickRequest_flags_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_TickRequest()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_TickRequest
    __del__ = lambda self: None
TickRequest_swigregister = _MT4ManagerAPI.TickRequest_swigregister
TickRequest_swigregister(TickRequest)

class PerformanceInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PerformanceInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PerformanceInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ctm"] = _MT4ManagerAPI.PerformanceInfo_ctm_set
    __swig_getmethods__["ctm"] = _MT4ManagerAPI.PerformanceInfo_ctm_get
    if _newclass:
        ctm = _swig_property(_MT4ManagerAPI.PerformanceInfo_ctm_get, _MT4ManagerAPI.PerformanceInfo_ctm_set)
    __swig_setmethods__["users"] = _MT4ManagerAPI.PerformanceInfo_users_set
    __swig_getmethods__["users"] = _MT4ManagerAPI.PerformanceInfo_users_get
    if _newclass:
        users = _swig_property(_MT4ManagerAPI.PerformanceInfo_users_get, _MT4ManagerAPI.PerformanceInfo_users_set)
    __swig_setmethods__["cpu"] = _MT4ManagerAPI.PerformanceInfo_cpu_set
    __swig_getmethods__["cpu"] = _MT4ManagerAPI.PerformanceInfo_cpu_get
    if _newclass:
        cpu = _swig_property(_MT4ManagerAPI.PerformanceInfo_cpu_get, _MT4ManagerAPI.PerformanceInfo_cpu_set)
    __swig_setmethods__["freemem"] = _MT4ManagerAPI.PerformanceInfo_freemem_set
    __swig_getmethods__["freemem"] = _MT4ManagerAPI.PerformanceInfo_freemem_get
    if _newclass:
        freemem = _swig_property(_MT4ManagerAPI.PerformanceInfo_freemem_get, _MT4ManagerAPI.PerformanceInfo_freemem_set)
    __swig_setmethods__["network"] = _MT4ManagerAPI.PerformanceInfo_network_set
    __swig_getmethods__["network"] = _MT4ManagerAPI.PerformanceInfo_network_get
    if _newclass:
        network = _swig_property(_MT4ManagerAPI.PerformanceInfo_network_get, _MT4ManagerAPI.PerformanceInfo_network_set)
    __swig_setmethods__["sockets"] = _MT4ManagerAPI.PerformanceInfo_sockets_set
    __swig_getmethods__["sockets"] = _MT4ManagerAPI.PerformanceInfo_sockets_get
    if _newclass:
        sockets = _swig_property(_MT4ManagerAPI.PerformanceInfo_sockets_get, _MT4ManagerAPI.PerformanceInfo_sockets_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_PerformanceInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_PerformanceInfo
    __del__ = lambda self: None
PerformanceInfo_swigregister = _MT4ManagerAPI.PerformanceInfo_swigregister
PerformanceInfo_swigregister(PerformanceInfo)

class BackupInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BackupInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BackupInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["file"] = _MT4ManagerAPI.BackupInfo_file_set
    __swig_getmethods__["file"] = _MT4ManagerAPI.BackupInfo_file_get
    if _newclass:
        file = _swig_property(_MT4ManagerAPI.BackupInfo_file_get, _MT4ManagerAPI.BackupInfo_file_set)
    __swig_setmethods__["size"] = _MT4ManagerAPI.BackupInfo_size_set
    __swig_getmethods__["size"] = _MT4ManagerAPI.BackupInfo_size_get
    if _newclass:
        size = _swig_property(_MT4ManagerAPI.BackupInfo_size_get, _MT4ManagerAPI.BackupInfo_size_set)
    __swig_setmethods__["time"] = _MT4ManagerAPI.BackupInfo_time_set
    __swig_getmethods__["time"] = _MT4ManagerAPI.BackupInfo_time_get
    if _newclass:
        time = _swig_property(_MT4ManagerAPI.BackupInfo_time_get, _MT4ManagerAPI.BackupInfo_time_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.BackupInfo_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.BackupInfo_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.BackupInfo_reserved_get, _MT4ManagerAPI.BackupInfo_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_BackupInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_BackupInfo
    __del__ = lambda self: None
BackupInfo_swigregister = _MT4ManagerAPI.BackupInfo_swigregister
BackupInfo_swigregister(BackupInfo)

BACKUPS_ALL = _MT4ManagerAPI.BACKUPS_ALL
BACKUPS_PERIODICAL = _MT4ManagerAPI.BACKUPS_PERIODICAL
BACKUPS_STARTUP = _MT4ManagerAPI.BACKUPS_STARTUP
BACKUPS_DELETE = _MT4ManagerAPI.BACKUPS_DELETE
TRANS_ADD = _MT4ManagerAPI.TRANS_ADD
TRANS_DELETE = _MT4ManagerAPI.TRANS_DELETE
TRANS_UPDATE = _MT4ManagerAPI.TRANS_UPDATE
TRANS_CHANGE_GRP = _MT4ManagerAPI.TRANS_CHANGE_GRP
PUBLIC_KEY_SIZE = _MT4ManagerAPI.PUBLIC_KEY_SIZE
USER_COLOR_NONE = _MT4ManagerAPI.USER_COLOR_NONE
class UserRecord(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UserRecord, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UserRecord, name)
    __repr__ = _swig_repr
    __swig_setmethods__["login"] = _MT4ManagerAPI.UserRecord_login_set
    __swig_getmethods__["login"] = _MT4ManagerAPI.UserRecord_login_get
    if _newclass:
        login = _swig_property(_MT4ManagerAPI.UserRecord_login_get, _MT4ManagerAPI.UserRecord_login_set)
    __swig_setmethods__["group"] = _MT4ManagerAPI.UserRecord_group_set
    __swig_getmethods__["group"] = _MT4ManagerAPI.UserRecord_group_get
    if _newclass:
        group = _swig_property(_MT4ManagerAPI.UserRecord_group_get, _MT4ManagerAPI.UserRecord_group_set)
    __swig_setmethods__["password"] = _MT4ManagerAPI.UserRecord_password_set
    __swig_getmethods__["password"] = _MT4ManagerAPI.UserRecord_password_get
    if _newclass:
        password = _swig_property(_MT4ManagerAPI.UserRecord_password_get, _MT4ManagerAPI.UserRecord_password_set)
    __swig_setmethods__["enable"] = _MT4ManagerAPI.UserRecord_enable_set
    __swig_getmethods__["enable"] = _MT4ManagerAPI.UserRecord_enable_get
    if _newclass:
        enable = _swig_property(_MT4ManagerAPI.UserRecord_enable_get, _MT4ManagerAPI.UserRecord_enable_set)
    __swig_setmethods__["enable_change_password"] = _MT4ManagerAPI.UserRecord_enable_change_password_set
    __swig_getmethods__["enable_change_password"] = _MT4ManagerAPI.UserRecord_enable_change_password_get
    if _newclass:
        enable_change_password = _swig_property(_MT4ManagerAPI.UserRecord_enable_change_password_get, _MT4ManagerAPI.UserRecord_enable_change_password_set)
    __swig_setmethods__["enable_read_only"] = _MT4ManagerAPI.UserRecord_enable_read_only_set
    __swig_getmethods__["enable_read_only"] = _MT4ManagerAPI.UserRecord_enable_read_only_get
    if _newclass:
        enable_read_only = _swig_property(_MT4ManagerAPI.UserRecord_enable_read_only_get, _MT4ManagerAPI.UserRecord_enable_read_only_set)
    __swig_setmethods__["enable_reserved"] = _MT4ManagerAPI.UserRecord_enable_reserved_set
    __swig_getmethods__["enable_reserved"] = _MT4ManagerAPI.UserRecord_enable_reserved_get
    if _newclass:
        enable_reserved = _swig_property(_MT4ManagerAPI.UserRecord_enable_reserved_get, _MT4ManagerAPI.UserRecord_enable_reserved_set)
    __swig_setmethods__["password_investor"] = _MT4ManagerAPI.UserRecord_password_investor_set
    __swig_getmethods__["password_investor"] = _MT4ManagerAPI.UserRecord_password_investor_get
    if _newclass:
        password_investor = _swig_property(_MT4ManagerAPI.UserRecord_password_investor_get, _MT4ManagerAPI.UserRecord_password_investor_set)
    __swig_setmethods__["password_phone"] = _MT4ManagerAPI.UserRecord_password_phone_set
    __swig_getmethods__["password_phone"] = _MT4ManagerAPI.UserRecord_password_phone_get
    if _newclass:
        password_phone = _swig_property(_MT4ManagerAPI.UserRecord_password_phone_get, _MT4ManagerAPI.UserRecord_password_phone_set)
    __swig_setmethods__["name"] = _MT4ManagerAPI.UserRecord_name_set
    __swig_getmethods__["name"] = _MT4ManagerAPI.UserRecord_name_get
    if _newclass:
        name = _swig_property(_MT4ManagerAPI.UserRecord_name_get, _MT4ManagerAPI.UserRecord_name_set)
    __swig_setmethods__["country"] = _MT4ManagerAPI.UserRecord_country_set
    __swig_getmethods__["country"] = _MT4ManagerAPI.UserRecord_country_get
    if _newclass:
        country = _swig_property(_MT4ManagerAPI.UserRecord_country_get, _MT4ManagerAPI.UserRecord_country_set)
    __swig_setmethods__["city"] = _MT4ManagerAPI.UserRecord_city_set
    __swig_getmethods__["city"] = _MT4ManagerAPI.UserRecord_city_get
    if _newclass:
        city = _swig_property(_MT4ManagerAPI.UserRecord_city_get, _MT4ManagerAPI.UserRecord_city_set)
    __swig_setmethods__["state"] = _MT4ManagerAPI.UserRecord_state_set
    __swig_getmethods__["state"] = _MT4ManagerAPI.UserRecord_state_get
    if _newclass:
        state = _swig_property(_MT4ManagerAPI.UserRecord_state_get, _MT4ManagerAPI.UserRecord_state_set)
    __swig_setmethods__["zipcode"] = _MT4ManagerAPI.UserRecord_zipcode_set
    __swig_getmethods__["zipcode"] = _MT4ManagerAPI.UserRecord_zipcode_get
    if _newclass:
        zipcode = _swig_property(_MT4ManagerAPI.UserRecord_zipcode_get, _MT4ManagerAPI.UserRecord_zipcode_set)
    __swig_setmethods__["address"] = _MT4ManagerAPI.UserRecord_address_set
    __swig_getmethods__["address"] = _MT4ManagerAPI.UserRecord_address_get
    if _newclass:
        address = _swig_property(_MT4ManagerAPI.UserRecord_address_get, _MT4ManagerAPI.UserRecord_address_set)
    __swig_setmethods__["phone"] = _MT4ManagerAPI.UserRecord_phone_set
    __swig_getmethods__["phone"] = _MT4ManagerAPI.UserRecord_phone_get
    if _newclass:
        phone = _swig_property(_MT4ManagerAPI.UserRecord_phone_get, _MT4ManagerAPI.UserRecord_phone_set)
    __swig_setmethods__["email"] = _MT4ManagerAPI.UserRecord_email_set
    __swig_getmethods__["email"] = _MT4ManagerAPI.UserRecord_email_get
    if _newclass:
        email = _swig_property(_MT4ManagerAPI.UserRecord_email_get, _MT4ManagerAPI.UserRecord_email_set)
    __swig_setmethods__["comment"] = _MT4ManagerAPI.UserRecord_comment_set
    __swig_getmethods__["comment"] = _MT4ManagerAPI.UserRecord_comment_get
    if _newclass:
        comment = _swig_property(_MT4ManagerAPI.UserRecord_comment_get, _MT4ManagerAPI.UserRecord_comment_set)
    __swig_setmethods__["id"] = _MT4ManagerAPI.UserRecord_id_set
    __swig_getmethods__["id"] = _MT4ManagerAPI.UserRecord_id_get
    if _newclass:
        id = _swig_property(_MT4ManagerAPI.UserRecord_id_get, _MT4ManagerAPI.UserRecord_id_set)
    __swig_setmethods__["status"] = _MT4ManagerAPI.UserRecord_status_set
    __swig_getmethods__["status"] = _MT4ManagerAPI.UserRecord_status_get
    if _newclass:
        status = _swig_property(_MT4ManagerAPI.UserRecord_status_get, _MT4ManagerAPI.UserRecord_status_set)
    __swig_setmethods__["regdate"] = _MT4ManagerAPI.UserRecord_regdate_set
    __swig_getmethods__["regdate"] = _MT4ManagerAPI.UserRecord_regdate_get
    if _newclass:
        regdate = _swig_property(_MT4ManagerAPI.UserRecord_regdate_get, _MT4ManagerAPI.UserRecord_regdate_set)
    __swig_setmethods__["lastdate"] = _MT4ManagerAPI.UserRecord_lastdate_set
    __swig_getmethods__["lastdate"] = _MT4ManagerAPI.UserRecord_lastdate_get
    if _newclass:
        lastdate = _swig_property(_MT4ManagerAPI.UserRecord_lastdate_get, _MT4ManagerAPI.UserRecord_lastdate_set)
    __swig_setmethods__["leverage"] = _MT4ManagerAPI.UserRecord_leverage_set
    __swig_getmethods__["leverage"] = _MT4ManagerAPI.UserRecord_leverage_get
    if _newclass:
        leverage = _swig_property(_MT4ManagerAPI.UserRecord_leverage_get, _MT4ManagerAPI.UserRecord_leverage_set)
    __swig_setmethods__["agent_account"] = _MT4ManagerAPI.UserRecord_agent_account_set
    __swig_getmethods__["agent_account"] = _MT4ManagerAPI.UserRecord_agent_account_get
    if _newclass:
        agent_account = _swig_property(_MT4ManagerAPI.UserRecord_agent_account_get, _MT4ManagerAPI.UserRecord_agent_account_set)
    __swig_setmethods__["timestamp"] = _MT4ManagerAPI.UserRecord_timestamp_set
    __swig_getmethods__["timestamp"] = _MT4ManagerAPI.UserRecord_timestamp_get
    if _newclass:
        timestamp = _swig_property(_MT4ManagerAPI.UserRecord_timestamp_get, _MT4ManagerAPI.UserRecord_timestamp_set)
    __swig_setmethods__["last_ip"] = _MT4ManagerAPI.UserRecord_last_ip_set
    __swig_getmethods__["last_ip"] = _MT4ManagerAPI.UserRecord_last_ip_get
    if _newclass:
        last_ip = _swig_property(_MT4ManagerAPI.UserRecord_last_ip_get, _MT4ManagerAPI.UserRecord_last_ip_set)
    __swig_setmethods__["balance"] = _MT4ManagerAPI.UserRecord_balance_set
    __swig_getmethods__["balance"] = _MT4ManagerAPI.UserRecord_balance_get
    if _newclass:
        balance = _swig_property(_MT4ManagerAPI.UserRecord_balance_get, _MT4ManagerAPI.UserRecord_balance_set)
    __swig_setmethods__["prevmonthbalance"] = _MT4ManagerAPI.UserRecord_prevmonthbalance_set
    __swig_getmethods__["prevmonthbalance"] = _MT4ManagerAPI.UserRecord_prevmonthbalance_get
    if _newclass:
        prevmonthbalance = _swig_property(_MT4ManagerAPI.UserRecord_prevmonthbalance_get, _MT4ManagerAPI.UserRecord_prevmonthbalance_set)
    __swig_setmethods__["prevbalance"] = _MT4ManagerAPI.UserRecord_prevbalance_set
    __swig_getmethods__["prevbalance"] = _MT4ManagerAPI.UserRecord_prevbalance_get
    if _newclass:
        prevbalance = _swig_property(_MT4ManagerAPI.UserRecord_prevbalance_get, _MT4ManagerAPI.UserRecord_prevbalance_set)
    __swig_setmethods__["credit"] = _MT4ManagerAPI.UserRecord_credit_set
    __swig_getmethods__["credit"] = _MT4ManagerAPI.UserRecord_credit_get
    if _newclass:
        credit = _swig_property(_MT4ManagerAPI.UserRecord_credit_get, _MT4ManagerAPI.UserRecord_credit_set)
    __swig_setmethods__["interestrate"] = _MT4ManagerAPI.UserRecord_interestrate_set
    __swig_getmethods__["interestrate"] = _MT4ManagerAPI.UserRecord_interestrate_get
    if _newclass:
        interestrate = _swig_property(_MT4ManagerAPI.UserRecord_interestrate_get, _MT4ManagerAPI.UserRecord_interestrate_set)
    __swig_setmethods__["taxes"] = _MT4ManagerAPI.UserRecord_taxes_set
    __swig_getmethods__["taxes"] = _MT4ManagerAPI.UserRecord_taxes_get
    if _newclass:
        taxes = _swig_property(_MT4ManagerAPI.UserRecord_taxes_get, _MT4ManagerAPI.UserRecord_taxes_set)
    __swig_setmethods__["prevmonthequity"] = _MT4ManagerAPI.UserRecord_prevmonthequity_set
    __swig_getmethods__["prevmonthequity"] = _MT4ManagerAPI.UserRecord_prevmonthequity_get
    if _newclass:
        prevmonthequity = _swig_property(_MT4ManagerAPI.UserRecord_prevmonthequity_get, _MT4ManagerAPI.UserRecord_prevmonthequity_set)
    __swig_setmethods__["prevequity"] = _MT4ManagerAPI.UserRecord_prevequity_set
    __swig_getmethods__["prevequity"] = _MT4ManagerAPI.UserRecord_prevequity_get
    if _newclass:
        prevequity = _swig_property(_MT4ManagerAPI.UserRecord_prevequity_get, _MT4ManagerAPI.UserRecord_prevequity_set)
    __swig_setmethods__["reserved2"] = _MT4ManagerAPI.UserRecord_reserved2_set
    __swig_getmethods__["reserved2"] = _MT4ManagerAPI.UserRecord_reserved2_get
    if _newclass:
        reserved2 = _swig_property(_MT4ManagerAPI.UserRecord_reserved2_get, _MT4ManagerAPI.UserRecord_reserved2_set)
    __swig_setmethods__["publickey"] = _MT4ManagerAPI.UserRecord_publickey_set
    __swig_getmethods__["publickey"] = _MT4ManagerAPI.UserRecord_publickey_get
    if _newclass:
        publickey = _swig_property(_MT4ManagerAPI.UserRecord_publickey_get, _MT4ManagerAPI.UserRecord_publickey_set)
    __swig_setmethods__["send_reports"] = _MT4ManagerAPI.UserRecord_send_reports_set
    __swig_getmethods__["send_reports"] = _MT4ManagerAPI.UserRecord_send_reports_get
    if _newclass:
        send_reports = _swig_property(_MT4ManagerAPI.UserRecord_send_reports_get, _MT4ManagerAPI.UserRecord_send_reports_set)
    __swig_setmethods__["mqid"] = _MT4ManagerAPI.UserRecord_mqid_set
    __swig_getmethods__["mqid"] = _MT4ManagerAPI.UserRecord_mqid_get
    if _newclass:
        mqid = _swig_property(_MT4ManagerAPI.UserRecord_mqid_get, _MT4ManagerAPI.UserRecord_mqid_set)
    __swig_setmethods__["user_color"] = _MT4ManagerAPI.UserRecord_user_color_set
    __swig_getmethods__["user_color"] = _MT4ManagerAPI.UserRecord_user_color_get
    if _newclass:
        user_color = _swig_property(_MT4ManagerAPI.UserRecord_user_color_get, _MT4ManagerAPI.UserRecord_user_color_set)
    __swig_setmethods__["unused"] = _MT4ManagerAPI.UserRecord_unused_set
    __swig_getmethods__["unused"] = _MT4ManagerAPI.UserRecord_unused_get
    if _newclass:
        unused = _swig_property(_MT4ManagerAPI.UserRecord_unused_get, _MT4ManagerAPI.UserRecord_unused_set)
    __swig_setmethods__["api_data"] = _MT4ManagerAPI.UserRecord_api_data_set
    __swig_getmethods__["api_data"] = _MT4ManagerAPI.UserRecord_api_data_get
    if _newclass:
        api_data = _swig_property(_MT4ManagerAPI.UserRecord_api_data_get, _MT4ManagerAPI.UserRecord_api_data_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_UserRecord()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_UserRecord
    __del__ = lambda self: None
UserRecord_swigregister = _MT4ManagerAPI.UserRecord_swigregister
UserRecord_swigregister(UserRecord)

class GroupCommandInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GroupCommandInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GroupCommandInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["len"] = _MT4ManagerAPI.GroupCommandInfo_len_set
    __swig_getmethods__["len"] = _MT4ManagerAPI.GroupCommandInfo_len_get
    if _newclass:
        len = _swig_property(_MT4ManagerAPI.GroupCommandInfo_len_get, _MT4ManagerAPI.GroupCommandInfo_len_set)
    __swig_setmethods__["command"] = _MT4ManagerAPI.GroupCommandInfo_command_set
    __swig_getmethods__["command"] = _MT4ManagerAPI.GroupCommandInfo_command_get
    if _newclass:
        command = _swig_property(_MT4ManagerAPI.GroupCommandInfo_command_get, _MT4ManagerAPI.GroupCommandInfo_command_set)
    __swig_setmethods__["newgroup"] = _MT4ManagerAPI.GroupCommandInfo_newgroup_set
    __swig_getmethods__["newgroup"] = _MT4ManagerAPI.GroupCommandInfo_newgroup_get
    if _newclass:
        newgroup = _swig_property(_MT4ManagerAPI.GroupCommandInfo_newgroup_get, _MT4ManagerAPI.GroupCommandInfo_newgroup_set)
    __swig_setmethods__["leverage"] = _MT4ManagerAPI.GroupCommandInfo_leverage_set
    __swig_getmethods__["leverage"] = _MT4ManagerAPI.GroupCommandInfo_leverage_get
    if _newclass:
        leverage = _swig_property(_MT4ManagerAPI.GroupCommandInfo_leverage_get, _MT4ManagerAPI.GroupCommandInfo_leverage_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.GroupCommandInfo_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.GroupCommandInfo_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.GroupCommandInfo_reserved_get, _MT4ManagerAPI.GroupCommandInfo_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_GroupCommandInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_GroupCommandInfo
    __del__ = lambda self: None
GroupCommandInfo_swigregister = _MT4ManagerAPI.GroupCommandInfo_swigregister
GroupCommandInfo_swigregister(GroupCommandInfo)

GROUP_DELETE = _MT4ManagerAPI.GROUP_DELETE
GROUP_ENABLE = _MT4ManagerAPI.GROUP_ENABLE
GROUP_DISABLE = _MT4ManagerAPI.GROUP_DISABLE
GROUP_LEVERAGE = _MT4ManagerAPI.GROUP_LEVERAGE
GROUP_SETGROUP = _MT4ManagerAPI.GROUP_SETGROUP
class OnlineRecord(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OnlineRecord, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OnlineRecord, name)
    __repr__ = _swig_repr
    __swig_setmethods__["counter"] = _MT4ManagerAPI.OnlineRecord_counter_set
    __swig_getmethods__["counter"] = _MT4ManagerAPI.OnlineRecord_counter_get
    if _newclass:
        counter = _swig_property(_MT4ManagerAPI.OnlineRecord_counter_get, _MT4ManagerAPI.OnlineRecord_counter_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.OnlineRecord_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.OnlineRecord_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.OnlineRecord_reserved_get, _MT4ManagerAPI.OnlineRecord_reserved_set)
    __swig_setmethods__["login"] = _MT4ManagerAPI.OnlineRecord_login_set
    __swig_getmethods__["login"] = _MT4ManagerAPI.OnlineRecord_login_get
    if _newclass:
        login = _swig_property(_MT4ManagerAPI.OnlineRecord_login_get, _MT4ManagerAPI.OnlineRecord_login_set)
    __swig_setmethods__["ip"] = _MT4ManagerAPI.OnlineRecord_ip_set
    __swig_getmethods__["ip"] = _MT4ManagerAPI.OnlineRecord_ip_get
    if _newclass:
        ip = _swig_property(_MT4ManagerAPI.OnlineRecord_ip_get, _MT4ManagerAPI.OnlineRecord_ip_set)
    __swig_setmethods__["group"] = _MT4ManagerAPI.OnlineRecord_group_set
    __swig_getmethods__["group"] = _MT4ManagerAPI.OnlineRecord_group_get
    if _newclass:
        group = _swig_property(_MT4ManagerAPI.OnlineRecord_group_get, _MT4ManagerAPI.OnlineRecord_group_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_OnlineRecord()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_OnlineRecord
    __del__ = lambda self: None
OnlineRecord_swigregister = _MT4ManagerAPI.OnlineRecord_swigregister
OnlineRecord_swigregister(OnlineRecord)

class TradeRecord(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TradeRecord, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TradeRecord, name)
    __repr__ = _swig_repr
    __swig_setmethods__["order"] = _MT4ManagerAPI.TradeRecord_order_set
    __swig_getmethods__["order"] = _MT4ManagerAPI.TradeRecord_order_get
    if _newclass:
        order = _swig_property(_MT4ManagerAPI.TradeRecord_order_get, _MT4ManagerAPI.TradeRecord_order_set)
    __swig_setmethods__["login"] = _MT4ManagerAPI.TradeRecord_login_set
    __swig_getmethods__["login"] = _MT4ManagerAPI.TradeRecord_login_get
    if _newclass:
        login = _swig_property(_MT4ManagerAPI.TradeRecord_login_get, _MT4ManagerAPI.TradeRecord_login_set)
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.TradeRecord_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.TradeRecord_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.TradeRecord_symbol_get, _MT4ManagerAPI.TradeRecord_symbol_set)
    __swig_setmethods__["digits"] = _MT4ManagerAPI.TradeRecord_digits_set
    __swig_getmethods__["digits"] = _MT4ManagerAPI.TradeRecord_digits_get
    if _newclass:
        digits = _swig_property(_MT4ManagerAPI.TradeRecord_digits_get, _MT4ManagerAPI.TradeRecord_digits_set)
    __swig_setmethods__["cmd"] = _MT4ManagerAPI.TradeRecord_cmd_set
    __swig_getmethods__["cmd"] = _MT4ManagerAPI.TradeRecord_cmd_get
    if _newclass:
        cmd = _swig_property(_MT4ManagerAPI.TradeRecord_cmd_get, _MT4ManagerAPI.TradeRecord_cmd_set)
    __swig_setmethods__["volume"] = _MT4ManagerAPI.TradeRecord_volume_set
    __swig_getmethods__["volume"] = _MT4ManagerAPI.TradeRecord_volume_get
    if _newclass:
        volume = _swig_property(_MT4ManagerAPI.TradeRecord_volume_get, _MT4ManagerAPI.TradeRecord_volume_set)
    __swig_setmethods__["open_time"] = _MT4ManagerAPI.TradeRecord_open_time_set
    __swig_getmethods__["open_time"] = _MT4ManagerAPI.TradeRecord_open_time_get
    if _newclass:
        open_time = _swig_property(_MT4ManagerAPI.TradeRecord_open_time_get, _MT4ManagerAPI.TradeRecord_open_time_set)
    __swig_setmethods__["state"] = _MT4ManagerAPI.TradeRecord_state_set
    __swig_getmethods__["state"] = _MT4ManagerAPI.TradeRecord_state_get
    if _newclass:
        state = _swig_property(_MT4ManagerAPI.TradeRecord_state_get, _MT4ManagerAPI.TradeRecord_state_set)
    __swig_setmethods__["open_price"] = _MT4ManagerAPI.TradeRecord_open_price_set
    __swig_getmethods__["open_price"] = _MT4ManagerAPI.TradeRecord_open_price_get
    if _newclass:
        open_price = _swig_property(_MT4ManagerAPI.TradeRecord_open_price_get, _MT4ManagerAPI.TradeRecord_open_price_set)
    __swig_setmethods__["sl"] = _MT4ManagerAPI.TradeRecord_sl_set
    __swig_getmethods__["sl"] = _MT4ManagerAPI.TradeRecord_sl_get
    if _newclass:
        sl = _swig_property(_MT4ManagerAPI.TradeRecord_sl_get, _MT4ManagerAPI.TradeRecord_sl_set)
    __swig_setmethods__["tp"] = _MT4ManagerAPI.TradeRecord_tp_set
    __swig_getmethods__["tp"] = _MT4ManagerAPI.TradeRecord_tp_get
    if _newclass:
        tp = _swig_property(_MT4ManagerAPI.TradeRecord_tp_get, _MT4ManagerAPI.TradeRecord_tp_set)
    __swig_setmethods__["close_time"] = _MT4ManagerAPI.TradeRecord_close_time_set
    __swig_getmethods__["close_time"] = _MT4ManagerAPI.TradeRecord_close_time_get
    if _newclass:
        close_time = _swig_property(_MT4ManagerAPI.TradeRecord_close_time_get, _MT4ManagerAPI.TradeRecord_close_time_set)
    __swig_setmethods__["value_date"] = _MT4ManagerAPI.TradeRecord_value_date_set
    __swig_getmethods__["value_date"] = _MT4ManagerAPI.TradeRecord_value_date_get
    if _newclass:
        value_date = _swig_property(_MT4ManagerAPI.TradeRecord_value_date_get, _MT4ManagerAPI.TradeRecord_value_date_set)
    __swig_setmethods__["expiration"] = _MT4ManagerAPI.TradeRecord_expiration_set
    __swig_getmethods__["expiration"] = _MT4ManagerAPI.TradeRecord_expiration_get
    if _newclass:
        expiration = _swig_property(_MT4ManagerAPI.TradeRecord_expiration_get, _MT4ManagerAPI.TradeRecord_expiration_set)
    __swig_setmethods__["reason"] = _MT4ManagerAPI.TradeRecord_reason_set
    __swig_getmethods__["reason"] = _MT4ManagerAPI.TradeRecord_reason_get
    if _newclass:
        reason = _swig_property(_MT4ManagerAPI.TradeRecord_reason_get, _MT4ManagerAPI.TradeRecord_reason_set)
    __swig_setmethods__["conv_reserv"] = _MT4ManagerAPI.TradeRecord_conv_reserv_set
    __swig_getmethods__["conv_reserv"] = _MT4ManagerAPI.TradeRecord_conv_reserv_get
    if _newclass:
        conv_reserv = _swig_property(_MT4ManagerAPI.TradeRecord_conv_reserv_get, _MT4ManagerAPI.TradeRecord_conv_reserv_set)
    __swig_setmethods__["conv_rates"] = _MT4ManagerAPI.TradeRecord_conv_rates_set
    __swig_getmethods__["conv_rates"] = _MT4ManagerAPI.TradeRecord_conv_rates_get
    if _newclass:
        conv_rates = _swig_property(_MT4ManagerAPI.TradeRecord_conv_rates_get, _MT4ManagerAPI.TradeRecord_conv_rates_set)
    __swig_setmethods__["commission"] = _MT4ManagerAPI.TradeRecord_commission_set
    __swig_getmethods__["commission"] = _MT4ManagerAPI.TradeRecord_commission_get
    if _newclass:
        commission = _swig_property(_MT4ManagerAPI.TradeRecord_commission_get, _MT4ManagerAPI.TradeRecord_commission_set)
    __swig_setmethods__["commission_agent"] = _MT4ManagerAPI.TradeRecord_commission_agent_set
    __swig_getmethods__["commission_agent"] = _MT4ManagerAPI.TradeRecord_commission_agent_get
    if _newclass:
        commission_agent = _swig_property(_MT4ManagerAPI.TradeRecord_commission_agent_get, _MT4ManagerAPI.TradeRecord_commission_agent_set)
    __swig_setmethods__["storage"] = _MT4ManagerAPI.TradeRecord_storage_set
    __swig_getmethods__["storage"] = _MT4ManagerAPI.TradeRecord_storage_get
    if _newclass:
        storage = _swig_property(_MT4ManagerAPI.TradeRecord_storage_get, _MT4ManagerAPI.TradeRecord_storage_set)
    __swig_setmethods__["close_price"] = _MT4ManagerAPI.TradeRecord_close_price_set
    __swig_getmethods__["close_price"] = _MT4ManagerAPI.TradeRecord_close_price_get
    if _newclass:
        close_price = _swig_property(_MT4ManagerAPI.TradeRecord_close_price_get, _MT4ManagerAPI.TradeRecord_close_price_set)
    __swig_setmethods__["profit"] = _MT4ManagerAPI.TradeRecord_profit_set
    __swig_getmethods__["profit"] = _MT4ManagerAPI.TradeRecord_profit_get
    if _newclass:
        profit = _swig_property(_MT4ManagerAPI.TradeRecord_profit_get, _MT4ManagerAPI.TradeRecord_profit_set)
    __swig_setmethods__["taxes"] = _MT4ManagerAPI.TradeRecord_taxes_set
    __swig_getmethods__["taxes"] = _MT4ManagerAPI.TradeRecord_taxes_get
    if _newclass:
        taxes = _swig_property(_MT4ManagerAPI.TradeRecord_taxes_get, _MT4ManagerAPI.TradeRecord_taxes_set)
    __swig_setmethods__["magic"] = _MT4ManagerAPI.TradeRecord_magic_set
    __swig_getmethods__["magic"] = _MT4ManagerAPI.TradeRecord_magic_get
    if _newclass:
        magic = _swig_property(_MT4ManagerAPI.TradeRecord_magic_get, _MT4ManagerAPI.TradeRecord_magic_set)
    __swig_setmethods__["comment"] = _MT4ManagerAPI.TradeRecord_comment_set
    __swig_getmethods__["comment"] = _MT4ManagerAPI.TradeRecord_comment_get
    if _newclass:
        comment = _swig_property(_MT4ManagerAPI.TradeRecord_comment_get, _MT4ManagerAPI.TradeRecord_comment_set)
    __swig_setmethods__["internal_id"] = _MT4ManagerAPI.TradeRecord_internal_id_set
    __swig_getmethods__["internal_id"] = _MT4ManagerAPI.TradeRecord_internal_id_get
    if _newclass:
        internal_id = _swig_property(_MT4ManagerAPI.TradeRecord_internal_id_get, _MT4ManagerAPI.TradeRecord_internal_id_set)
    __swig_setmethods__["activation"] = _MT4ManagerAPI.TradeRecord_activation_set
    __swig_getmethods__["activation"] = _MT4ManagerAPI.TradeRecord_activation_get
    if _newclass:
        activation = _swig_property(_MT4ManagerAPI.TradeRecord_activation_get, _MT4ManagerAPI.TradeRecord_activation_set)
    __swig_setmethods__["spread"] = _MT4ManagerAPI.TradeRecord_spread_set
    __swig_getmethods__["spread"] = _MT4ManagerAPI.TradeRecord_spread_get
    if _newclass:
        spread = _swig_property(_MT4ManagerAPI.TradeRecord_spread_get, _MT4ManagerAPI.TradeRecord_spread_set)
    __swig_setmethods__["margin_rate"] = _MT4ManagerAPI.TradeRecord_margin_rate_set
    __swig_getmethods__["margin_rate"] = _MT4ManagerAPI.TradeRecord_margin_rate_get
    if _newclass:
        margin_rate = _swig_property(_MT4ManagerAPI.TradeRecord_margin_rate_get, _MT4ManagerAPI.TradeRecord_margin_rate_set)
    __swig_setmethods__["timestamp"] = _MT4ManagerAPI.TradeRecord_timestamp_set
    __swig_getmethods__["timestamp"] = _MT4ManagerAPI.TradeRecord_timestamp_get
    if _newclass:
        timestamp = _swig_property(_MT4ManagerAPI.TradeRecord_timestamp_get, _MT4ManagerAPI.TradeRecord_timestamp_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.TradeRecord_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.TradeRecord_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.TradeRecord_reserved_get, _MT4ManagerAPI.TradeRecord_reserved_set)
    __swig_setmethods__["next"] = _MT4ManagerAPI.TradeRecord_next_set
    __swig_getmethods__["next"] = _MT4ManagerAPI.TradeRecord_next_get
    if _newclass:
        next = _swig_property(_MT4ManagerAPI.TradeRecord_next_get, _MT4ManagerAPI.TradeRecord_next_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_TradeRecord()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_TradeRecord
    __del__ = lambda self: None
TradeRecord_swigregister = _MT4ManagerAPI.TradeRecord_swigregister
TradeRecord_swigregister(TradeRecord)

OP_BUY = _MT4ManagerAPI.OP_BUY
OP_SELL = _MT4ManagerAPI.OP_SELL
OP_BUY_LIMIT = _MT4ManagerAPI.OP_BUY_LIMIT
OP_SELL_LIMIT = _MT4ManagerAPI.OP_SELL_LIMIT
OP_BUY_STOP = _MT4ManagerAPI.OP_BUY_STOP
OP_SELL_STOP = _MT4ManagerAPI.OP_SELL_STOP
OP_BALANCE = _MT4ManagerAPI.OP_BALANCE
OP_CREDIT = _MT4ManagerAPI.OP_CREDIT
TS_OPEN_NORMAL = _MT4ManagerAPI.TS_OPEN_NORMAL
TS_OPEN_REMAND = _MT4ManagerAPI.TS_OPEN_REMAND
TS_OPEN_RESTORED = _MT4ManagerAPI.TS_OPEN_RESTORED
TS_CLOSED_NORMAL = _MT4ManagerAPI.TS_CLOSED_NORMAL
TS_CLOSED_PART = _MT4ManagerAPI.TS_CLOSED_PART
TS_CLOSED_BY = _MT4ManagerAPI.TS_CLOSED_BY
TS_DELETED = _MT4ManagerAPI.TS_DELETED
TR_REASON_CLIENT = _MT4ManagerAPI.TR_REASON_CLIENT
TR_REASON_EXPERT = _MT4ManagerAPI.TR_REASON_EXPERT
TR_REASON_DEALER = _MT4ManagerAPI.TR_REASON_DEALER
TR_REASON_SIGNAL = _MT4ManagerAPI.TR_REASON_SIGNAL
TR_REASON_GATEWAY = _MT4ManagerAPI.TR_REASON_GATEWAY
ACTIVATION_NONE = _MT4ManagerAPI.ACTIVATION_NONE
ACTIVATION_SL = _MT4ManagerAPI.ACTIVATION_SL
ACTIVATION_TP = _MT4ManagerAPI.ACTIVATION_TP
ACTIVATION_PENDING = _MT4ManagerAPI.ACTIVATION_PENDING
ACTIVATION_STOPOUT = _MT4ManagerAPI.ACTIVATION_STOPOUT
ACTIVATION_SL_ROLLBACK = _MT4ManagerAPI.ACTIVATION_SL_ROLLBACK
ACTIVATION_TP_ROLLBACK = _MT4ManagerAPI.ACTIVATION_TP_ROLLBACK
ACTIVATION_PENDING_ROLLBACK = _MT4ManagerAPI.ACTIVATION_PENDING_ROLLBACK
ACTIVATION_STOPOUT_ROLLBACK = _MT4ManagerAPI.ACTIVATION_STOPOUT_ROLLBACK
class TradeRestoreResult(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TradeRestoreResult, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TradeRestoreResult, name)
    __repr__ = _swig_repr
    __swig_setmethods__["order"] = _MT4ManagerAPI.TradeRestoreResult_order_set
    __swig_getmethods__["order"] = _MT4ManagerAPI.TradeRestoreResult_order_get
    if _newclass:
        order = _swig_property(_MT4ManagerAPI.TradeRestoreResult_order_get, _MT4ManagerAPI.TradeRestoreResult_order_set)
    __swig_setmethods__["res"] = _MT4ManagerAPI.TradeRestoreResult_res_set
    __swig_getmethods__["res"] = _MT4ManagerAPI.TradeRestoreResult_res_get
    if _newclass:
        res = _swig_property(_MT4ManagerAPI.TradeRestoreResult_res_get, _MT4ManagerAPI.TradeRestoreResult_res_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_TradeRestoreResult()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_TradeRestoreResult
    __del__ = lambda self: None
TradeRestoreResult_swigregister = _MT4ManagerAPI.TradeRestoreResult_swigregister
TradeRestoreResult_swigregister(TradeRestoreResult)

class TradeTransInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TradeTransInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TradeTransInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _MT4ManagerAPI.TradeTransInfo_type_set
    __swig_getmethods__["type"] = _MT4ManagerAPI.TradeTransInfo_type_get
    if _newclass:
        type = _swig_property(_MT4ManagerAPI.TradeTransInfo_type_get, _MT4ManagerAPI.TradeTransInfo_type_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.TradeTransInfo_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.TradeTransInfo_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.TradeTransInfo_reserved_get, _MT4ManagerAPI.TradeTransInfo_reserved_set)
    __swig_setmethods__["cmd"] = _MT4ManagerAPI.TradeTransInfo_cmd_set
    __swig_getmethods__["cmd"] = _MT4ManagerAPI.TradeTransInfo_cmd_get
    if _newclass:
        cmd = _swig_property(_MT4ManagerAPI.TradeTransInfo_cmd_get, _MT4ManagerAPI.TradeTransInfo_cmd_set)
    __swig_setmethods__["order"] = _MT4ManagerAPI.TradeTransInfo_order_set
    __swig_getmethods__["order"] = _MT4ManagerAPI.TradeTransInfo_order_get
    if _newclass:
        order = _swig_property(_MT4ManagerAPI.TradeTransInfo_order_get, _MT4ManagerAPI.TradeTransInfo_order_set)
    __swig_setmethods__["orderby"] = _MT4ManagerAPI.TradeTransInfo_orderby_set
    __swig_getmethods__["orderby"] = _MT4ManagerAPI.TradeTransInfo_orderby_get
    if _newclass:
        orderby = _swig_property(_MT4ManagerAPI.TradeTransInfo_orderby_get, _MT4ManagerAPI.TradeTransInfo_orderby_set)
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.TradeTransInfo_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.TradeTransInfo_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.TradeTransInfo_symbol_get, _MT4ManagerAPI.TradeTransInfo_symbol_set)
    __swig_setmethods__["volume"] = _MT4ManagerAPI.TradeTransInfo_volume_set
    __swig_getmethods__["volume"] = _MT4ManagerAPI.TradeTransInfo_volume_get
    if _newclass:
        volume = _swig_property(_MT4ManagerAPI.TradeTransInfo_volume_get, _MT4ManagerAPI.TradeTransInfo_volume_set)
    __swig_setmethods__["price"] = _MT4ManagerAPI.TradeTransInfo_price_set
    __swig_getmethods__["price"] = _MT4ManagerAPI.TradeTransInfo_price_get
    if _newclass:
        price = _swig_property(_MT4ManagerAPI.TradeTransInfo_price_get, _MT4ManagerAPI.TradeTransInfo_price_set)
    __swig_setmethods__["sl"] = _MT4ManagerAPI.TradeTransInfo_sl_set
    __swig_getmethods__["sl"] = _MT4ManagerAPI.TradeTransInfo_sl_get
    if _newclass:
        sl = _swig_property(_MT4ManagerAPI.TradeTransInfo_sl_get, _MT4ManagerAPI.TradeTransInfo_sl_set)
    __swig_setmethods__["tp"] = _MT4ManagerAPI.TradeTransInfo_tp_set
    __swig_getmethods__["tp"] = _MT4ManagerAPI.TradeTransInfo_tp_get
    if _newclass:
        tp = _swig_property(_MT4ManagerAPI.TradeTransInfo_tp_get, _MT4ManagerAPI.TradeTransInfo_tp_set)
    __swig_setmethods__["ie_deviation"] = _MT4ManagerAPI.TradeTransInfo_ie_deviation_set
    __swig_getmethods__["ie_deviation"] = _MT4ManagerAPI.TradeTransInfo_ie_deviation_get
    if _newclass:
        ie_deviation = _swig_property(_MT4ManagerAPI.TradeTransInfo_ie_deviation_get, _MT4ManagerAPI.TradeTransInfo_ie_deviation_set)
    __swig_setmethods__["comment"] = _MT4ManagerAPI.TradeTransInfo_comment_set
    __swig_getmethods__["comment"] = _MT4ManagerAPI.TradeTransInfo_comment_get
    if _newclass:
        comment = _swig_property(_MT4ManagerAPI.TradeTransInfo_comment_get, _MT4ManagerAPI.TradeTransInfo_comment_set)
    __swig_setmethods__["expiration"] = _MT4ManagerAPI.TradeTransInfo_expiration_set
    __swig_getmethods__["expiration"] = _MT4ManagerAPI.TradeTransInfo_expiration_get
    if _newclass:
        expiration = _swig_property(_MT4ManagerAPI.TradeTransInfo_expiration_get, _MT4ManagerAPI.TradeTransInfo_expiration_set)
    __swig_setmethods__["crc"] = _MT4ManagerAPI.TradeTransInfo_crc_set
    __swig_getmethods__["crc"] = _MT4ManagerAPI.TradeTransInfo_crc_get
    if _newclass:
        crc = _swig_property(_MT4ManagerAPI.TradeTransInfo_crc_get, _MT4ManagerAPI.TradeTransInfo_crc_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_TradeTransInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_TradeTransInfo
    __del__ = lambda self: None
TradeTransInfo_swigregister = _MT4ManagerAPI.TradeTransInfo_swigregister
TradeTransInfo_swigregister(TradeTransInfo)

TT_PRICES_GET = _MT4ManagerAPI.TT_PRICES_GET
TT_PRICES_REQUOTE = _MT4ManagerAPI.TT_PRICES_REQUOTE
TT_ORDER_IE_OPEN = _MT4ManagerAPI.TT_ORDER_IE_OPEN
TT_ORDER_REQ_OPEN = _MT4ManagerAPI.TT_ORDER_REQ_OPEN
TT_ORDER_MK_OPEN = _MT4ManagerAPI.TT_ORDER_MK_OPEN
TT_ORDER_PENDING_OPEN = _MT4ManagerAPI.TT_ORDER_PENDING_OPEN
TT_ORDER_IE_CLOSE = _MT4ManagerAPI.TT_ORDER_IE_CLOSE
TT_ORDER_REQ_CLOSE = _MT4ManagerAPI.TT_ORDER_REQ_CLOSE
TT_ORDER_MK_CLOSE = _MT4ManagerAPI.TT_ORDER_MK_CLOSE
TT_ORDER_MODIFY = _MT4ManagerAPI.TT_ORDER_MODIFY
TT_ORDER_DELETE = _MT4ManagerAPI.TT_ORDER_DELETE
TT_ORDER_CLOSE_BY = _MT4ManagerAPI.TT_ORDER_CLOSE_BY
TT_ORDER_CLOSE_ALL = _MT4ManagerAPI.TT_ORDER_CLOSE_ALL
TT_BR_ORDER_OPEN = _MT4ManagerAPI.TT_BR_ORDER_OPEN
TT_BR_ORDER_CLOSE = _MT4ManagerAPI.TT_BR_ORDER_CLOSE
TT_BR_ORDER_DELETE = _MT4ManagerAPI.TT_BR_ORDER_DELETE
TT_BR_ORDER_CLOSE_BY = _MT4ManagerAPI.TT_BR_ORDER_CLOSE_BY
TT_BR_ORDER_CLOSE_ALL = _MT4ManagerAPI.TT_BR_ORDER_CLOSE_ALL
TT_BR_ORDER_MODIFY = _MT4ManagerAPI.TT_BR_ORDER_MODIFY
TT_BR_ORDER_ACTIVATE = _MT4ManagerAPI.TT_BR_ORDER_ACTIVATE
TT_BR_ORDER_COMMENT = _MT4ManagerAPI.TT_BR_ORDER_COMMENT
TT_BR_BALANCE = _MT4ManagerAPI.TT_BR_BALANCE
class MarginLevel(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MarginLevel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MarginLevel, name)
    __repr__ = _swig_repr
    __swig_setmethods__["login"] = _MT4ManagerAPI.MarginLevel_login_set
    __swig_getmethods__["login"] = _MT4ManagerAPI.MarginLevel_login_get
    if _newclass:
        login = _swig_property(_MT4ManagerAPI.MarginLevel_login_get, _MT4ManagerAPI.MarginLevel_login_set)
    __swig_setmethods__["group"] = _MT4ManagerAPI.MarginLevel_group_set
    __swig_getmethods__["group"] = _MT4ManagerAPI.MarginLevel_group_get
    if _newclass:
        group = _swig_property(_MT4ManagerAPI.MarginLevel_group_get, _MT4ManagerAPI.MarginLevel_group_set)
    __swig_setmethods__["leverage"] = _MT4ManagerAPI.MarginLevel_leverage_set
    __swig_getmethods__["leverage"] = _MT4ManagerAPI.MarginLevel_leverage_get
    if _newclass:
        leverage = _swig_property(_MT4ManagerAPI.MarginLevel_leverage_get, _MT4ManagerAPI.MarginLevel_leverage_set)
    __swig_setmethods__["updated"] = _MT4ManagerAPI.MarginLevel_updated_set
    __swig_getmethods__["updated"] = _MT4ManagerAPI.MarginLevel_updated_get
    if _newclass:
        updated = _swig_property(_MT4ManagerAPI.MarginLevel_updated_get, _MT4ManagerAPI.MarginLevel_updated_set)
    __swig_setmethods__["balance"] = _MT4ManagerAPI.MarginLevel_balance_set
    __swig_getmethods__["balance"] = _MT4ManagerAPI.MarginLevel_balance_get
    if _newclass:
        balance = _swig_property(_MT4ManagerAPI.MarginLevel_balance_get, _MT4ManagerAPI.MarginLevel_balance_set)
    __swig_setmethods__["equity"] = _MT4ManagerAPI.MarginLevel_equity_set
    __swig_getmethods__["equity"] = _MT4ManagerAPI.MarginLevel_equity_get
    if _newclass:
        equity = _swig_property(_MT4ManagerAPI.MarginLevel_equity_get, _MT4ManagerAPI.MarginLevel_equity_set)
    __swig_setmethods__["volume"] = _MT4ManagerAPI.MarginLevel_volume_set
    __swig_getmethods__["volume"] = _MT4ManagerAPI.MarginLevel_volume_get
    if _newclass:
        volume = _swig_property(_MT4ManagerAPI.MarginLevel_volume_get, _MT4ManagerAPI.MarginLevel_volume_set)
    __swig_setmethods__["margin"] = _MT4ManagerAPI.MarginLevel_margin_set
    __swig_getmethods__["margin"] = _MT4ManagerAPI.MarginLevel_margin_get
    if _newclass:
        margin = _swig_property(_MT4ManagerAPI.MarginLevel_margin_get, _MT4ManagerAPI.MarginLevel_margin_set)
    __swig_setmethods__["margin_free"] = _MT4ManagerAPI.MarginLevel_margin_free_set
    __swig_getmethods__["margin_free"] = _MT4ManagerAPI.MarginLevel_margin_free_get
    if _newclass:
        margin_free = _swig_property(_MT4ManagerAPI.MarginLevel_margin_free_get, _MT4ManagerAPI.MarginLevel_margin_free_set)
    __swig_setmethods__["margin_level"] = _MT4ManagerAPI.MarginLevel_margin_level_set
    __swig_getmethods__["margin_level"] = _MT4ManagerAPI.MarginLevel_margin_level_get
    if _newclass:
        margin_level = _swig_property(_MT4ManagerAPI.MarginLevel_margin_level_get, _MT4ManagerAPI.MarginLevel_margin_level_set)
    __swig_setmethods__["margin_type"] = _MT4ManagerAPI.MarginLevel_margin_type_set
    __swig_getmethods__["margin_type"] = _MT4ManagerAPI.MarginLevel_margin_type_get
    if _newclass:
        margin_type = _swig_property(_MT4ManagerAPI.MarginLevel_margin_type_get, _MT4ManagerAPI.MarginLevel_margin_type_set)
    __swig_setmethods__["level_type"] = _MT4ManagerAPI.MarginLevel_level_type_set
    __swig_getmethods__["level_type"] = _MT4ManagerAPI.MarginLevel_level_type_get
    if _newclass:
        level_type = _swig_property(_MT4ManagerAPI.MarginLevel_level_type_get, _MT4ManagerAPI.MarginLevel_level_type_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_MarginLevel()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_MarginLevel
    __del__ = lambda self: None
MarginLevel_swigregister = _MT4ManagerAPI.MarginLevel_swigregister
MarginLevel_swigregister(MarginLevel)

MARGINLEVEL_OK = _MT4ManagerAPI.MARGINLEVEL_OK
MARGINLEVEL_MARGINCALL = _MT4ManagerAPI.MARGINLEVEL_MARGINCALL
MARGINLEVEL_STOPOUT = _MT4ManagerAPI.MARGINLEVEL_STOPOUT
class RequestInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RequestInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RequestInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["id"] = _MT4ManagerAPI.RequestInfo_id_set
    __swig_getmethods__["id"] = _MT4ManagerAPI.RequestInfo_id_get
    if _newclass:
        id = _swig_property(_MT4ManagerAPI.RequestInfo_id_get, _MT4ManagerAPI.RequestInfo_id_set)
    __swig_setmethods__["status"] = _MT4ManagerAPI.RequestInfo_status_set
    __swig_getmethods__["status"] = _MT4ManagerAPI.RequestInfo_status_get
    if _newclass:
        status = _swig_property(_MT4ManagerAPI.RequestInfo_status_get, _MT4ManagerAPI.RequestInfo_status_set)
    __swig_setmethods__["time"] = _MT4ManagerAPI.RequestInfo_time_set
    __swig_getmethods__["time"] = _MT4ManagerAPI.RequestInfo_time_get
    if _newclass:
        time = _swig_property(_MT4ManagerAPI.RequestInfo_time_get, _MT4ManagerAPI.RequestInfo_time_set)
    __swig_setmethods__["manager"] = _MT4ManagerAPI.RequestInfo_manager_set
    __swig_getmethods__["manager"] = _MT4ManagerAPI.RequestInfo_manager_get
    if _newclass:
        manager = _swig_property(_MT4ManagerAPI.RequestInfo_manager_get, _MT4ManagerAPI.RequestInfo_manager_set)
    __swig_setmethods__["login"] = _MT4ManagerAPI.RequestInfo_login_set
    __swig_getmethods__["login"] = _MT4ManagerAPI.RequestInfo_login_get
    if _newclass:
        login = _swig_property(_MT4ManagerAPI.RequestInfo_login_get, _MT4ManagerAPI.RequestInfo_login_set)
    __swig_setmethods__["group"] = _MT4ManagerAPI.RequestInfo_group_set
    __swig_getmethods__["group"] = _MT4ManagerAPI.RequestInfo_group_get
    if _newclass:
        group = _swig_property(_MT4ManagerAPI.RequestInfo_group_get, _MT4ManagerAPI.RequestInfo_group_set)
    __swig_setmethods__["balance"] = _MT4ManagerAPI.RequestInfo_balance_set
    __swig_getmethods__["balance"] = _MT4ManagerAPI.RequestInfo_balance_get
    if _newclass:
        balance = _swig_property(_MT4ManagerAPI.RequestInfo_balance_get, _MT4ManagerAPI.RequestInfo_balance_set)
    __swig_setmethods__["credit"] = _MT4ManagerAPI.RequestInfo_credit_set
    __swig_getmethods__["credit"] = _MT4ManagerAPI.RequestInfo_credit_get
    if _newclass:
        credit = _swig_property(_MT4ManagerAPI.RequestInfo_credit_get, _MT4ManagerAPI.RequestInfo_credit_set)
    __swig_setmethods__["prices"] = _MT4ManagerAPI.RequestInfo_prices_set
    __swig_getmethods__["prices"] = _MT4ManagerAPI.RequestInfo_prices_get
    if _newclass:
        prices = _swig_property(_MT4ManagerAPI.RequestInfo_prices_get, _MT4ManagerAPI.RequestInfo_prices_set)
    __swig_setmethods__["trade"] = _MT4ManagerAPI.RequestInfo_trade_set
    __swig_getmethods__["trade"] = _MT4ManagerAPI.RequestInfo_trade_get
    if _newclass:
        trade = _swig_property(_MT4ManagerAPI.RequestInfo_trade_get, _MT4ManagerAPI.RequestInfo_trade_set)
    __swig_setmethods__["trade_group"] = _MT4ManagerAPI.RequestInfo_trade_group_set
    __swig_getmethods__["trade_group"] = _MT4ManagerAPI.RequestInfo_trade_group_get
    if _newclass:
        trade_group = _swig_property(_MT4ManagerAPI.RequestInfo_trade_group_get, _MT4ManagerAPI.RequestInfo_trade_group_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.RequestInfo_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.RequestInfo_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.RequestInfo_reserved_get, _MT4ManagerAPI.RequestInfo_reserved_set)
    __swig_setmethods__["prev"] = _MT4ManagerAPI.RequestInfo_prev_set
    __swig_getmethods__["prev"] = _MT4ManagerAPI.RequestInfo_prev_get
    if _newclass:
        prev = _swig_property(_MT4ManagerAPI.RequestInfo_prev_get, _MT4ManagerAPI.RequestInfo_prev_set)
    __swig_setmethods__["next"] = _MT4ManagerAPI.RequestInfo_next_set
    __swig_getmethods__["next"] = _MT4ManagerAPI.RequestInfo_next_get
    if _newclass:
        next = _swig_property(_MT4ManagerAPI.RequestInfo_next_get, _MT4ManagerAPI.RequestInfo_next_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_RequestInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_RequestInfo
    __del__ = lambda self: None
RequestInfo_swigregister = _MT4ManagerAPI.RequestInfo_swigregister
RequestInfo_swigregister(RequestInfo)

DC_EMPTY = _MT4ManagerAPI.DC_EMPTY
DC_REQUEST = _MT4ManagerAPI.DC_REQUEST
DC_LOCKED = _MT4ManagerAPI.DC_LOCKED
DC_ANSWERED = _MT4ManagerAPI.DC_ANSWERED
DC_RESETED = _MT4ManagerAPI.DC_RESETED
DC_CANCELED = _MT4ManagerAPI.DC_CANCELED
CONFIRM_MODE_ADD_PRICES = _MT4ManagerAPI.CONFIRM_MODE_ADD_PRICES
CONFIRM_MODE_PACKET = _MT4ManagerAPI.CONFIRM_MODE_PACKET
class DailyReport(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DailyReport, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DailyReport, name)
    __repr__ = _swig_repr
    __swig_setmethods__["login"] = _MT4ManagerAPI.DailyReport_login_set
    __swig_getmethods__["login"] = _MT4ManagerAPI.DailyReport_login_get
    if _newclass:
        login = _swig_property(_MT4ManagerAPI.DailyReport_login_get, _MT4ManagerAPI.DailyReport_login_set)
    __swig_setmethods__["ctm"] = _MT4ManagerAPI.DailyReport_ctm_set
    __swig_getmethods__["ctm"] = _MT4ManagerAPI.DailyReport_ctm_get
    if _newclass:
        ctm = _swig_property(_MT4ManagerAPI.DailyReport_ctm_get, _MT4ManagerAPI.DailyReport_ctm_set)
    __swig_setmethods__["group"] = _MT4ManagerAPI.DailyReport_group_set
    __swig_getmethods__["group"] = _MT4ManagerAPI.DailyReport_group_get
    if _newclass:
        group = _swig_property(_MT4ManagerAPI.DailyReport_group_get, _MT4ManagerAPI.DailyReport_group_set)
    __swig_setmethods__["bank"] = _MT4ManagerAPI.DailyReport_bank_set
    __swig_getmethods__["bank"] = _MT4ManagerAPI.DailyReport_bank_get
    if _newclass:
        bank = _swig_property(_MT4ManagerAPI.DailyReport_bank_get, _MT4ManagerAPI.DailyReport_bank_set)
    __swig_setmethods__["balance_prev"] = _MT4ManagerAPI.DailyReport_balance_prev_set
    __swig_getmethods__["balance_prev"] = _MT4ManagerAPI.DailyReport_balance_prev_get
    if _newclass:
        balance_prev = _swig_property(_MT4ManagerAPI.DailyReport_balance_prev_get, _MT4ManagerAPI.DailyReport_balance_prev_set)
    __swig_setmethods__["balance"] = _MT4ManagerAPI.DailyReport_balance_set
    __swig_getmethods__["balance"] = _MT4ManagerAPI.DailyReport_balance_get
    if _newclass:
        balance = _swig_property(_MT4ManagerAPI.DailyReport_balance_get, _MT4ManagerAPI.DailyReport_balance_set)
    __swig_setmethods__["deposit"] = _MT4ManagerAPI.DailyReport_deposit_set
    __swig_getmethods__["deposit"] = _MT4ManagerAPI.DailyReport_deposit_get
    if _newclass:
        deposit = _swig_property(_MT4ManagerAPI.DailyReport_deposit_get, _MT4ManagerAPI.DailyReport_deposit_set)
    __swig_setmethods__["credit"] = _MT4ManagerAPI.DailyReport_credit_set
    __swig_getmethods__["credit"] = _MT4ManagerAPI.DailyReport_credit_get
    if _newclass:
        credit = _swig_property(_MT4ManagerAPI.DailyReport_credit_get, _MT4ManagerAPI.DailyReport_credit_set)
    __swig_setmethods__["profit_closed"] = _MT4ManagerAPI.DailyReport_profit_closed_set
    __swig_getmethods__["profit_closed"] = _MT4ManagerAPI.DailyReport_profit_closed_get
    if _newclass:
        profit_closed = _swig_property(_MT4ManagerAPI.DailyReport_profit_closed_get, _MT4ManagerAPI.DailyReport_profit_closed_set)
    __swig_setmethods__["profit"] = _MT4ManagerAPI.DailyReport_profit_set
    __swig_getmethods__["profit"] = _MT4ManagerAPI.DailyReport_profit_get
    if _newclass:
        profit = _swig_property(_MT4ManagerAPI.DailyReport_profit_get, _MT4ManagerAPI.DailyReport_profit_set)
    __swig_setmethods__["equity"] = _MT4ManagerAPI.DailyReport_equity_set
    __swig_getmethods__["equity"] = _MT4ManagerAPI.DailyReport_equity_get
    if _newclass:
        equity = _swig_property(_MT4ManagerAPI.DailyReport_equity_get, _MT4ManagerAPI.DailyReport_equity_set)
    __swig_setmethods__["margin"] = _MT4ManagerAPI.DailyReport_margin_set
    __swig_getmethods__["margin"] = _MT4ManagerAPI.DailyReport_margin_get
    if _newclass:
        margin = _swig_property(_MT4ManagerAPI.DailyReport_margin_get, _MT4ManagerAPI.DailyReport_margin_set)
    __swig_setmethods__["margin_free"] = _MT4ManagerAPI.DailyReport_margin_free_set
    __swig_getmethods__["margin_free"] = _MT4ManagerAPI.DailyReport_margin_free_get
    if _newclass:
        margin_free = _swig_property(_MT4ManagerAPI.DailyReport_margin_free_get, _MT4ManagerAPI.DailyReport_margin_free_set)
    __swig_setmethods__["next"] = _MT4ManagerAPI.DailyReport_next_set
    __swig_getmethods__["next"] = _MT4ManagerAPI.DailyReport_next_get
    if _newclass:
        next = _swig_property(_MT4ManagerAPI.DailyReport_next_get, _MT4ManagerAPI.DailyReport_next_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.DailyReport_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.DailyReport_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.DailyReport_reserved_get, _MT4ManagerAPI.DailyReport_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_DailyReport()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_DailyReport
    __del__ = lambda self: None
DailyReport_swigregister = _MT4ManagerAPI.DailyReport_swigregister
DailyReport_swigregister(DailyReport)

class ReportGroupRequest(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReportGroupRequest, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ReportGroupRequest, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _MT4ManagerAPI.ReportGroupRequest_name_set
    __swig_getmethods__["name"] = _MT4ManagerAPI.ReportGroupRequest_name_get
    if _newclass:
        name = _swig_property(_MT4ManagerAPI.ReportGroupRequest_name_get, _MT4ManagerAPI.ReportGroupRequest_name_set)
    __swig_setmethods__["_from"] = _MT4ManagerAPI.ReportGroupRequest__from_set
    __swig_getmethods__["_from"] = _MT4ManagerAPI.ReportGroupRequest__from_get
    if _newclass:
        _from = _swig_property(_MT4ManagerAPI.ReportGroupRequest__from_get, _MT4ManagerAPI.ReportGroupRequest__from_set)
    __swig_setmethods__["to"] = _MT4ManagerAPI.ReportGroupRequest_to_set
    __swig_getmethods__["to"] = _MT4ManagerAPI.ReportGroupRequest_to_get
    if _newclass:
        to = _swig_property(_MT4ManagerAPI.ReportGroupRequest_to_get, _MT4ManagerAPI.ReportGroupRequest_to_set)
    __swig_setmethods__["total"] = _MT4ManagerAPI.ReportGroupRequest_total_set
    __swig_getmethods__["total"] = _MT4ManagerAPI.ReportGroupRequest_total_get
    if _newclass:
        total = _swig_property(_MT4ManagerAPI.ReportGroupRequest_total_get, _MT4ManagerAPI.ReportGroupRequest_total_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ReportGroupRequest()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ReportGroupRequest
    __del__ = lambda self: None
ReportGroupRequest_swigregister = _MT4ManagerAPI.ReportGroupRequest_swigregister
ReportGroupRequest_swigregister(ReportGroupRequest)

class DailyGroupRequest(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DailyGroupRequest, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DailyGroupRequest, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _MT4ManagerAPI.DailyGroupRequest_name_set
    __swig_getmethods__["name"] = _MT4ManagerAPI.DailyGroupRequest_name_get
    if _newclass:
        name = _swig_property(_MT4ManagerAPI.DailyGroupRequest_name_get, _MT4ManagerAPI.DailyGroupRequest_name_set)
    __swig_setmethods__["_from"] = _MT4ManagerAPI.DailyGroupRequest__from_set
    __swig_getmethods__["_from"] = _MT4ManagerAPI.DailyGroupRequest__from_get
    if _newclass:
        _from = _swig_property(_MT4ManagerAPI.DailyGroupRequest__from_get, _MT4ManagerAPI.DailyGroupRequest__from_set)
    __swig_setmethods__["to"] = _MT4ManagerAPI.DailyGroupRequest_to_set
    __swig_getmethods__["to"] = _MT4ManagerAPI.DailyGroupRequest_to_get
    if _newclass:
        to = _swig_property(_MT4ManagerAPI.DailyGroupRequest_to_get, _MT4ManagerAPI.DailyGroupRequest_to_set)
    __swig_setmethods__["total"] = _MT4ManagerAPI.DailyGroupRequest_total_set
    __swig_getmethods__["total"] = _MT4ManagerAPI.DailyGroupRequest_total_get
    if _newclass:
        total = _swig_property(_MT4ManagerAPI.DailyGroupRequest_total_get, _MT4ManagerAPI.DailyGroupRequest_total_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.DailyGroupRequest_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.DailyGroupRequest_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.DailyGroupRequest_reserved_get, _MT4ManagerAPI.DailyGroupRequest_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_DailyGroupRequest()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_DailyGroupRequest
    __del__ = lambda self: None
DailyGroupRequest_swigregister = _MT4ManagerAPI.DailyGroupRequest_swigregister
DailyGroupRequest_swigregister(DailyGroupRequest)

class SymbolInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SymbolInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SymbolInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.SymbolInfo_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.SymbolInfo_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.SymbolInfo_symbol_get, _MT4ManagerAPI.SymbolInfo_symbol_set)
    __swig_setmethods__["digits"] = _MT4ManagerAPI.SymbolInfo_digits_set
    __swig_getmethods__["digits"] = _MT4ManagerAPI.SymbolInfo_digits_get
    if _newclass:
        digits = _swig_property(_MT4ManagerAPI.SymbolInfo_digits_get, _MT4ManagerAPI.SymbolInfo_digits_set)
    __swig_setmethods__["count"] = _MT4ManagerAPI.SymbolInfo_count_set
    __swig_getmethods__["count"] = _MT4ManagerAPI.SymbolInfo_count_get
    if _newclass:
        count = _swig_property(_MT4ManagerAPI.SymbolInfo_count_get, _MT4ManagerAPI.SymbolInfo_count_set)
    __swig_setmethods__["visible"] = _MT4ManagerAPI.SymbolInfo_visible_set
    __swig_getmethods__["visible"] = _MT4ManagerAPI.SymbolInfo_visible_get
    if _newclass:
        visible = _swig_property(_MT4ManagerAPI.SymbolInfo_visible_get, _MT4ManagerAPI.SymbolInfo_visible_set)
    __swig_setmethods__["type"] = _MT4ManagerAPI.SymbolInfo_type_set
    __swig_getmethods__["type"] = _MT4ManagerAPI.SymbolInfo_type_get
    if _newclass:
        type = _swig_property(_MT4ManagerAPI.SymbolInfo_type_get, _MT4ManagerAPI.SymbolInfo_type_set)
    __swig_setmethods__["point"] = _MT4ManagerAPI.SymbolInfo_point_set
    __swig_getmethods__["point"] = _MT4ManagerAPI.SymbolInfo_point_get
    if _newclass:
        point = _swig_property(_MT4ManagerAPI.SymbolInfo_point_get, _MT4ManagerAPI.SymbolInfo_point_set)
    __swig_setmethods__["spread"] = _MT4ManagerAPI.SymbolInfo_spread_set
    __swig_getmethods__["spread"] = _MT4ManagerAPI.SymbolInfo_spread_get
    if _newclass:
        spread = _swig_property(_MT4ManagerAPI.SymbolInfo_spread_get, _MT4ManagerAPI.SymbolInfo_spread_set)
    __swig_setmethods__["spread_balance"] = _MT4ManagerAPI.SymbolInfo_spread_balance_set
    __swig_getmethods__["spread_balance"] = _MT4ManagerAPI.SymbolInfo_spread_balance_get
    if _newclass:
        spread_balance = _swig_property(_MT4ManagerAPI.SymbolInfo_spread_balance_get, _MT4ManagerAPI.SymbolInfo_spread_balance_set)
    __swig_setmethods__["direction"] = _MT4ManagerAPI.SymbolInfo_direction_set
    __swig_getmethods__["direction"] = _MT4ManagerAPI.SymbolInfo_direction_get
    if _newclass:
        direction = _swig_property(_MT4ManagerAPI.SymbolInfo_direction_get, _MT4ManagerAPI.SymbolInfo_direction_set)
    __swig_setmethods__["updateflag"] = _MT4ManagerAPI.SymbolInfo_updateflag_set
    __swig_getmethods__["updateflag"] = _MT4ManagerAPI.SymbolInfo_updateflag_get
    if _newclass:
        updateflag = _swig_property(_MT4ManagerAPI.SymbolInfo_updateflag_get, _MT4ManagerAPI.SymbolInfo_updateflag_set)
    __swig_setmethods__["lasttime"] = _MT4ManagerAPI.SymbolInfo_lasttime_set
    __swig_getmethods__["lasttime"] = _MT4ManagerAPI.SymbolInfo_lasttime_get
    if _newclass:
        lasttime = _swig_property(_MT4ManagerAPI.SymbolInfo_lasttime_get, _MT4ManagerAPI.SymbolInfo_lasttime_set)
    __swig_setmethods__["bid"] = _MT4ManagerAPI.SymbolInfo_bid_set
    __swig_getmethods__["bid"] = _MT4ManagerAPI.SymbolInfo_bid_get
    if _newclass:
        bid = _swig_property(_MT4ManagerAPI.SymbolInfo_bid_get, _MT4ManagerAPI.SymbolInfo_bid_set)
    __swig_setmethods__["ask"] = _MT4ManagerAPI.SymbolInfo_ask_set
    __swig_getmethods__["ask"] = _MT4ManagerAPI.SymbolInfo_ask_get
    if _newclass:
        ask = _swig_property(_MT4ManagerAPI.SymbolInfo_ask_get, _MT4ManagerAPI.SymbolInfo_ask_set)
    __swig_setmethods__["high"] = _MT4ManagerAPI.SymbolInfo_high_set
    __swig_getmethods__["high"] = _MT4ManagerAPI.SymbolInfo_high_get
    if _newclass:
        high = _swig_property(_MT4ManagerAPI.SymbolInfo_high_get, _MT4ManagerAPI.SymbolInfo_high_set)
    __swig_setmethods__["low"] = _MT4ManagerAPI.SymbolInfo_low_set
    __swig_getmethods__["low"] = _MT4ManagerAPI.SymbolInfo_low_get
    if _newclass:
        low = _swig_property(_MT4ManagerAPI.SymbolInfo_low_get, _MT4ManagerAPI.SymbolInfo_low_set)
    __swig_setmethods__["commission"] = _MT4ManagerAPI.SymbolInfo_commission_set
    __swig_getmethods__["commission"] = _MT4ManagerAPI.SymbolInfo_commission_get
    if _newclass:
        commission = _swig_property(_MT4ManagerAPI.SymbolInfo_commission_get, _MT4ManagerAPI.SymbolInfo_commission_set)
    __swig_setmethods__["comm_type"] = _MT4ManagerAPI.SymbolInfo_comm_type_set
    __swig_getmethods__["comm_type"] = _MT4ManagerAPI.SymbolInfo_comm_type_get
    if _newclass:
        comm_type = _swig_property(_MT4ManagerAPI.SymbolInfo_comm_type_get, _MT4ManagerAPI.SymbolInfo_comm_type_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_SymbolInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_SymbolInfo
    __del__ = lambda self: None
SymbolInfo_swigregister = _MT4ManagerAPI.SymbolInfo_swigregister
SymbolInfo_swigregister(SymbolInfo)

SDIR_UP = _MT4ManagerAPI.SDIR_UP
SDIR_DOWN = _MT4ManagerAPI.SDIR_DOWN
SDIR_NONE = _MT4ManagerAPI.SDIR_NONE
class SymbolSummary(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SymbolSummary, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SymbolSummary, name)
    __repr__ = _swig_repr
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.SymbolSummary_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.SymbolSummary_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.SymbolSummary_symbol_get, _MT4ManagerAPI.SymbolSummary_symbol_set)
    __swig_setmethods__["count"] = _MT4ManagerAPI.SymbolSummary_count_set
    __swig_getmethods__["count"] = _MT4ManagerAPI.SymbolSummary_count_get
    if _newclass:
        count = _swig_property(_MT4ManagerAPI.SymbolSummary_count_get, _MT4ManagerAPI.SymbolSummary_count_set)
    __swig_setmethods__["digits"] = _MT4ManagerAPI.SymbolSummary_digits_set
    __swig_getmethods__["digits"] = _MT4ManagerAPI.SymbolSummary_digits_get
    if _newclass:
        digits = _swig_property(_MT4ManagerAPI.SymbolSummary_digits_get, _MT4ManagerAPI.SymbolSummary_digits_set)
    __swig_setmethods__["type"] = _MT4ManagerAPI.SymbolSummary_type_set
    __swig_getmethods__["type"] = _MT4ManagerAPI.SymbolSummary_type_get
    if _newclass:
        type = _swig_property(_MT4ManagerAPI.SymbolSummary_type_get, _MT4ManagerAPI.SymbolSummary_type_set)
    __swig_setmethods__["orders"] = _MT4ManagerAPI.SymbolSummary_orders_set
    __swig_getmethods__["orders"] = _MT4ManagerAPI.SymbolSummary_orders_get
    if _newclass:
        orders = _swig_property(_MT4ManagerAPI.SymbolSummary_orders_get, _MT4ManagerAPI.SymbolSummary_orders_set)
    __swig_setmethods__["buylots"] = _MT4ManagerAPI.SymbolSummary_buylots_set
    __swig_getmethods__["buylots"] = _MT4ManagerAPI.SymbolSummary_buylots_get
    if _newclass:
        buylots = _swig_property(_MT4ManagerAPI.SymbolSummary_buylots_get, _MT4ManagerAPI.SymbolSummary_buylots_set)
    __swig_setmethods__["selllots"] = _MT4ManagerAPI.SymbolSummary_selllots_set
    __swig_getmethods__["selllots"] = _MT4ManagerAPI.SymbolSummary_selllots_get
    if _newclass:
        selllots = _swig_property(_MT4ManagerAPI.SymbolSummary_selllots_get, _MT4ManagerAPI.SymbolSummary_selllots_set)
    __swig_setmethods__["buyprice"] = _MT4ManagerAPI.SymbolSummary_buyprice_set
    __swig_getmethods__["buyprice"] = _MT4ManagerAPI.SymbolSummary_buyprice_get
    if _newclass:
        buyprice = _swig_property(_MT4ManagerAPI.SymbolSummary_buyprice_get, _MT4ManagerAPI.SymbolSummary_buyprice_set)
    __swig_setmethods__["sellprice"] = _MT4ManagerAPI.SymbolSummary_sellprice_set
    __swig_getmethods__["sellprice"] = _MT4ManagerAPI.SymbolSummary_sellprice_get
    if _newclass:
        sellprice = _swig_property(_MT4ManagerAPI.SymbolSummary_sellprice_get, _MT4ManagerAPI.SymbolSummary_sellprice_set)
    __swig_setmethods__["profit"] = _MT4ManagerAPI.SymbolSummary_profit_set
    __swig_getmethods__["profit"] = _MT4ManagerAPI.SymbolSummary_profit_get
    if _newclass:
        profit = _swig_property(_MT4ManagerAPI.SymbolSummary_profit_get, _MT4ManagerAPI.SymbolSummary_profit_set)
    __swig_setmethods__["covorders"] = _MT4ManagerAPI.SymbolSummary_covorders_set
    __swig_getmethods__["covorders"] = _MT4ManagerAPI.SymbolSummary_covorders_get
    if _newclass:
        covorders = _swig_property(_MT4ManagerAPI.SymbolSummary_covorders_get, _MT4ManagerAPI.SymbolSummary_covorders_set)
    __swig_setmethods__["covbuylots"] = _MT4ManagerAPI.SymbolSummary_covbuylots_set
    __swig_getmethods__["covbuylots"] = _MT4ManagerAPI.SymbolSummary_covbuylots_get
    if _newclass:
        covbuylots = _swig_property(_MT4ManagerAPI.SymbolSummary_covbuylots_get, _MT4ManagerAPI.SymbolSummary_covbuylots_set)
    __swig_setmethods__["covselllots"] = _MT4ManagerAPI.SymbolSummary_covselllots_set
    __swig_getmethods__["covselllots"] = _MT4ManagerAPI.SymbolSummary_covselllots_get
    if _newclass:
        covselllots = _swig_property(_MT4ManagerAPI.SymbolSummary_covselllots_get, _MT4ManagerAPI.SymbolSummary_covselllots_set)
    __swig_setmethods__["covbuyprice"] = _MT4ManagerAPI.SymbolSummary_covbuyprice_set
    __swig_getmethods__["covbuyprice"] = _MT4ManagerAPI.SymbolSummary_covbuyprice_get
    if _newclass:
        covbuyprice = _swig_property(_MT4ManagerAPI.SymbolSummary_covbuyprice_get, _MT4ManagerAPI.SymbolSummary_covbuyprice_set)
    __swig_setmethods__["covsellprice"] = _MT4ManagerAPI.SymbolSummary_covsellprice_set
    __swig_getmethods__["covsellprice"] = _MT4ManagerAPI.SymbolSummary_covsellprice_get
    if _newclass:
        covsellprice = _swig_property(_MT4ManagerAPI.SymbolSummary_covsellprice_get, _MT4ManagerAPI.SymbolSummary_covsellprice_set)
    __swig_setmethods__["covprofit"] = _MT4ManagerAPI.SymbolSummary_covprofit_set
    __swig_getmethods__["covprofit"] = _MT4ManagerAPI.SymbolSummary_covprofit_get
    if _newclass:
        covprofit = _swig_property(_MT4ManagerAPI.SymbolSummary_covprofit_get, _MT4ManagerAPI.SymbolSummary_covprofit_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_SymbolSummary()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_SymbolSummary
    __del__ = lambda self: None
SymbolSummary_swigregister = _MT4ManagerAPI.SymbolSummary_swigregister
SymbolSummary_swigregister(SymbolSummary)

class ExposureValue(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExposureValue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExposureValue, name)
    __repr__ = _swig_repr
    __swig_setmethods__["currency"] = _MT4ManagerAPI.ExposureValue_currency_set
    __swig_getmethods__["currency"] = _MT4ManagerAPI.ExposureValue_currency_get
    if _newclass:
        currency = _swig_property(_MT4ManagerAPI.ExposureValue_currency_get, _MT4ManagerAPI.ExposureValue_currency_set)
    __swig_setmethods__["clients"] = _MT4ManagerAPI.ExposureValue_clients_set
    __swig_getmethods__["clients"] = _MT4ManagerAPI.ExposureValue_clients_get
    if _newclass:
        clients = _swig_property(_MT4ManagerAPI.ExposureValue_clients_get, _MT4ManagerAPI.ExposureValue_clients_set)
    __swig_setmethods__["coverage"] = _MT4ManagerAPI.ExposureValue_coverage_set
    __swig_getmethods__["coverage"] = _MT4ManagerAPI.ExposureValue_coverage_get
    if _newclass:
        coverage = _swig_property(_MT4ManagerAPI.ExposureValue_coverage_get, _MT4ManagerAPI.ExposureValue_coverage_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ExposureValue()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ExposureValue
    __del__ = lambda self: None
ExposureValue_swigregister = _MT4ManagerAPI.ExposureValue_swigregister
ExposureValue_swigregister(ExposureValue)

class SymbolPropertiesOld(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SymbolPropertiesOld, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SymbolPropertiesOld, name)
    __repr__ = _swig_repr
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.SymbolPropertiesOld_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.SymbolPropertiesOld_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.SymbolPropertiesOld_symbol_get, _MT4ManagerAPI.SymbolPropertiesOld_symbol_set)
    __swig_setmethods__["color"] = _MT4ManagerAPI.SymbolPropertiesOld_color_set
    __swig_getmethods__["color"] = _MT4ManagerAPI.SymbolPropertiesOld_color_get
    if _newclass:
        color = _swig_property(_MT4ManagerAPI.SymbolPropertiesOld_color_get, _MT4ManagerAPI.SymbolPropertiesOld_color_set)
    __swig_setmethods__["spread"] = _MT4ManagerAPI.SymbolPropertiesOld_spread_set
    __swig_getmethods__["spread"] = _MT4ManagerAPI.SymbolPropertiesOld_spread_get
    if _newclass:
        spread = _swig_property(_MT4ManagerAPI.SymbolPropertiesOld_spread_get, _MT4ManagerAPI.SymbolPropertiesOld_spread_set)
    __swig_setmethods__["spread_balance"] = _MT4ManagerAPI.SymbolPropertiesOld_spread_balance_set
    __swig_getmethods__["spread_balance"] = _MT4ManagerAPI.SymbolPropertiesOld_spread_balance_get
    if _newclass:
        spread_balance = _swig_property(_MT4ManagerAPI.SymbolPropertiesOld_spread_balance_get, _MT4ManagerAPI.SymbolPropertiesOld_spread_balance_set)
    __swig_setmethods__["stops_level"] = _MT4ManagerAPI.SymbolPropertiesOld_stops_level_set
    __swig_getmethods__["stops_level"] = _MT4ManagerAPI.SymbolPropertiesOld_stops_level_get
    if _newclass:
        stops_level = _swig_property(_MT4ManagerAPI.SymbolPropertiesOld_stops_level_get, _MT4ManagerAPI.SymbolPropertiesOld_stops_level_set)
    __swig_setmethods__["exemode"] = _MT4ManagerAPI.SymbolPropertiesOld_exemode_set
    __swig_getmethods__["exemode"] = _MT4ManagerAPI.SymbolPropertiesOld_exemode_get
    if _newclass:
        exemode = _swig_property(_MT4ManagerAPI.SymbolPropertiesOld_exemode_get, _MT4ManagerAPI.SymbolPropertiesOld_exemode_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_SymbolPropertiesOld()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_SymbolPropertiesOld
    __del__ = lambda self: None
SymbolPropertiesOld_swigregister = _MT4ManagerAPI.SymbolPropertiesOld_swigregister
SymbolPropertiesOld_swigregister(SymbolPropertiesOld)

class SymbolProperties(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SymbolProperties, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SymbolProperties, name)
    __repr__ = _swig_repr
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.SymbolProperties_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.SymbolProperties_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.SymbolProperties_symbol_get, _MT4ManagerAPI.SymbolProperties_symbol_set)
    __swig_setmethods__["color"] = _MT4ManagerAPI.SymbolProperties_color_set
    __swig_getmethods__["color"] = _MT4ManagerAPI.SymbolProperties_color_get
    if _newclass:
        color = _swig_property(_MT4ManagerAPI.SymbolProperties_color_get, _MT4ManagerAPI.SymbolProperties_color_set)
    __swig_setmethods__["spread"] = _MT4ManagerAPI.SymbolProperties_spread_set
    __swig_getmethods__["spread"] = _MT4ManagerAPI.SymbolProperties_spread_get
    if _newclass:
        spread = _swig_property(_MT4ManagerAPI.SymbolProperties_spread_get, _MT4ManagerAPI.SymbolProperties_spread_set)
    __swig_setmethods__["spread_balance"] = _MT4ManagerAPI.SymbolProperties_spread_balance_set
    __swig_getmethods__["spread_balance"] = _MT4ManagerAPI.SymbolProperties_spread_balance_get
    if _newclass:
        spread_balance = _swig_property(_MT4ManagerAPI.SymbolProperties_spread_balance_get, _MT4ManagerAPI.SymbolProperties_spread_balance_set)
    __swig_setmethods__["stops_level"] = _MT4ManagerAPI.SymbolProperties_stops_level_set
    __swig_getmethods__["stops_level"] = _MT4ManagerAPI.SymbolProperties_stops_level_get
    if _newclass:
        stops_level = _swig_property(_MT4ManagerAPI.SymbolProperties_stops_level_get, _MT4ManagerAPI.SymbolProperties_stops_level_set)
    __swig_setmethods__["smoothing"] = _MT4ManagerAPI.SymbolProperties_smoothing_set
    __swig_getmethods__["smoothing"] = _MT4ManagerAPI.SymbolProperties_smoothing_get
    if _newclass:
        smoothing = _swig_property(_MT4ManagerAPI.SymbolProperties_smoothing_get, _MT4ManagerAPI.SymbolProperties_smoothing_set)
    __swig_setmethods__["exemode"] = _MT4ManagerAPI.SymbolProperties_exemode_set
    __swig_getmethods__["exemode"] = _MT4ManagerAPI.SymbolProperties_exemode_get
    if _newclass:
        exemode = _swig_property(_MT4ManagerAPI.SymbolProperties_exemode_get, _MT4ManagerAPI.SymbolProperties_exemode_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.SymbolProperties_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.SymbolProperties_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.SymbolProperties_reserved_get, _MT4ManagerAPI.SymbolProperties_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_SymbolProperties()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_SymbolProperties
    __del__ = lambda self: None
SymbolProperties_swigregister = _MT4ManagerAPI.SymbolProperties_swigregister
SymbolProperties_swigregister(SymbolProperties)

class TickInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TickInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TickInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["symbol"] = _MT4ManagerAPI.TickInfo_symbol_set
    __swig_getmethods__["symbol"] = _MT4ManagerAPI.TickInfo_symbol_get
    if _newclass:
        symbol = _swig_property(_MT4ManagerAPI.TickInfo_symbol_get, _MT4ManagerAPI.TickInfo_symbol_set)
    __swig_setmethods__["ctm"] = _MT4ManagerAPI.TickInfo_ctm_set
    __swig_getmethods__["ctm"] = _MT4ManagerAPI.TickInfo_ctm_get
    if _newclass:
        ctm = _swig_property(_MT4ManagerAPI.TickInfo_ctm_get, _MT4ManagerAPI.TickInfo_ctm_set)
    __swig_setmethods__["bid"] = _MT4ManagerAPI.TickInfo_bid_set
    __swig_getmethods__["bid"] = _MT4ManagerAPI.TickInfo_bid_get
    if _newclass:
        bid = _swig_property(_MT4ManagerAPI.TickInfo_bid_get, _MT4ManagerAPI.TickInfo_bid_set)
    __swig_setmethods__["ask"] = _MT4ManagerAPI.TickInfo_ask_set
    __swig_getmethods__["ask"] = _MT4ManagerAPI.TickInfo_ask_get
    if _newclass:
        ask = _swig_property(_MT4ManagerAPI.TickInfo_ask_get, _MT4ManagerAPI.TickInfo_ask_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_TickInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_TickInfo
    __del__ = lambda self: None
TickInfo_swigregister = _MT4ManagerAPI.TickInfo_swigregister
TickInfo_swigregister(TickInfo)

class MailBox(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MailBox, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MailBox, name)
    __repr__ = _swig_repr
    __swig_setmethods__["time"] = _MT4ManagerAPI.MailBox_time_set
    __swig_getmethods__["time"] = _MT4ManagerAPI.MailBox_time_get
    if _newclass:
        time = _swig_property(_MT4ManagerAPI.MailBox_time_get, _MT4ManagerAPI.MailBox_time_set)
    __swig_setmethods__["sender"] = _MT4ManagerAPI.MailBox_sender_set
    __swig_getmethods__["sender"] = _MT4ManagerAPI.MailBox_sender_get
    if _newclass:
        sender = _swig_property(_MT4ManagerAPI.MailBox_sender_get, _MT4ManagerAPI.MailBox_sender_set)
    __swig_setmethods__["_from"] = _MT4ManagerAPI.MailBox__from_set
    __swig_getmethods__["_from"] = _MT4ManagerAPI.MailBox__from_get
    if _newclass:
        _from = _swig_property(_MT4ManagerAPI.MailBox__from_get, _MT4ManagerAPI.MailBox__from_set)
    __swig_setmethods__["to"] = _MT4ManagerAPI.MailBox_to_set
    __swig_getmethods__["to"] = _MT4ManagerAPI.MailBox_to_get
    if _newclass:
        to = _swig_property(_MT4ManagerAPI.MailBox_to_get, _MT4ManagerAPI.MailBox_to_set)
    __swig_setmethods__["subject"] = _MT4ManagerAPI.MailBox_subject_set
    __swig_getmethods__["subject"] = _MT4ManagerAPI.MailBox_subject_get
    if _newclass:
        subject = _swig_property(_MT4ManagerAPI.MailBox_subject_get, _MT4ManagerAPI.MailBox_subject_set)
    __swig_setmethods__["readed"] = _MT4ManagerAPI.MailBox_readed_set
    __swig_getmethods__["readed"] = _MT4ManagerAPI.MailBox_readed_get
    if _newclass:
        readed = _swig_property(_MT4ManagerAPI.MailBox_readed_get, _MT4ManagerAPI.MailBox_readed_set)
    __swig_setmethods__["body"] = _MT4ManagerAPI.MailBox_body_set
    __swig_getmethods__["body"] = _MT4ManagerAPI.MailBox_body_get
    if _newclass:
        body = _swig_property(_MT4ManagerAPI.MailBox_body_get, _MT4ManagerAPI.MailBox_body_set)
    __swig_setmethods__["bodylen"] = _MT4ManagerAPI.MailBox_bodylen_set
    __swig_getmethods__["bodylen"] = _MT4ManagerAPI.MailBox_bodylen_get
    if _newclass:
        bodylen = _swig_property(_MT4ManagerAPI.MailBox_bodylen_get, _MT4ManagerAPI.MailBox_bodylen_set)
    __swig_setmethods__["build_min"] = _MT4ManagerAPI.MailBox_build_min_set
    __swig_getmethods__["build_min"] = _MT4ManagerAPI.MailBox_build_min_get
    if _newclass:
        build_min = _swig_property(_MT4ManagerAPI.MailBox_build_min_get, _MT4ManagerAPI.MailBox_build_min_set)
    __swig_setmethods__["build_max"] = _MT4ManagerAPI.MailBox_build_max_set
    __swig_getmethods__["build_max"] = _MT4ManagerAPI.MailBox_build_max_get
    if _newclass:
        build_max = _swig_property(_MT4ManagerAPI.MailBox_build_max_get, _MT4ManagerAPI.MailBox_build_max_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.MailBox_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.MailBox_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.MailBox_reserved_get, _MT4ManagerAPI.MailBox_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_MailBox()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_MailBox
    __del__ = lambda self: None
MailBox_swigregister = _MT4ManagerAPI.MailBox_swigregister
MailBox_swigregister(MailBox)

class NewsTopic(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NewsTopic, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NewsTopic, name)
    __repr__ = _swig_repr
    __swig_setmethods__["key"] = _MT4ManagerAPI.NewsTopic_key_set
    __swig_getmethods__["key"] = _MT4ManagerAPI.NewsTopic_key_get
    if _newclass:
        key = _swig_property(_MT4ManagerAPI.NewsTopic_key_get, _MT4ManagerAPI.NewsTopic_key_set)
    __swig_setmethods__["time"] = _MT4ManagerAPI.NewsTopic_time_set
    __swig_getmethods__["time"] = _MT4ManagerAPI.NewsTopic_time_get
    if _newclass:
        time = _swig_property(_MT4ManagerAPI.NewsTopic_time_get, _MT4ManagerAPI.NewsTopic_time_set)
    __swig_setmethods__["ctm"] = _MT4ManagerAPI.NewsTopic_ctm_set
    __swig_getmethods__["ctm"] = _MT4ManagerAPI.NewsTopic_ctm_get
    if _newclass:
        ctm = _swig_property(_MT4ManagerAPI.NewsTopic_ctm_get, _MT4ManagerAPI.NewsTopic_ctm_set)
    __swig_setmethods__["topic"] = _MT4ManagerAPI.NewsTopic_topic_set
    __swig_getmethods__["topic"] = _MT4ManagerAPI.NewsTopic_topic_get
    if _newclass:
        topic = _swig_property(_MT4ManagerAPI.NewsTopic_topic_get, _MT4ManagerAPI.NewsTopic_topic_set)
    __swig_setmethods__["category"] = _MT4ManagerAPI.NewsTopic_category_set
    __swig_getmethods__["category"] = _MT4ManagerAPI.NewsTopic_category_get
    if _newclass:
        category = _swig_property(_MT4ManagerAPI.NewsTopic_category_get, _MT4ManagerAPI.NewsTopic_category_set)
    __swig_setmethods__["keywords"] = _MT4ManagerAPI.NewsTopic_keywords_set
    __swig_getmethods__["keywords"] = _MT4ManagerAPI.NewsTopic_keywords_get
    if _newclass:
        keywords = _swig_property(_MT4ManagerAPI.NewsTopic_keywords_get, _MT4ManagerAPI.NewsTopic_keywords_set)
    __swig_setmethods__["body"] = _MT4ManagerAPI.NewsTopic_body_set
    __swig_getmethods__["body"] = _MT4ManagerAPI.NewsTopic_body_get
    if _newclass:
        body = _swig_property(_MT4ManagerAPI.NewsTopic_body_get, _MT4ManagerAPI.NewsTopic_body_set)
    __swig_setmethods__["bodylen"] = _MT4ManagerAPI.NewsTopic_bodylen_set
    __swig_getmethods__["bodylen"] = _MT4ManagerAPI.NewsTopic_bodylen_get
    if _newclass:
        bodylen = _swig_property(_MT4ManagerAPI.NewsTopic_bodylen_get, _MT4ManagerAPI.NewsTopic_bodylen_set)
    __swig_setmethods__["readed"] = _MT4ManagerAPI.NewsTopic_readed_set
    __swig_getmethods__["readed"] = _MT4ManagerAPI.NewsTopic_readed_get
    if _newclass:
        readed = _swig_property(_MT4ManagerAPI.NewsTopic_readed_get, _MT4ManagerAPI.NewsTopic_readed_set)
    __swig_setmethods__["priority"] = _MT4ManagerAPI.NewsTopic_priority_set
    __swig_getmethods__["priority"] = _MT4ManagerAPI.NewsTopic_priority_get
    if _newclass:
        priority = _swig_property(_MT4ManagerAPI.NewsTopic_priority_get, _MT4ManagerAPI.NewsTopic_priority_set)
    __swig_setmethods__["langid"] = _MT4ManagerAPI.NewsTopic_langid_set
    __swig_getmethods__["langid"] = _MT4ManagerAPI.NewsTopic_langid_get
    if _newclass:
        langid = _swig_property(_MT4ManagerAPI.NewsTopic_langid_get, _MT4ManagerAPI.NewsTopic_langid_set)
    __swig_setmethods__["reserved"] = _MT4ManagerAPI.NewsTopic_reserved_set
    __swig_getmethods__["reserved"] = _MT4ManagerAPI.NewsTopic_reserved_get
    if _newclass:
        reserved = _swig_property(_MT4ManagerAPI.NewsTopic_reserved_get, _MT4ManagerAPI.NewsTopic_reserved_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_NewsTopic()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_NewsTopic
    __del__ = lambda self: None
NewsTopic_swigregister = _MT4ManagerAPI.NewsTopic_swigregister
NewsTopic_swigregister(NewsTopic)

class ServerLog(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ServerLog, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ServerLog, name)
    __repr__ = _swig_repr
    __swig_setmethods__["code"] = _MT4ManagerAPI.ServerLog_code_set
    __swig_getmethods__["code"] = _MT4ManagerAPI.ServerLog_code_get
    if _newclass:
        code = _swig_property(_MT4ManagerAPI.ServerLog_code_get, _MT4ManagerAPI.ServerLog_code_set)
    __swig_setmethods__["time"] = _MT4ManagerAPI.ServerLog_time_set
    __swig_getmethods__["time"] = _MT4ManagerAPI.ServerLog_time_get
    if _newclass:
        time = _swig_property(_MT4ManagerAPI.ServerLog_time_get, _MT4ManagerAPI.ServerLog_time_set)
    __swig_setmethods__["ip"] = _MT4ManagerAPI.ServerLog_ip_set
    __swig_getmethods__["ip"] = _MT4ManagerAPI.ServerLog_ip_get
    if _newclass:
        ip = _swig_property(_MT4ManagerAPI.ServerLog_ip_get, _MT4ManagerAPI.ServerLog_ip_set)
    __swig_setmethods__["message"] = _MT4ManagerAPI.ServerLog_message_set
    __swig_getmethods__["message"] = _MT4ManagerAPI.ServerLog_message_get
    if _newclass:
        message = _swig_property(_MT4ManagerAPI.ServerLog_message_get, _MT4ManagerAPI.ServerLog_message_set)

    def __init__(self):
        this = _MT4ManagerAPI.new_ServerLog()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_ServerLog
    __del__ = lambda self: None
ServerLog_swigregister = _MT4ManagerAPI.ServerLog_swigregister
ServerLog_swigregister(ServerLog)

CmdOK = _MT4ManagerAPI.CmdOK
CmdTrade = _MT4ManagerAPI.CmdTrade
CmdLogin = _MT4ManagerAPI.CmdLogin
CmdWarn = _MT4ManagerAPI.CmdWarn
CmdErr = _MT4ManagerAPI.CmdErr
CmdAtt = _MT4ManagerAPI.CmdAtt
LOG_TYPE_STANDARD = _MT4ManagerAPI.LOG_TYPE_STANDARD
LOG_TYPE_LOGINS = _MT4ManagerAPI.LOG_TYPE_LOGINS
LOG_TYPE_TRADES = _MT4ManagerAPI.LOG_TYPE_TRADES
LOG_TYPE_ERRORS = _MT4ManagerAPI.LOG_TYPE_ERRORS
LOG_TYPE_FULL = _MT4ManagerAPI.LOG_TYPE_FULL
LOG_MODE_ENABLED = _MT4ManagerAPI.LOG_MODE_ENABLED
LOG_MODE_DISABLED = _MT4ManagerAPI.LOG_MODE_DISABLED
PUMP_START_PUMPING = _MT4ManagerAPI.PUMP_START_PUMPING
PUMP_UPDATE_SYMBOLS = _MT4ManagerAPI.PUMP_UPDATE_SYMBOLS
PUMP_UPDATE_GROUPS = _MT4ManagerAPI.PUMP_UPDATE_GROUPS
PUMP_UPDATE_USERS = _MT4ManagerAPI.PUMP_UPDATE_USERS
PUMP_UPDATE_ONLINE = _MT4ManagerAPI.PUMP_UPDATE_ONLINE
PUMP_UPDATE_BIDASK = _MT4ManagerAPI.PUMP_UPDATE_BIDASK
PUMP_UPDATE_NEWS = _MT4ManagerAPI.PUMP_UPDATE_NEWS
PUMP_UPDATE_NEWS_BODY = _MT4ManagerAPI.PUMP_UPDATE_NEWS_BODY
PUMP_UPDATE_MAIL = _MT4ManagerAPI.PUMP_UPDATE_MAIL
PUMP_UPDATE_TRADES = _MT4ManagerAPI.PUMP_UPDATE_TRADES
PUMP_UPDATE_REQUESTS = _MT4ManagerAPI.PUMP_UPDATE_REQUESTS
PUMP_UPDATE_PLUGINS = _MT4ManagerAPI.PUMP_UPDATE_PLUGINS
PUMP_UPDATE_ACTIVATION = _MT4ManagerAPI.PUMP_UPDATE_ACTIVATION
PUMP_UPDATE_MARGINCALL = _MT4ManagerAPI.PUMP_UPDATE_MARGINCALL
PUMP_STOP_PUMPING = _MT4ManagerAPI.PUMP_STOP_PUMPING
PUMP_PING = _MT4ManagerAPI.PUMP_PING
DEAL_START_DEALING = _MT4ManagerAPI.DEAL_START_DEALING
DEAL_REQUEST_NEW = _MT4ManagerAPI.DEAL_REQUEST_NEW
DEAL_STOP_DEALING = _MT4ManagerAPI.DEAL_STOP_DEALING
class CManagerInterface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CManagerInterface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CManagerInterface, name)

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

    def QueryInterface(self, riid, obj):
        return _MT4ManagerAPI.CManagerInterface_QueryInterface(self, riid, obj)

    def AddRef(self):
        return _MT4ManagerAPI.CManagerInterface_AddRef(self)

    def Release(self):
        return _MT4ManagerAPI.CManagerInterface_Release(self)

    def MemFree(self, ptr):
        return _MT4ManagerAPI.CManagerInterface_MemFree(self, ptr)

    def ErrorDescription(self, code):
        return _MT4ManagerAPI.CManagerInterface_ErrorDescription(self, code)

    def WorkingDirectory(self, path):
        return _MT4ManagerAPI.CManagerInterface_WorkingDirectory(self, path)

    def Connect(self, server):
        return _MT4ManagerAPI.CManagerInterface_Connect(self, server)

    def Disconnect(self):
        return _MT4ManagerAPI.CManagerInterface_Disconnect(self)

    def IsConnected(self):
        return _MT4ManagerAPI.CManagerInterface_IsConnected(self)

    def Login(self, login, password):
        return _MT4ManagerAPI.CManagerInterface_Login(self, login, password)

    def LoginSecured(self, key_path):
        return _MT4ManagerAPI.CManagerInterface_LoginSecured(self, key_path)

    def KeysSend(self, key_path):
        return _MT4ManagerAPI.CManagerInterface_KeysSend(self, key_path)

    def Ping(self):
        return _MT4ManagerAPI.CManagerInterface_Ping(self)

    def PasswordChange(self, arg2, is_investor):
        return _MT4ManagerAPI.CManagerInterface_PasswordChange(self, arg2, is_investor)

    def ManagerRights(self, man):
        return _MT4ManagerAPI.CManagerInterface_ManagerRights(self, man)

    def SrvRestart(self):
        return _MT4ManagerAPI.CManagerInterface_SrvRestart(self)

    def SrvChartsSync(self):
        return _MT4ManagerAPI.CManagerInterface_SrvChartsSync(self)

    def SrvLiveUpdateStart(self):
        return _MT4ManagerAPI.CManagerInterface_SrvLiveUpdateStart(self)

    def SrvFeedsRestart(self):
        return _MT4ManagerAPI.CManagerInterface_SrvFeedsRestart(self)

    def CfgRequestCommon(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestCommon(self, cfg)

    def CfgRequestTime(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestTime(self, cfg)

    def CfgRequestBackup(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestBackup(self, cfg)

    def CfgRequestSymbolGroup(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestSymbolGroup(self, cfg)

    def CfgRequestAccess(self, total):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestAccess(self, total)

    def CfgRequestDataServer(self, total):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestDataServer(self, total)

    def CfgRequestHoliday(self, total):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestHoliday(self, total)

    def CfgRequestSymbol(self, total):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestSymbol(self, total)

    def CfgRequestGroup(self, total):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestGroup(self, total)

    def CfgRequestManager(self, total):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestManager(self, total)

    def CfgRequestFeeder(self, total):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestFeeder(self, total)

    def CfgRequestLiveUpdate(self, total):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestLiveUpdate(self, total)

    def CfgRequestSync(self, total):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestSync(self, total)

    def CfgRequestPlugin(self, total):
        return _MT4ManagerAPI.CManagerInterface_CfgRequestPlugin(self, total)

    def CfgUpdateCommon(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateCommon(self, cfg)

    def CfgUpdateAccess(self, cfg, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateAccess(self, cfg, pos)

    def CfgUpdateDataServer(self, cfg, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateDataServer(self, cfg, pos)

    def CfgUpdateTime(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateTime(self, cfg)

    def CfgUpdateHoliday(self, cfg, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateHoliday(self, cfg, pos)

    def CfgUpdateSymbol(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateSymbol(self, cfg)

    def CfgUpdateSymbolGroup(self, cfg, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateSymbolGroup(self, cfg, pos)

    def CfgUpdateGroup(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateGroup(self, cfg)

    def CfgUpdateManager(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateManager(self, cfg)

    def CfgUpdateFeeder(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateFeeder(self, cfg)

    def CfgUpdateBackup(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateBackup(self, cfg)

    def CfgUpdateLiveUpdate(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateLiveUpdate(self, cfg)

    def CfgUpdateSync(self, cfg):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdateSync(self, cfg)

    def CfgUpdatePlugin(self, cfg, parupd, total):
        return _MT4ManagerAPI.CManagerInterface_CfgUpdatePlugin(self, cfg, parupd, total)

    def CfgDeleteAccess(self, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgDeleteAccess(self, pos)

    def CfgDeleteDataServer(self, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgDeleteDataServer(self, pos)

    def CfgDeleteHoliday(self, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgDeleteHoliday(self, pos)

    def CfgDeleteSymbol(self, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgDeleteSymbol(self, pos)

    def CfgDeleteGroup(self, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgDeleteGroup(self, pos)

    def CfgDeleteManager(self, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgDeleteManager(self, pos)

    def CfgDeleteFeeder(self, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgDeleteFeeder(self, pos)

    def CfgDeleteLiveUpdate(self, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgDeleteLiveUpdate(self, pos)

    def CfgDeleteSync(self, pos):
        return _MT4ManagerAPI.CManagerInterface_CfgDeleteSync(self, pos)

    def CfgShiftAccess(self, pos, shift):
        return _MT4ManagerAPI.CManagerInterface_CfgShiftAccess(self, pos, shift)

    def CfgShiftDataServer(self, pos, shift):
        return _MT4ManagerAPI.CManagerInterface_CfgShiftDataServer(self, pos, shift)

    def CfgShiftHoliday(self, pos, shift):
        return _MT4ManagerAPI.CManagerInterface_CfgShiftHoliday(self, pos, shift)

    def CfgShiftSymbol(self, pos, shift):
        return _MT4ManagerAPI.CManagerInterface_CfgShiftSymbol(self, pos, shift)

    def CfgShiftGroup(self, pos, shift):
        return _MT4ManagerAPI.CManagerInterface_CfgShiftGroup(self, pos, shift)

    def CfgShiftManager(self, pos, shift):
        return _MT4ManagerAPI.CManagerInterface_CfgShiftManager(self, pos, shift)

    def CfgShiftFeeder(self, pos, shift):
        return _MT4ManagerAPI.CManagerInterface_CfgShiftFeeder(self, pos, shift)

    def CfgShiftLiveUpdate(self, pos, shift):
        return _MT4ManagerAPI.CManagerInterface_CfgShiftLiveUpdate(self, pos, shift)

    def CfgShiftSync(self, pos, shift):
        return _MT4ManagerAPI.CManagerInterface_CfgShiftSync(self, pos, shift)

    def CfgShiftPlugin(self, pos, shift):
        return _MT4ManagerAPI.CManagerInterface_CfgShiftPlugin(self, pos, shift)

    def SrvFeeders(self, total):
        return _MT4ManagerAPI.CManagerInterface_SrvFeeders(self, total)

    def SrvFeederLog(self, name, len):
        return _MT4ManagerAPI.CManagerInterface_SrvFeederLog(self, name, len)

    def ChartRequestObsolete(self, chart, timesign, total):
        return _MT4ManagerAPI.CManagerInterface_ChartRequestObsolete(self, chart, timesign, total)

    def ChartAddObsolete(self, symbol, period, rates, count):
        return _MT4ManagerAPI.CManagerInterface_ChartAddObsolete(self, symbol, period, rates, count)

    def ChartUpdateObsolete(self, symbol, period, rates, count):
        return _MT4ManagerAPI.CManagerInterface_ChartUpdateObsolete(self, symbol, period, rates, count)

    def ChartDeleteObsolete(self, symbol, period, rates, count):
        return _MT4ManagerAPI.CManagerInterface_ChartDeleteObsolete(self, symbol, period, rates, count)

    def PerformaneRequest(self, arg2, total):
        return _MT4ManagerAPI.CManagerInterface_PerformaneRequest(self, arg2, total)

    def BackupInfoUsers(self, mode, total):
        return _MT4ManagerAPI.CManagerInterface_BackupInfoUsers(self, mode, total)

    def BackupInfoOrders(self, mode, total):
        return _MT4ManagerAPI.CManagerInterface_BackupInfoOrders(self, mode, total)

    def BackupRequestUsers(self, file, request, total):
        return _MT4ManagerAPI.CManagerInterface_BackupRequestUsers(self, file, request, total)

    def BackupRequestOrders(self, file, request, total):
        return _MT4ManagerAPI.CManagerInterface_BackupRequestOrders(self, file, request, total)

    def BackupRestoreUsers(self, users, total):
        return _MT4ManagerAPI.CManagerInterface_BackupRestoreUsers(self, users, total)

    def BackupRestoreOrders(self, trades, total):
        return _MT4ManagerAPI.CManagerInterface_BackupRestoreOrders(self, trades, total)

    def AdmUsersRequest(self, group, total):
        return _MT4ManagerAPI.CManagerInterface_AdmUsersRequest(self, group, total)

    def AdmTradesRequest(self, group, open_only, total):
        return _MT4ManagerAPI.CManagerInterface_AdmTradesRequest(self, group, open_only, total)

    def AdmBalanceCheck(self, logins, total):
        return _MT4ManagerAPI.CManagerInterface_AdmBalanceCheck(self, logins, total)

    def AdmBalanceFix(self, logins, total):
        return _MT4ManagerAPI.CManagerInterface_AdmBalanceFix(self, logins, total)

    def AdmTradesDelete(self, orders, total):
        return _MT4ManagerAPI.CManagerInterface_AdmTradesDelete(self, orders, total)

    def AdmTradeRecordModify(self, trade):
        return _MT4ManagerAPI.CManagerInterface_AdmTradeRecordModify(self, trade)

    def SymbolsRefresh(self):
        return _MT4ManagerAPI.CManagerInterface_SymbolsRefresh(self)

    def SymbolsGetAll(self, total):
        return _MT4ManagerAPI.CManagerInterface_SymbolsGetAll(self, total)

    def SymbolGet(self, symbol, cs):
        return _MT4ManagerAPI.CManagerInterface_SymbolGet(self, symbol, cs)

    def SymbolInfoGet(self, symbol, si):
        return _MT4ManagerAPI.CManagerInterface_SymbolInfoGet(self, symbol, si)

    def SymbolAdd(self, symbol):
        return _MT4ManagerAPI.CManagerInterface_SymbolAdd(self, symbol)

    def SymbolHide(self, symbol):
        return _MT4ManagerAPI.CManagerInterface_SymbolHide(self, symbol)

    def SymbolChangeObsolete(self, prop):
        return _MT4ManagerAPI.CManagerInterface_SymbolChangeObsolete(self, prop)

    def SymbolSendTick(self, symbol, bid, ask):
        return _MT4ManagerAPI.CManagerInterface_SymbolSendTick(self, symbol, bid, ask)

    def GroupsRequest(self, total):
        return _MT4ManagerAPI.CManagerInterface_GroupsRequest(self, total)

    def MailSend(self, mail, logins):
        return _MT4ManagerAPI.CManagerInterface_MailSend(self, mail, logins)

    def NewsSend(self, news):
        return _MT4ManagerAPI.CManagerInterface_NewsSend(self, news)

    def JournalRequest(self, mode, arg3, to, filter, total):
        return _MT4ManagerAPI.CManagerInterface_JournalRequest(self, mode, arg3, to, filter, total)

    def UsersRequest(self, total):
        return _MT4ManagerAPI.CManagerInterface_UsersRequest(self, total)

    def UserRecordsRequest(self, logins, total):
        return _MT4ManagerAPI.CManagerInterface_UserRecordsRequest(self, logins, total)

    def UserRecordNew(self, user):
        return _MT4ManagerAPI.CManagerInterface_UserRecordNew(self, user)

    def UserRecordUpdate(self, user):
        return _MT4ManagerAPI.CManagerInterface_UserRecordUpdate(self, user)

    def UsersGroupOp(self, info, logins):
        return _MT4ManagerAPI.CManagerInterface_UsersGroupOp(self, info, logins)

    def UserPasswordCheck(self, login, password):
        return _MT4ManagerAPI.CManagerInterface_UserPasswordCheck(self, login, password)

    def UserPasswordSet(self, login, password, change_investor, clean_pubkey):
        return _MT4ManagerAPI.CManagerInterface_UserPasswordSet(self, login, password, change_investor, clean_pubkey)

    def OnlineRequest(self, total):
        return _MT4ManagerAPI.CManagerInterface_OnlineRequest(self, total)

    def TradeTransaction(self, info):
        return _MT4ManagerAPI.CManagerInterface_TradeTransaction(self, info)

    def TradesRequest(self, total):
        return _MT4ManagerAPI.CManagerInterface_TradesRequest(self, total)

    def TradeRecordsRequest(self, orders, total):
        return _MT4ManagerAPI.CManagerInterface_TradeRecordsRequest(self, orders, total)

    def TradesUserHistory(self, login, arg3, to, total):
        return _MT4ManagerAPI.CManagerInterface_TradesUserHistory(self, login, arg3, to, total)

    def TradeCheckStops(self, trade, price):
        return _MT4ManagerAPI.CManagerInterface_TradeCheckStops(self, trade, price)

    def ReportsRequest(self, req, logins, total):
        return _MT4ManagerAPI.CManagerInterface_ReportsRequest(self, req, logins, total)

    def DailyReportsRequest(self, req, logins, total):
        return _MT4ManagerAPI.CManagerInterface_DailyReportsRequest(self, req, logins, total)

    def ExternalCommand(self, data_in, size_in, data_out, size_out):
        return _MT4ManagerAPI.CManagerInterface_ExternalCommand(self, data_in, size_in, data_out, size_out)

    def PluginUpdate(self, plugin):
        return _MT4ManagerAPI.CManagerInterface_PluginUpdate(self, plugin)

    def PumpingSwitch(self, pfnFunc, destwnd, eventmsg, flags):
        return _MT4ManagerAPI.CManagerInterface_PumpingSwitch(self, pfnFunc, destwnd, eventmsg, flags)

    def GroupsGet(self, total):
        return _MT4ManagerAPI.CManagerInterface_GroupsGet(self, total)

    def GroupRecordGet(self, name, group):
        return _MT4ManagerAPI.CManagerInterface_GroupRecordGet(self, name, group)

    def SymbolInfoUpdated(self, si, max_info):
        return _MT4ManagerAPI.CManagerInterface_SymbolInfoUpdated(self, si, max_info)

    def UsersGet(self, total):
        return _MT4ManagerAPI.CManagerInterface_UsersGet(self, total)

    def UserRecordGet(self, login, user):
        return _MT4ManagerAPI.CManagerInterface_UserRecordGet(self, login, user)

    def OnlineGet(self, total):
        return _MT4ManagerAPI.CManagerInterface_OnlineGet(self, total)

    def OnlineRecordGet(self, login, user):
        return _MT4ManagerAPI.CManagerInterface_OnlineRecordGet(self, login, user)

    def TradesGet(self, total):
        return _MT4ManagerAPI.CManagerInterface_TradesGet(self, total)

    def TradesGetBySymbol(self, symbol, total):
        return _MT4ManagerAPI.CManagerInterface_TradesGetBySymbol(self, symbol, total)

    def TradesGetByLogin(self, login, group, total):
        return _MT4ManagerAPI.CManagerInterface_TradesGetByLogin(self, login, group, total)

    def TradesGetByMarket(self, total):
        return _MT4ManagerAPI.CManagerInterface_TradesGetByMarket(self, total)

    def TradeRecordGet(self, order, trade):
        return _MT4ManagerAPI.CManagerInterface_TradeRecordGet(self, order, trade)

    def TradeClearRollback(self, order):
        return _MT4ManagerAPI.CManagerInterface_TradeClearRollback(self, order)

    def MarginsGet(self, total):
        return _MT4ManagerAPI.CManagerInterface_MarginsGet(self, total)

    def MarginLevelGet(self, login, group, margin):
        return _MT4ManagerAPI.CManagerInterface_MarginLevelGet(self, login, group, margin)

    def RequestsGet(self, total):
        return _MT4ManagerAPI.CManagerInterface_RequestsGet(self, total)

    def RequestInfoGet(self, pos, info):
        return _MT4ManagerAPI.CManagerInterface_RequestInfoGet(self, pos, info)

    def PluginsGet(self, total):
        return _MT4ManagerAPI.CManagerInterface_PluginsGet(self, total)

    def PluginParamGet(self, pos, plugin):
        return _MT4ManagerAPI.CManagerInterface_PluginParamGet(self, pos, plugin)

    def MailLast(self, path, length):
        return _MT4ManagerAPI.CManagerInterface_MailLast(self, path, length)

    def NewsGet(self, total):
        return _MT4ManagerAPI.CManagerInterface_NewsGet(self, total)

    def NewsTotal(self):
        return _MT4ManagerAPI.CManagerInterface_NewsTotal(self)

    def NewsTopicGet(self, pos, news):
        return _MT4ManagerAPI.CManagerInterface_NewsTopicGet(self, pos, news)

    def NewsBodyRequest(self, key):
        return _MT4ManagerAPI.CManagerInterface_NewsBodyRequest(self, key)

    def NewsBodyGet(self, key):
        return _MT4ManagerAPI.CManagerInterface_NewsBodyGet(self, key)

    def DealerSwitch(self, pfnFunc, destwnd, eventmsg):
        return _MT4ManagerAPI.CManagerInterface_DealerSwitch(self, pfnFunc, destwnd, eventmsg)

    def DealerRequestGet(self, info):
        return _MT4ManagerAPI.CManagerInterface_DealerRequestGet(self, info)

    def DealerSend(self, info, requote, mode):
        return _MT4ManagerAPI.CManagerInterface_DealerSend(self, info, requote, mode)

    def DealerReject(self, id):
        return _MT4ManagerAPI.CManagerInterface_DealerReject(self, id)

    def DealerReset(self, id):
        return _MT4ManagerAPI.CManagerInterface_DealerReset(self, id)

    def TickInfoLast(self, symbol, total):
        return _MT4ManagerAPI.CManagerInterface_TickInfoLast(self, symbol, total)

    def SymbolsGroupsGet(self, grp):
        return _MT4ManagerAPI.CManagerInterface_SymbolsGroupsGet(self, grp)

    def ServerTime(self):
        return _MT4ManagerAPI.CManagerInterface_ServerTime(self)

    def MailsRequest(self, total):
        return _MT4ManagerAPI.CManagerInterface_MailsRequest(self, total)

    def SummaryGetAll(self, total):
        return _MT4ManagerAPI.CManagerInterface_SummaryGetAll(self, total)

    def SummaryGet(self, symbol, info):
        return _MT4ManagerAPI.CManagerInterface_SummaryGet(self, symbol, info)

    def SummaryGetByCount(self, symbol, info):
        return _MT4ManagerAPI.CManagerInterface_SummaryGetByCount(self, symbol, info)

    def SummaryGetByType(self, sectype, info):
        return _MT4ManagerAPI.CManagerInterface_SummaryGetByType(self, sectype, info)

    def SummaryCurrency(self, cur, maxchars):
        return _MT4ManagerAPI.CManagerInterface_SummaryCurrency(self, cur, maxchars)

    def ExposureGet(self, total):
        return _MT4ManagerAPI.CManagerInterface_ExposureGet(self, total)

    def ExposureValueGet(self, cur, info):
        return _MT4ManagerAPI.CManagerInterface_ExposureValueGet(self, cur, info)

    def MarginLevelRequest(self, login, level):
        return _MT4ManagerAPI.CManagerInterface_MarginLevelRequest(self, login, level)

    def HistoryCorrect(self, symbol, updated):
        return _MT4ManagerAPI.CManagerInterface_HistoryCorrect(self, symbol, updated)

    def ChartRequest(self, chart, timesign, total):
        return _MT4ManagerAPI.CManagerInterface_ChartRequest(self, chart, timesign, total)

    def ChartAdd(self, symbol, period, rates, count):
        return _MT4ManagerAPI.CManagerInterface_ChartAdd(self, symbol, period, rates, count)

    def ChartUpdate(self, symbol, period, rates, count):
        return _MT4ManagerAPI.CManagerInterface_ChartUpdate(self, symbol, period, rates, count)

    def ChartDelete(self, symbol, period, rates, count):
        return _MT4ManagerAPI.CManagerInterface_ChartDelete(self, symbol, period, rates, count)

    def TicksRequest(self, request, total):
        return _MT4ManagerAPI.CManagerInterface_TicksRequest(self, request, total)

    def PumpingSwitchEx(self, pfnFunc, flags, param):
        return _MT4ManagerAPI.CManagerInterface_PumpingSwitchEx(self, pfnFunc, flags, param)

    def UsersSyncStart(self, timestamp):
        return _MT4ManagerAPI.CManagerInterface_UsersSyncStart(self, timestamp)

    def UsersSyncRead(self, users_total):
        return _MT4ManagerAPI.CManagerInterface_UsersSyncRead(self, users_total)

    def UsersSnapshot(self, users_total):
        return _MT4ManagerAPI.CManagerInterface_UsersSnapshot(self, users_total)

    def TradesSyncStart(self, timestamp):
        return _MT4ManagerAPI.CManagerInterface_TradesSyncStart(self, timestamp)

    def TradesSyncRead(self, trades_total):
        return _MT4ManagerAPI.CManagerInterface_TradesSyncRead(self, trades_total)

    def TradesSnapshot(self, trades_total):
        return _MT4ManagerAPI.CManagerInterface_TradesSnapshot(self, trades_total)

    def DailySyncStart(self, timestamp):
        return _MT4ManagerAPI.CManagerInterface_DailySyncStart(self, timestamp)

    def DailySyncRead(self, daily_total):
        return _MT4ManagerAPI.CManagerInterface_DailySyncRead(self, daily_total)

    def TradeCalcProfit(self, trade):
        return _MT4ManagerAPI.CManagerInterface_TradeCalcProfit(self, trade)

    def SymbolChange(self, prop):
        return _MT4ManagerAPI.CManagerInterface_SymbolChange(self, prop)

    def BytesSent(self):
        return _MT4ManagerAPI.CManagerInterface_BytesSent(self)

    def BytesReceived(self):
        return _MT4ManagerAPI.CManagerInterface_BytesReceived(self)

    def ManagerCommon(self, common):
        return _MT4ManagerAPI.CManagerInterface_ManagerCommon(self, common)

    def LogsOut(self, code, source, msg):
        return _MT4ManagerAPI.CManagerInterface_LogsOut(self, code, source, msg)

    def LogsMode(self, mode):
        return _MT4ManagerAPI.CManagerInterface_LogsMode(self, mode)

    def LicenseCheck(self, license_name):
        return _MT4ManagerAPI.CManagerInterface_LicenseCheck(self, license_name)
    __swig_destroy__ = _MT4ManagerAPI.delete_CManagerInterface
    __del__ = lambda self: None
CManagerInterface_swigregister = _MT4ManagerAPI.CManagerInterface_swigregister
CManagerInterface_swigregister(CManagerInterface)

class CManagerFactory(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CManagerFactory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CManagerFactory, name)
    __repr__ = _swig_repr

    def __init__(self, lib_path=None):
        this = _MT4ManagerAPI.new_CManagerFactory(lib_path)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _MT4ManagerAPI.delete_CManagerFactory
    __del__ = lambda self: None

    def Init(self, lib_path=None):
        return _MT4ManagerAPI.CManagerFactory_Init(self, lib_path)

    def WinsockStartup(self):
        return _MT4ManagerAPI.CManagerFactory_WinsockStartup(self)

    def WinsockCleanup(self):
        return _MT4ManagerAPI.CManagerFactory_WinsockCleanup(self)

    def IsValid(self):
        return _MT4ManagerAPI.CManagerFactory_IsValid(self)

    def Version(self):
        return _MT4ManagerAPI.CManagerFactory_Version(self)

    def Create(self, version):
        return _MT4ManagerAPI.CManagerFactory_Create(self, version)
CManagerFactory_swigregister = _MT4ManagerAPI.CManagerFactory_swigregister
CManagerFactory_swigregister(CManagerFactory)

# This file is compatible with both classic and new-style classes.