renamed hooks to addons, new filemanager and database, many new api methods

you will loose ALL your LINKS, webinterface will NOT work

1 files changed, 2661 insertions, 1398 deletions

diff --git a/module/remote/thriftbackend/thriftgen/pyload/Pyload.py b/module/remote/thriftbackend/thriftgen/pyload/Pyload.py
index 3e0fe3bbc..e58070a59 100644
--- a/module/remote/thriftbackend/thriftgen/pyload/Pyload.py
+++ b/module/remote/thriftbackend/thriftgen/pyload/Pyload.py
@@ -9,38 +9,14 @@
 from thrift.Thrift import TType, TMessageType, TException
 from ttypes import *
 from thrift.Thrift import TProcessor
-from thrift.protocol.TBase import TBase, TExceptionBase, TApplicationException
+from thrift.protocol.TBase import TBase, TExceptionBase
 
 
 class Iface(object):
-  def getConfigValue(self, section, option):
-    """
-    Parameters:
-     - section
-     - option
-    """
-    pass
-
-  def setConfigValue(self, section, option, value):
-    """
-    Parameters:
-     - section
-     - option
-     - value
-    """
-    pass
-
-  def getConfig(self, ):
-    pass
-
-  def getPluginConfig(self, ):
+  def getServerVersion(self, ):
     pass
 
-  def configureSection(self, section):
-    """
-    Parameters:
-     - section
-    """
+  def statusServer(self, ):
     pass
 
   def pauseServer(self, ):
@@ -52,15 +28,9 @@ class Iface(object):
   def togglePause(self, ):
     pass
 
-  def statusServer(self, ):
-    pass
-
   def freeSpace(self, ):
     pass
 
-  def getServerVersion(self, ):
-    pass
-
   def kill(self, ):
     pass
 
@@ -83,10 +53,48 @@ class Iface(object):
   def toggleReconnect(self, ):
     pass
 
-  def generatePackages(self, links):
+  def scanDownloadFolder(self, ):
+    pass
+
+  def getProgressInfo(self, ):
+    pass
+
+  def getConfigValue(self, section, option):
     """
     Parameters:
-     - links
+     - section
+     - option
+    """
+    pass
+
+  def setConfigValue(self, section, option, value):
+    """
+    Parameters:
+     - section
+     - option
+     - value
+    """
+    pass
+
+  def getConfig(self, ):
+    pass
+
+  def getPluginConfig(self, ):
+    pass
+
+  def configureSection(self, section):
+    """
+    Parameters:
+     - section
+    """
+    pass
+
+  def setConfigHandler(self, plugin, iid, value):
+    """
+    Parameters:
+     - plugin
+     - iid
+     - value
     """
     pass
 
@@ -128,118 +136,191 @@ class Iface(object):
     """
     pass
 
-  def statusDownloads(self, ):
+  def generatePackages(self, links):
+    """
+    Parameters:
+     - links
+    """
     pass
 
-  def getPackageData(self, pid):
+  def generateAndAddPackages(self, links, paused):
     """
     Parameters:
-     - pid
+     - links
+     - paused
     """
     pass
 
-  def getPackageInfo(self, pid):
+  def autoAddLinks(self, links):
     """
     Parameters:
-     - pid
+     - links
     """
     pass
 
-  def getFileData(self, fid):
+  def createPackage(self, name, folder, root, password, site, comment, paused):
     """
     Parameters:
-     - fid
+     - name
+     - folder
+     - root
+     - password
+     - site
+     - comment
+     - paused
     """
     pass
 
-  def getQueue(self, ):
+  def addPackage(self, name, links, password):
+    """
+    Parameters:
+     - name
+     - links
+     - password
+    """
     pass
 
-  def getCollector(self, ):
+  def addPackageP(self, name, links, password, paused):
+    """
+    Parameters:
+     - name
+     - links
+     - password
+     - paused
+    """
     pass
 
-  def getQueueData(self, ):
+  def addPackageChild(self, name, links, password, root, paused):
+    """
+    Parameters:
+     - name
+     - links
+     - password
+     - root
+     - paused
+    """
     pass
 
-  def getCollectorData(self, ):
+  def uploadContainer(self, filename, data):
+    """
+    Parameters:
+     - filename
+     - data
+    """
     pass
 
-  def getPackageOrder(self, destination):
+  def addLinks(self, pid, links):
     """
     Parameters:
-     - destination
+     - pid
+     - links
     """
     pass
 
-  def getFileOrder(self, pid):
+  def deleteFiles(self, fids):
     """
     Parameters:
-     - pid
+     - fids
+    """
+    pass
+
+  def deletePackages(self, pids):
     """
+    Parameters:
+     - pids
+    """
+    pass
+
+  def getCollector(self, ):
     pass
 
-  def generateAndAddPackages(self, links, dest):
+  def addToCollector(self, links):
     """
     Parameters:
      - links
-     - dest
     """
     pass
 
-  def addPackage(self, name, links, dest, password):
+  def addFromCollector(self, name, paused):
     """
     Parameters:
      - name
-     - links
-     - dest
-     - password
+     - paused
     """
     pass
 
-  def addFiles(self, pid, links):
+  def renameCollPack(self, name, new_name):
     """
     Parameters:
-     - pid
-     - links
+     - name
+     - new_name
     """
     pass
 
-  def uploadContainer(self, filename, data):
+  def deleteCollPack(self, name):
     """
     Parameters:
-     - filename
-     - data
+     - name
     """
     pass
 
-  def deleteFiles(self, fids):
+  def deleteCollLink(self, url):
     """
     Parameters:
-     - fids
+     - url
     """
     pass
 
-  def deletePackages(self, pids):
+  def getAllFiles(self, ):
+    pass
+
+  def getAllUnfinishedFiles(self, ):
+    pass
+
+  def getFileTree(self, pid, full):
     """
     Parameters:
-     - pids
+     - pid
+     - full
+    """
+    pass
+
+  def getUnfinishedFileTree(self, pid, full):
+    """
+    Parameters:
+     - pid
+     - full
     """
     pass
 
-  def pushToQueue(self, pid):
+  def getPackageContent(self, pid):
     """
     Parameters:
      - pid
     """
     pass
 
-  def pullFromQueue(self, pid):
+  def getPackageInfo(self, pid):
     """
     Parameters:
      - pid
     """
     pass
 
+  def getFileInfo(self, fid):
+    """
+    Parameters:
+     - fid
+    """
+    pass
+
+  def findFiles(self, pattern):
+    """
+    Parameters:
+     - pattern
+    """
+    pass
+
   def restartPackage(self, pid):
     """
     Parameters:
@@ -261,29 +342,56 @@ class Iface(object):
     """
     pass
 
+  def stopDownloads(self, fids):
+    """
+    Parameters:
+     - fids
+    """
+    pass
+
   def stopAllDownloads(self, ):
     pass
 
-  def stopDownloads(self, fids):
+  def restartFailed(self, ):
+    pass
+
+  def setFilePaused(self, fid, paused):
     """
     Parameters:
-     - fids
+     - fid
+     - paused
     """
     pass
 
-  def setPackageName(self, pid, name):
+  def setPackagePaused(self, pid, paused):
     """
     Parameters:
      - pid
-     - name
+     - paused
     """
     pass
 
-  def movePackage(self, destination, pid):
+  def setPackageFolder(self, pid, path):
     """
     Parameters:
-     - destination
      - pid
+     - path
+    """
+    pass
+
+  def setPackageData(self, pid, data):
+    """
+    Parameters:
+     - pid
+     - data
+    """
+    pass
+
+  def movePackage(self, pid, root):
+    """
+    Parameters:
+     - pid
+     - root
     """
     pass
 
@@ -295,34 +403,63 @@ class Iface(object):
     """
     pass
 
-  def orderPackage(self, pid, position):
+  def orderPackage(self, pids, position):
     """
     Parameters:
-     - pid
+     - pids
      - position
     """
     pass
 
-  def orderFile(self, fid, position):
+  def orderFiles(self, fids, pid, position):
     """
     Parameters:
-     - fid
+     - fids
+     - pid
      - position
     """
     pass
 
-  def setPackageData(self, pid, data):
+  def isInteractionWaiting(self, mode):
     """
     Parameters:
-     - pid
-     - data
+     - mode
     """
     pass
 
-  def deleteFinished(self, ):
+  def getInteractionTask(self, mode):
+    """
+    Parameters:
+     - mode
+    """
     pass
 
-  def restartFailed(self, ):
+  def setInteractionResult(self, iid, result):
+    """
+    Parameters:
+     - iid
+     - result
+    """
+    pass
+
+  def generateDownloadLink(self, fid, timeout):
+    """
+    Parameters:
+     - fid
+     - timeout
+    """
+    pass
+
+  def getAddonHandler(self, ):
+    pass
+
+  def callAddonHandler(self, plugin, func, pid_or_fid):
+    """
+    Parameters:
+     - plugin
+     - func
+     - pid_or_fid
+    """
     pass
 
   def getEvents(self, uuid):
@@ -390,10 +527,12 @@ class Iface(object):
     """
     pass
 
-  def call(self, info):
+  def call(self, plugin, func, arguments):
     """
     Parameters:
-     - info
+     - plugin
+     - func
+     - arguments
     """
     pass
 
@@ -407,31 +546,6 @@ class Iface(object):
     """
     pass
 
-  def isCaptchaWaiting(self, ):
-    pass
-
-  def getCaptchaTask(self, exclusive):
-    """
-    Parameters:
-     - exclusive
-    """
-    pass
-
-  def getCaptchaTaskStatus(self, tid):
-    """
-    Parameters:
-     - tid
-    """
-    pass
-
-  def setCaptchaResult(self, tid, result):
-    """
-    Parameters:
-     - tid
-     - result
-    """
-    pass
-
 
 class Client(Iface):
   def __init__(self, iprot, oprot=None):
@@ -440,149 +554,55 @@ class Client(Iface):
       self._oprot = oprot
     self._seqid = 0
 
-  def getConfigValue(self, section, option):
-    """
-    Parameters:
-     - section
-     - option
-    """
-    self.send_getConfigValue(section, option)
-    return self.recv_getConfigValue()
-
-  def send_getConfigValue(self, section, option):
-    self._oprot.writeMessageBegin('getConfigValue', TMessageType.CALL, self._seqid)
-    args = getConfigValue_args()
-    args.section = section
-    args.option = option
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getConfigValue(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getConfigValue_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getConfigValue failed: unknown result");
-
-  def setConfigValue(self, section, option, value):
-    """
-    Parameters:
-     - section
-     - option
-     - value
-    """
-    self.send_setConfigValue(section, option, value)
-    self.recv_setConfigValue()
-
-  def send_setConfigValue(self, section, option, value):
-    self._oprot.writeMessageBegin('setConfigValue', TMessageType.CALL, self._seqid)
-    args = setConfigValue_args()
-    args.section = section
-    args.option = option
-    args.value = value
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_setConfigValue(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = setConfigValue_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def getConfig(self, ):
-    self.send_getConfig()
-    return self.recv_getConfig()
-
-  def send_getConfig(self, ):
-    self._oprot.writeMessageBegin('getConfig', TMessageType.CALL, self._seqid)
-    args = getConfig_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getConfig(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getConfig_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getConfig failed: unknown result");
-
-  def getPluginConfig(self, ):
-    self.send_getPluginConfig()
-    return self.recv_getPluginConfig()
+  def getServerVersion(self, ):
+    self.send_getServerVersion()
+    return self.recv_getServerVersion()
 
-  def send_getPluginConfig(self, ):
-    self._oprot.writeMessageBegin('getPluginConfig', TMessageType.CALL, self._seqid)
-    args = getPluginConfig_args()
+  def send_getServerVersion(self, ):
+    self._oprot.writeMessageBegin('getServerVersion', TMessageType.CALL, self._seqid)
+    args = getServerVersion_args()
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_getPluginConfig(self, ):
+  def recv_getServerVersion(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getPluginConfig_result()
+    result = getServerVersion_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPluginConfig failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServerVersion failed: unknown result");
 
-  def configureSection(self, section):
-    """
-    Parameters:
-     - section
-    """
-    self.send_configureSection(section)
-    return self.recv_configureSection()
+  def statusServer(self, ):
+    self.send_statusServer()
+    return self.recv_statusServer()
 
-  def send_configureSection(self, section):
-    self._oprot.writeMessageBegin('configureSection', TMessageType.CALL, self._seqid)
-    args = configureSection_args()
-    args.section = section
+  def send_statusServer(self, ):
+    self._oprot.writeMessageBegin('statusServer', TMessageType.CALL, self._seqid)
+    args = statusServer_args()
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_configureSection(self, ):
+  def recv_statusServer(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = configureSection_result()
+    result = statusServer_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "configureSection failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "statusServer failed: unknown result");
 
   def pauseServer(self, ):
     self.send_pauseServer()
@@ -655,31 +675,6 @@ class Client(Iface):
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "togglePause failed: unknown result");
 
-  def statusServer(self, ):
-    self.send_statusServer()
-    return self.recv_statusServer()
-
-  def send_statusServer(self, ):
-    self._oprot.writeMessageBegin('statusServer', TMessageType.CALL, self._seqid)
-    args = statusServer_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_statusServer(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = statusServer_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "statusServer failed: unknown result");
-
   def freeSpace(self, ):
     self.send_freeSpace()
     return self.recv_freeSpace()
@@ -705,31 +700,6 @@ class Client(Iface):
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "freeSpace failed: unknown result");
 
-  def getServerVersion(self, ):
-    self.send_getServerVersion()
-    return self.recv_getServerVersion()
-
-  def send_getServerVersion(self, ):
-    self._oprot.writeMessageBegin('getServerVersion', TMessageType.CALL, self._seqid)
-    args = getServerVersion_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getServerVersion(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getServerVersion_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServerVersion failed: unknown result");
-
   def kill(self, ):
     self.send_kill()
     self.recv_kill()
@@ -881,35 +851,229 @@ class Client(Iface):
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleReconnect failed: unknown result");
 
-  def generatePackages(self, links):
+  def scanDownloadFolder(self, ):
+    self.send_scanDownloadFolder()
+    self.recv_scanDownloadFolder()
+
+  def send_scanDownloadFolder(self, ):
+    self._oprot.writeMessageBegin('scanDownloadFolder', TMessageType.CALL, self._seqid)
+    args = scanDownloadFolder_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scanDownloadFolder(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scanDownloadFolder_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+
+  def getProgressInfo(self, ):
+    self.send_getProgressInfo()
+    return self.recv_getProgressInfo()
+
+  def send_getProgressInfo(self, ):
+    self._oprot.writeMessageBegin('getProgressInfo', TMessageType.CALL, self._seqid)
+    args = getProgressInfo_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getProgressInfo(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getProgressInfo_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProgressInfo failed: unknown result");
+
+  def getConfigValue(self, section, option):
     """
     Parameters:
-     - links
+     - section
+     - option
     """
-    self.send_generatePackages(links)
-    return self.recv_generatePackages()
+    self.send_getConfigValue(section, option)
+    return self.recv_getConfigValue()
 
-  def send_generatePackages(self, links):
-    self._oprot.writeMessageBegin('generatePackages', TMessageType.CALL, self._seqid)
-    args = generatePackages_args()
-    args.links = links
+  def send_getConfigValue(self, section, option):
+    self._oprot.writeMessageBegin('getConfigValue', TMessageType.CALL, self._seqid)
+    args = getConfigValue_args()
+    args.section = section
+    args.option = option
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_generatePackages(self, ):
+  def recv_getConfigValue(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = generatePackages_result()
+    result = getConfigValue_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "generatePackages failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getConfigValue failed: unknown result");
+
+  def setConfigValue(self, section, option, value):
+    """
+    Parameters:
+     - section
+     - option
+     - value
+    """
+    self.send_setConfigValue(section, option, value)
+    self.recv_setConfigValue()
+
+  def send_setConfigValue(self, section, option, value):
+    self._oprot.writeMessageBegin('setConfigValue', TMessageType.CALL, self._seqid)
+    args = setConfigValue_args()
+    args.section = section
+    args.option = option
+    args.value = value
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_setConfigValue(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = setConfigValue_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+
+  def getConfig(self, ):
+    self.send_getConfig()
+    return self.recv_getConfig()
+
+  def send_getConfig(self, ):
+    self._oprot.writeMessageBegin('getConfig', TMessageType.CALL, self._seqid)
+    args = getConfig_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getConfig(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getConfig_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getConfig failed: unknown result");
+
+  def getPluginConfig(self, ):
+    self.send_getPluginConfig()
+    return self.recv_getPluginConfig()
+
+  def send_getPluginConfig(self, ):
+    self._oprot.writeMessageBegin('getPluginConfig', TMessageType.CALL, self._seqid)
+    args = getPluginConfig_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getPluginConfig(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getPluginConfig_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPluginConfig failed: unknown result");
+
+  def configureSection(self, section):
+    """
+    Parameters:
+     - section
+    """
+    self.send_configureSection(section)
+    return self.recv_configureSection()
+
+  def send_configureSection(self, section):
+    self._oprot.writeMessageBegin('configureSection', TMessageType.CALL, self._seqid)
+    args = configureSection_args()
+    args.section = section
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_configureSection(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = configureSection_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "configureSection failed: unknown result");
+
+  def setConfigHandler(self, plugin, iid, value):
+    """
+    Parameters:
+     - plugin
+     - iid
+     - value
+    """
+    self.send_setConfigHandler(plugin, iid, value)
+    self.recv_setConfigHandler()
+
+  def send_setConfigHandler(self, plugin, iid, value):
+    self._oprot.writeMessageBegin('setConfigHandler', TMessageType.CALL, self._seqid)
+    args = setConfigHandler_args()
+    args.plugin = plugin
+    args.iid = iid
+    args.value = value
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_setConfigHandler(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = setConfigHandler_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
 
   def checkURLs(self, urls):
     """
@@ -1067,526 +1231,776 @@ class Client(Iface):
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "pollResults failed: unknown result");
 
-  def statusDownloads(self, ):
-    self.send_statusDownloads()
-    return self.recv_statusDownloads()
+  def generatePackages(self, links):
+    """
+    Parameters:
+     - links
+    """
+    self.send_generatePackages(links)
+    return self.recv_generatePackages()
 
-  def send_statusDownloads(self, ):
-    self._oprot.writeMessageBegin('statusDownloads', TMessageType.CALL, self._seqid)
-    args = statusDownloads_args()
+  def send_generatePackages(self, links):
+    self._oprot.writeMessageBegin('generatePackages', TMessageType.CALL, self._seqid)
+    args = generatePackages_args()
+    args.links = links
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_statusDownloads(self, ):
+  def recv_generatePackages(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = statusDownloads_result()
+    result = generatePackages_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "statusDownloads failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "generatePackages failed: unknown result");
 
-  def getPackageData(self, pid):
+  def generateAndAddPackages(self, links, paused):
     """
     Parameters:
-     - pid
+     - links
+     - paused
     """
-    self.send_getPackageData(pid)
-    return self.recv_getPackageData()
+    self.send_generateAndAddPackages(links, paused)
+    return self.recv_generateAndAddPackages()
 
-  def send_getPackageData(self, pid):
-    self._oprot.writeMessageBegin('getPackageData', TMessageType.CALL, self._seqid)
-    args = getPackageData_args()
-    args.pid = pid
+  def send_generateAndAddPackages(self, links, paused):
+    self._oprot.writeMessageBegin('generateAndAddPackages', TMessageType.CALL, self._seqid)
+    args = generateAndAddPackages_args()
+    args.links = links
+    args.paused = paused
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_getPackageData(self, ):
+  def recv_generateAndAddPackages(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getPackageData_result()
+    result = generateAndAddPackages_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    if result.e is not None:
-      raise result.e
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPackageData failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateAndAddPackages failed: unknown result");
 
-  def getPackageInfo(self, pid):
+  def autoAddLinks(self, links):
     """
     Parameters:
-     - pid
+     - links
     """
-    self.send_getPackageInfo(pid)
-    return self.recv_getPackageInfo()
+    self.send_autoAddLinks(links)
+    return self.recv_autoAddLinks()
 
-  def send_getPackageInfo(self, pid):
-    self._oprot.writeMessageBegin('getPackageInfo', TMessageType.CALL, self._seqid)
-    args = getPackageInfo_args()
-    args.pid = pid
+  def send_autoAddLinks(self, links):
+    self._oprot.writeMessageBegin('autoAddLinks', TMessageType.CALL, self._seqid)
+    args = autoAddLinks_args()
+    args.links = links
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_getPackageInfo(self, ):
+  def recv_autoAddLinks(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getPackageInfo_result()
+    result = autoAddLinks_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    if result.e is not None:
-      raise result.e
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPackageInfo failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "autoAddLinks failed: unknown result");
 
-  def getFileData(self, fid):
+  def createPackage(self, name, folder, root, password, site, comment, paused):
     """
     Parameters:
-     - fid
+     - name
+     - folder
+     - root
+     - password
+     - site
+     - comment
+     - paused
     """
-    self.send_getFileData(fid)
-    return self.recv_getFileData()
+    self.send_createPackage(name, folder, root, password, site, comment, paused)
+    return self.recv_createPackage()
 
-  def send_getFileData(self, fid):
-    self._oprot.writeMessageBegin('getFileData', TMessageType.CALL, self._seqid)
-    args = getFileData_args()
-    args.fid = fid
+  def send_createPackage(self, name, folder, root, password, site, comment, paused):
+    self._oprot.writeMessageBegin('createPackage', TMessageType.CALL, self._seqid)
+    args = createPackage_args()
+    args.name = name
+    args.folder = folder
+    args.root = root
+    args.password = password
+    args.site = site
+    args.comment = comment
+    args.paused = paused
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_getFileData(self, ):
+  def recv_createPackage(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getFileData_result()
+    result = createPackage_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    if result.e is not None:
-      raise result.e
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFileData failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPackage failed: unknown result");
 
-  def getQueue(self, ):
-    self.send_getQueue()
-    return self.recv_getQueue()
+  def addPackage(self, name, links, password):
+    """
+    Parameters:
+     - name
+     - links
+     - password
+    """
+    self.send_addPackage(name, links, password)
+    return self.recv_addPackage()
 
-  def send_getQueue(self, ):
-    self._oprot.writeMessageBegin('getQueue', TMessageType.CALL, self._seqid)
-    args = getQueue_args()
+  def send_addPackage(self, name, links, password):
+    self._oprot.writeMessageBegin('addPackage', TMessageType.CALL, self._seqid)
+    args = addPackage_args()
+    args.name = name
+    args.links = links
+    args.password = password
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_getQueue(self, ):
+  def recv_addPackage(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getQueue_result()
+    result = addPackage_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getQueue failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPackage failed: unknown result");
 
-  def getCollector(self, ):
-    self.send_getCollector()
-    return self.recv_getCollector()
+  def addPackageP(self, name, links, password, paused):
+    """
+    Parameters:
+     - name
+     - links
+     - password
+     - paused
+    """
+    self.send_addPackageP(name, links, password, paused)
+    return self.recv_addPackageP()
 
-  def send_getCollector(self, ):
-    self._oprot.writeMessageBegin('getCollector', TMessageType.CALL, self._seqid)
-    args = getCollector_args()
+  def send_addPackageP(self, name, links, password, paused):
+    self._oprot.writeMessageBegin('addPackageP', TMessageType.CALL, self._seqid)
+    args = addPackageP_args()
+    args.name = name
+    args.links = links
+    args.password = password
+    args.paused = paused
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_getCollector(self, ):
+  def recv_addPackageP(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getCollector_result()
+    result = addPackageP_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCollector failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPackageP failed: unknown result");
 
-  def getQueueData(self, ):
-    self.send_getQueueData()
-    return self.recv_getQueueData()
+  def addPackageChild(self, name, links, password, root, paused):
+    """
+    Parameters:
+     - name
+     - links
+     - password
+     - root
+     - paused
+    """
+    self.send_addPackageChild(name, links, password, root, paused)
+    return self.recv_addPackageChild()
 
-  def send_getQueueData(self, ):
-    self._oprot.writeMessageBegin('getQueueData', TMessageType.CALL, self._seqid)
-    args = getQueueData_args()
+  def send_addPackageChild(self, name, links, password, root, paused):
+    self._oprot.writeMessageBegin('addPackageChild', TMessageType.CALL, self._seqid)
+    args = addPackageChild_args()
+    args.name = name
+    args.links = links
+    args.password = password
+    args.root = root
+    args.paused = paused
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_getQueueData(self, ):
+  def recv_addPackageChild(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getQueueData_result()
+    result = addPackageChild_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getQueueData failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPackageChild failed: unknown result");
 
-  def getCollectorData(self, ):
-    self.send_getCollectorData()
-    return self.recv_getCollectorData()
+  def uploadContainer(self, filename, data):
+    """
+    Parameters:
+     - filename
+     - data
+    """
+    self.send_uploadContainer(filename, data)
+    return self.recv_uploadContainer()
 
-  def send_getCollectorData(self, ):
-    self._oprot.writeMessageBegin('getCollectorData', TMessageType.CALL, self._seqid)
-    args = getCollectorData_args()
+  def send_uploadContainer(self, filename, data):
+    self._oprot.writeMessageBegin('uploadContainer', TMessageType.CALL, self._seqid)
+    args = uploadContainer_args()
+    args.filename = filename
+    args.data = data
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_getCollectorData(self, ):
+  def recv_uploadContainer(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getCollectorData_result()
+    result = uploadContainer_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCollectorData failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "uploadContainer failed: unknown result");
 
-  def getPackageOrder(self, destination):
+  def addLinks(self, pid, links):
     """
     Parameters:
-     - destination
+     - pid
+     - links
     """
-    self.send_getPackageOrder(destination)
-    return self.recv_getPackageOrder()
+    self.send_addLinks(pid, links)
+    self.recv_addLinks()
 
-  def send_getPackageOrder(self, destination):
-    self._oprot.writeMessageBegin('getPackageOrder', TMessageType.CALL, self._seqid)
-    args = getPackageOrder_args()
-    args.destination = destination
+  def send_addLinks(self, pid, links):
+    self._oprot.writeMessageBegin('addLinks', TMessageType.CALL, self._seqid)
+    args = addLinks_args()
+    args.pid = pid
+    args.links = links
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_getPackageOrder(self, ):
+  def recv_addLinks(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getPackageOrder_result()
+    result = addLinks_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPackageOrder failed: unknown result");
+    if result.e is not None:
+      raise result.e
+    return
 
-  def getFileOrder(self, pid):
+  def deleteFiles(self, fids):
     """
     Parameters:
-     - pid
+     - fids
     """
-    self.send_getFileOrder(pid)
-    return self.recv_getFileOrder()
+    self.send_deleteFiles(fids)
+    self.recv_deleteFiles()
 
-  def send_getFileOrder(self, pid):
-    self._oprot.writeMessageBegin('getFileOrder', TMessageType.CALL, self._seqid)
-    args = getFileOrder_args()
-    args.pid = pid
+  def send_deleteFiles(self, fids):
+    self._oprot.writeMessageBegin('deleteFiles', TMessageType.CALL, self._seqid)
+    args = deleteFiles_args()
+    args.fids = fids
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_getFileOrder(self, ):
+  def recv_deleteFiles(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getFileOrder_result()
+    result = deleteFiles_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+
+  def deletePackages(self, pids):
+    """
+    Parameters:
+     - pids
+    """
+    self.send_deletePackages(pids)
+    self.recv_deletePackages()
+
+  def send_deletePackages(self, pids):
+    self._oprot.writeMessageBegin('deletePackages', TMessageType.CALL, self._seqid)
+    args = deletePackages_args()
+    args.pids = pids
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deletePackages(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deletePackages_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+
+  def getCollector(self, ):
+    self.send_getCollector()
+    return self.recv_getCollector()
+
+  def send_getCollector(self, ):
+    self._oprot.writeMessageBegin('getCollector', TMessageType.CALL, self._seqid)
+    args = getCollector_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getCollector(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getCollector_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFileOrder failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCollector failed: unknown result");
 
-  def generateAndAddPackages(self, links, dest):
+  def addToCollector(self, links):
     """
     Parameters:
      - links
-     - dest
     """
-    self.send_generateAndAddPackages(links, dest)
-    return self.recv_generateAndAddPackages()
+    self.send_addToCollector(links)
+    self.recv_addToCollector()
 
-  def send_generateAndAddPackages(self, links, dest):
-    self._oprot.writeMessageBegin('generateAndAddPackages', TMessageType.CALL, self._seqid)
-    args = generateAndAddPackages_args()
+  def send_addToCollector(self, links):
+    self._oprot.writeMessageBegin('addToCollector', TMessageType.CALL, self._seqid)
+    args = addToCollector_args()
     args.links = links
-    args.dest = dest
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_generateAndAddPackages(self, ):
+  def recv_addToCollector(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = generateAndAddPackages_result()
+    result = addToCollector_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateAndAddPackages failed: unknown result");
+    return
 
-  def addPackage(self, name, links, dest, password):
+  def addFromCollector(self, name, paused):
     """
     Parameters:
      - name
-     - links
-     - dest
-     - password
+     - paused
     """
-    self.send_addPackage(name, links, dest, password)
-    return self.recv_addPackage()
+    self.send_addFromCollector(name, paused)
+    return self.recv_addFromCollector()
 
-  def send_addPackage(self, name, links, dest, password):
-    self._oprot.writeMessageBegin('addPackage', TMessageType.CALL, self._seqid)
-    args = addPackage_args()
+  def send_addFromCollector(self, name, paused):
+    self._oprot.writeMessageBegin('addFromCollector', TMessageType.CALL, self._seqid)
+    args = addFromCollector_args()
     args.name = name
-    args.links = links
-    args.dest = dest
-    args.password = password
+    args.paused = paused
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_addPackage(self, ):
+  def recv_addFromCollector(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = addPackage_result()
+    result = addFromCollector_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPackage failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "addFromCollector failed: unknown result");
 
-  def addFiles(self, pid, links):
+  def renameCollPack(self, name, new_name):
     """
     Parameters:
-     - pid
-     - links
+     - name
+     - new_name
     """
-    self.send_addFiles(pid, links)
-    self.recv_addFiles()
+    self.send_renameCollPack(name, new_name)
+    self.recv_renameCollPack()
 
-  def send_addFiles(self, pid, links):
-    self._oprot.writeMessageBegin('addFiles', TMessageType.CALL, self._seqid)
-    args = addFiles_args()
-    args.pid = pid
-    args.links = links
+  def send_renameCollPack(self, name, new_name):
+    self._oprot.writeMessageBegin('renameCollPack', TMessageType.CALL, self._seqid)
+    args = renameCollPack_args()
+    args.name = name
+    args.new_name = new_name
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_addFiles(self, ):
+  def recv_renameCollPack(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = addFiles_result()
+    result = renameCollPack_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     return
 
-  def uploadContainer(self, filename, data):
+  def deleteCollPack(self, name):
     """
     Parameters:
-     - filename
-     - data
+     - name
     """
-    self.send_uploadContainer(filename, data)
-    self.recv_uploadContainer()
+    self.send_deleteCollPack(name)
+    self.recv_deleteCollPack()
 
-  def send_uploadContainer(self, filename, data):
-    self._oprot.writeMessageBegin('uploadContainer', TMessageType.CALL, self._seqid)
-    args = uploadContainer_args()
-    args.filename = filename
-    args.data = data
+  def send_deleteCollPack(self, name):
+    self._oprot.writeMessageBegin('deleteCollPack', TMessageType.CALL, self._seqid)
+    args = deleteCollPack_args()
+    args.name = name
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_uploadContainer(self, ):
+  def recv_deleteCollPack(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = uploadContainer_result()
+    result = deleteCollPack_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     return
 
-  def deleteFiles(self, fids):
+  def deleteCollLink(self, url):
     """
     Parameters:
-     - fids
+     - url
     """
-    self.send_deleteFiles(fids)
-    self.recv_deleteFiles()
+    self.send_deleteCollLink(url)
+    self.recv_deleteCollLink()
 
-  def send_deleteFiles(self, fids):
-    self._oprot.writeMessageBegin('deleteFiles', TMessageType.CALL, self._seqid)
-    args = deleteFiles_args()
-    args.fids = fids
+  def send_deleteCollLink(self, url):
+    self._oprot.writeMessageBegin('deleteCollLink', TMessageType.CALL, self._seqid)
+    args = deleteCollLink_args()
+    args.url = url
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_deleteFiles(self, ):
+  def recv_deleteCollLink(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = deleteFiles_result()
+    result = deleteCollLink_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     return
 
-  def deletePackages(self, pids):
+  def getAllFiles(self, ):
+    self.send_getAllFiles()
+    return self.recv_getAllFiles()
+
+  def send_getAllFiles(self, ):
+    self._oprot.writeMessageBegin('getAllFiles', TMessageType.CALL, self._seqid)
+    args = getAllFiles_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getAllFiles(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getAllFiles_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFiles failed: unknown result");
+
+  def getAllUnfinishedFiles(self, ):
+    self.send_getAllUnfinishedFiles()
+    return self.recv_getAllUnfinishedFiles()
+
+  def send_getAllUnfinishedFiles(self, ):
+    self._oprot.writeMessageBegin('getAllUnfinishedFiles', TMessageType.CALL, self._seqid)
+    args = getAllUnfinishedFiles_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getAllUnfinishedFiles(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getAllUnfinishedFiles_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUnfinishedFiles failed: unknown result");
+
+  def getFileTree(self, pid, full):
     """
     Parameters:
-     - pids
+     - pid
+     - full
     """
-    self.send_deletePackages(pids)
-    self.recv_deletePackages()
+    self.send_getFileTree(pid, full)
+    return self.recv_getFileTree()
 
-  def send_deletePackages(self, pids):
-    self._oprot.writeMessageBegin('deletePackages', TMessageType.CALL, self._seqid)
-    args = deletePackages_args()
-    args.pids = pids
+  def send_getFileTree(self, pid, full):
+    self._oprot.writeMessageBegin('getFileTree', TMessageType.CALL, self._seqid)
+    args = getFileTree_args()
+    args.pid = pid
+    args.full = full
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_deletePackages(self, ):
+  def recv_getFileTree(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = deletePackages_result()
+    result = getFileTree_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
-    return
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFileTree failed: unknown result");
 
-  def pushToQueue(self, pid):
+  def getUnfinishedFileTree(self, pid, full):
     """
     Parameters:
      - pid
+     - full
     """
-    self.send_pushToQueue(pid)
-    self.recv_pushToQueue()
+    self.send_getUnfinishedFileTree(pid, full)
+    return self.recv_getUnfinishedFileTree()
 
-  def send_pushToQueue(self, pid):
-    self._oprot.writeMessageBegin('pushToQueue', TMessageType.CALL, self._seqid)
-    args = pushToQueue_args()
+  def send_getUnfinishedFileTree(self, pid, full):
+    self._oprot.writeMessageBegin('getUnfinishedFileTree', TMessageType.CALL, self._seqid)
+    args = getUnfinishedFileTree_args()
     args.pid = pid
+    args.full = full
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_pushToQueue(self, ):
+  def recv_getUnfinishedFileTree(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = pushToQueue_result()
+    result = getUnfinishedFileTree_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
-    return
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUnfinishedFileTree failed: unknown result");
 
-  def pullFromQueue(self, pid):
+  def getPackageContent(self, pid):
     """
     Parameters:
      - pid
     """
-    self.send_pullFromQueue(pid)
-    self.recv_pullFromQueue()
+    self.send_getPackageContent(pid)
+    return self.recv_getPackageContent()
 
-  def send_pullFromQueue(self, pid):
-    self._oprot.writeMessageBegin('pullFromQueue', TMessageType.CALL, self._seqid)
-    args = pullFromQueue_args()
+  def send_getPackageContent(self, pid):
+    self._oprot.writeMessageBegin('getPackageContent', TMessageType.CALL, self._seqid)
+    args = getPackageContent_args()
     args.pid = pid
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_pullFromQueue(self, ):
+  def recv_getPackageContent(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = pullFromQueue_result()
+    result = getPackageContent_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
-    return
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPackageContent failed: unknown result");
+
+  def getPackageInfo(self, pid):
+    """
+    Parameters:
+     - pid
+    """
+    self.send_getPackageInfo(pid)
+    return self.recv_getPackageInfo()
+
+  def send_getPackageInfo(self, pid):
+    self._oprot.writeMessageBegin('getPackageInfo', TMessageType.CALL, self._seqid)
+    args = getPackageInfo_args()
+    args.pid = pid
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getPackageInfo(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getPackageInfo_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.e is not None:
+      raise result.e
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPackageInfo failed: unknown result");
+
+  def getFileInfo(self, fid):
+    """
+    Parameters:
+     - fid
+    """
+    self.send_getFileInfo(fid)
+    return self.recv_getFileInfo()
+
+  def send_getFileInfo(self, fid):
+    self._oprot.writeMessageBegin('getFileInfo', TMessageType.CALL, self._seqid)
+    args = getFileInfo_args()
+    args.fid = fid
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getFileInfo(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getFileInfo_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.e is not None:
+      raise result.e
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFileInfo failed: unknown result");
+
+  def findFiles(self, pattern):
+    """
+    Parameters:
+     - pattern
+    """
+    self.send_findFiles(pattern)
+    return self.recv_findFiles()
+
+  def send_findFiles(self, pattern):
+    self._oprot.writeMessageBegin('findFiles', TMessageType.CALL, self._seqid)
+    args = findFiles_args()
+    args.pattern = pattern
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_findFiles(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = findFiles_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "findFiles failed: unknown result");
 
   def restartPackage(self, pid):
     """
@@ -1672,6 +2086,34 @@ class Client(Iface):
     self._iprot.readMessageEnd()
     return
 
+  def stopDownloads(self, fids):
+    """
+    Parameters:
+     - fids
+    """
+    self.send_stopDownloads(fids)
+    self.recv_stopDownloads()
+
+  def send_stopDownloads(self, fids):
+    self._oprot.writeMessageBegin('stopDownloads', TMessageType.CALL, self._seqid)
+    args = stopDownloads_args()
+    args.fids = fids
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_stopDownloads(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = stopDownloads_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+
   def stopAllDownloads(self, ):
     self.send_stopAllDownloads()
     self.recv_stopAllDownloads()
@@ -1695,78 +2137,173 @@ class Client(Iface):
     self._iprot.readMessageEnd()
     return
 
-  def stopDownloads(self, fids):
+  def restartFailed(self, ):
+    self.send_restartFailed()
+    self.recv_restartFailed()
+
+  def send_restartFailed(self, ):
+    self._oprot.writeMessageBegin('restartFailed', TMessageType.CALL, self._seqid)
+    args = restartFailed_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_restartFailed(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = restartFailed_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+
+  def setFilePaused(self, fid, paused):
     """
     Parameters:
-     - fids
+     - fid
+     - paused
     """
-    self.send_stopDownloads(fids)
-    self.recv_stopDownloads()
+    self.send_setFilePaused(fid, paused)
+    self.recv_setFilePaused()
 
-  def send_stopDownloads(self, fids):
-    self._oprot.writeMessageBegin('stopDownloads', TMessageType.CALL, self._seqid)
-    args = stopDownloads_args()
-    args.fids = fids
+  def send_setFilePaused(self, fid, paused):
+    self._oprot.writeMessageBegin('setFilePaused', TMessageType.CALL, self._seqid)
+    args = setFilePaused_args()
+    args.fid = fid
+    args.paused = paused
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_stopDownloads(self, ):
+  def recv_setFilePaused(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = stopDownloads_result()
+    result = setFilePaused_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
+    if result.e is not None:
+      raise result.e
     return
 
-  def setPackageName(self, pid, name):
+  def setPackagePaused(self, pid, paused):
     """
     Parameters:
      - pid
-     - name
+     - paused
     """
-    self.send_setPackageName(pid, name)
-    self.recv_setPackageName()
+    self.send_setPackagePaused(pid, paused)
+    self.recv_setPackagePaused()
 
-  def send_setPackageName(self, pid, name):
-    self._oprot.writeMessageBegin('setPackageName', TMessageType.CALL, self._seqid)
-    args = setPackageName_args()
+  def send_setPackagePaused(self, pid, paused):
+    self._oprot.writeMessageBegin('setPackagePaused', TMessageType.CALL, self._seqid)
+    args = setPackagePaused_args()
     args.pid = pid
-    args.name = name
+    args.paused = paused
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_setPackagePaused(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = setPackagePaused_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.e is not None:
+      raise result.e
+    return
+
+  def setPackageFolder(self, pid, path):
+    """
+    Parameters:
+     - pid
+     - path
+    """
+    self.send_setPackageFolder(pid, path)
+    return self.recv_setPackageFolder()
+
+  def send_setPackageFolder(self, pid, path):
+    self._oprot.writeMessageBegin('setPackageFolder', TMessageType.CALL, self._seqid)
+    args = setPackageFolder_args()
+    args.pid = pid
+    args.path = path
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_setPackageFolder(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = setPackageFolder_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.e is not None:
+      raise result.e
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "setPackageFolder failed: unknown result");
+
+  def setPackageData(self, pid, data):
+    """
+    Parameters:
+     - pid
+     - data
+    """
+    self.send_setPackageData(pid, data)
+    self.recv_setPackageData()
+
+  def send_setPackageData(self, pid, data):
+    self._oprot.writeMessageBegin('setPackageData', TMessageType.CALL, self._seqid)
+    args = setPackageData_args()
+    args.pid = pid
+    args.data = data
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_setPackageName(self, ):
+  def recv_setPackageData(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = setPackageName_result()
+    result = setPackageData_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
+    if result.e is not None:
+      raise result.e
     return
 
-  def movePackage(self, destination, pid):
+  def movePackage(self, pid, root):
     """
     Parameters:
-     - destination
      - pid
+     - root
     """
-    self.send_movePackage(destination, pid)
-    self.recv_movePackage()
+    self.send_movePackage(pid, root)
+    return self.recv_movePackage()
 
-  def send_movePackage(self, destination, pid):
+  def send_movePackage(self, pid, root):
     self._oprot.writeMessageBegin('movePackage', TMessageType.CALL, self._seqid)
     args = movePackage_args()
-    args.destination = destination
     args.pid = pid
+    args.root = root
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
@@ -1781,7 +2318,11 @@ class Client(Iface):
     result = movePackage_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
-    return
+    if result.success is not None:
+      return result.success
+    if result.e is not None:
+      raise result.e
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "movePackage failed: unknown result");
 
   def moveFiles(self, fids, pid):
     """
@@ -1790,7 +2331,7 @@ class Client(Iface):
      - pid
     """
     self.send_moveFiles(fids, pid)
-    self.recv_moveFiles()
+    return self.recv_moveFiles()
 
   def send_moveFiles(self, fids, pid):
     self._oprot.writeMessageBegin('moveFiles', TMessageType.CALL, self._seqid)
@@ -1811,21 +2352,25 @@ class Client(Iface):
     result = moveFiles_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
-    return
+    if result.success is not None:
+      return result.success
+    if result.e is not None:
+      raise result.e
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "moveFiles failed: unknown result");
 
-  def orderPackage(self, pid, position):
+  def orderPackage(self, pids, position):
     """
     Parameters:
-     - pid
+     - pids
      - position
     """
-    self.send_orderPackage(pid, position)
+    self.send_orderPackage(pids, position)
     self.recv_orderPackage()
 
-  def send_orderPackage(self, pid, position):
+  def send_orderPackage(self, pids, position):
     self._oprot.writeMessageBegin('orderPackage', TMessageType.CALL, self._seqid)
     args = orderPackage_args()
-    args.pid = pid
+    args.pids = pids
     args.position = position
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
@@ -1843,112 +2388,213 @@ class Client(Iface):
     self._iprot.readMessageEnd()
     return
 
-  def orderFile(self, fid, position):
+  def orderFiles(self, fids, pid, position):
     """
     Parameters:
-     - fid
+     - fids
+     - pid
      - position
     """
-    self.send_orderFile(fid, position)
-    self.recv_orderFile()
+    self.send_orderFiles(fids, pid, position)
+    self.recv_orderFiles()
 
-  def send_orderFile(self, fid, position):
-    self._oprot.writeMessageBegin('orderFile', TMessageType.CALL, self._seqid)
-    args = orderFile_args()
-    args.fid = fid
+  def send_orderFiles(self, fids, pid, position):
+    self._oprot.writeMessageBegin('orderFiles', TMessageType.CALL, self._seqid)
+    args = orderFiles_args()
+    args.fids = fids
+    args.pid = pid
     args.position = position
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_orderFile(self, ):
+  def recv_orderFiles(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = orderFile_result()
+    result = orderFiles_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     return
 
-  def setPackageData(self, pid, data):
+  def isInteractionWaiting(self, mode):
     """
     Parameters:
-     - pid
-     - data
+     - mode
     """
-    self.send_setPackageData(pid, data)
-    self.recv_setPackageData()
+    self.send_isInteractionWaiting(mode)
+    return self.recv_isInteractionWaiting()
 
-  def send_setPackageData(self, pid, data):
-    self._oprot.writeMessageBegin('setPackageData', TMessageType.CALL, self._seqid)
-    args = setPackageData_args()
-    args.pid = pid
-    args.data = data
+  def send_isInteractionWaiting(self, mode):
+    self._oprot.writeMessageBegin('isInteractionWaiting', TMessageType.CALL, self._seqid)
+    args = isInteractionWaiting_args()
+    args.mode = mode
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_setPackageData(self, ):
+  def recv_isInteractionWaiting(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = setPackageData_result()
+    result = isInteractionWaiting_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInteractionWaiting failed: unknown result");
+
+  def getInteractionTask(self, mode):
+    """
+    Parameters:
+     - mode
+    """
+    self.send_getInteractionTask(mode)
+    return self.recv_getInteractionTask()
+
+  def send_getInteractionTask(self, mode):
+    self._oprot.writeMessageBegin('getInteractionTask', TMessageType.CALL, self._seqid)
+    args = getInteractionTask_args()
+    args.mode = mode
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getInteractionTask(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getInteractionTask_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInteractionTask failed: unknown result");
+
+  def setInteractionResult(self, iid, result):
+    """
+    Parameters:
+     - iid
+     - result
+    """
+    self.send_setInteractionResult(iid, result)
+    self.recv_setInteractionResult()
+
+  def send_setInteractionResult(self, iid, result):
+    self._oprot.writeMessageBegin('setInteractionResult', TMessageType.CALL, self._seqid)
+    args = setInteractionResult_args()
+    args.iid = iid
+    args.result = result
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_setInteractionResult(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = setInteractionResult_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
-    if result.e is not None:
-      raise result.e
     return
 
-  def deleteFinished(self, ):
-    self.send_deleteFinished()
-    return self.recv_deleteFinished()
+  def generateDownloadLink(self, fid, timeout):
+    """
+    Parameters:
+     - fid
+     - timeout
+    """
+    self.send_generateDownloadLink(fid, timeout)
+    return self.recv_generateDownloadLink()
 
-  def send_deleteFinished(self, ):
-    self._oprot.writeMessageBegin('deleteFinished', TMessageType.CALL, self._seqid)
-    args = deleteFinished_args()
+  def send_generateDownloadLink(self, fid, timeout):
+    self._oprot.writeMessageBegin('generateDownloadLink', TMessageType.CALL, self._seqid)
+    args = generateDownloadLink_args()
+    args.fid = fid
+    args.timeout = timeout
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_deleteFinished(self, ):
+  def recv_generateDownloadLink(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = deleteFinished_result()
+    result = generateDownloadLink_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteFinished failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateDownloadLink failed: unknown result");
 
-  def restartFailed(self, ):
-    self.send_restartFailed()
-    self.recv_restartFailed()
+  def getAddonHandler(self, ):
+    self.send_getAddonHandler()
+    return self.recv_getAddonHandler()
 
-  def send_restartFailed(self, ):
-    self._oprot.writeMessageBegin('restartFailed', TMessageType.CALL, self._seqid)
-    args = restartFailed_args()
+  def send_getAddonHandler(self, ):
+    self._oprot.writeMessageBegin('getAddonHandler', TMessageType.CALL, self._seqid)
+    args = getAddonHandler_args()
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_restartFailed(self, ):
+  def recv_getAddonHandler(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = restartFailed_result()
+    result = getAddonHandler_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddonHandler failed: unknown result");
+
+  def callAddonHandler(self, plugin, func, pid_or_fid):
+    """
+    Parameters:
+     - plugin
+     - func
+     - pid_or_fid
+    """
+    self.send_callAddonHandler(plugin, func, pid_or_fid)
+    self.recv_callAddonHandler()
+
+  def send_callAddonHandler(self, plugin, func, pid_or_fid):
+    self._oprot.writeMessageBegin('callAddonHandler', TMessageType.CALL, self._seqid)
+    args = callAddonHandler_args()
+    args.plugin = plugin
+    args.func = func
+    args.pid_or_fid = pid_or_fid
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_callAddonHandler(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = callAddonHandler_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     return
@@ -2250,18 +2896,22 @@ class Client(Iface):
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "hasService failed: unknown result");
 
-  def call(self, info):
+  def call(self, plugin, func, arguments):
     """
     Parameters:
-     - info
+     - plugin
+     - func
+     - arguments
     """
-    self.send_call(info)
+    self.send_call(plugin, func, arguments)
     return self.recv_call()
 
-  def send_call(self, info):
+  def send_call(self, plugin, func, arguments):
     self._oprot.writeMessageBegin('call', TMessageType.CALL, self._seqid)
     args = call_args()
-    args.info = info
+    args.plugin = plugin
+    args.func = func
+    args.arguments = arguments
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
@@ -2339,180 +2989,81 @@ class Client(Iface):
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getInfoByPlugin failed: unknown result");
 
-  def isCaptchaWaiting(self, ):
-    self.send_isCaptchaWaiting()
-    return self.recv_isCaptchaWaiting()
-
-  def send_isCaptchaWaiting(self, ):
-    self._oprot.writeMessageBegin('isCaptchaWaiting', TMessageType.CALL, self._seqid)
-    args = isCaptchaWaiting_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_isCaptchaWaiting(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = isCaptchaWaiting_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCaptchaWaiting failed: unknown result");
-
-  def getCaptchaTask(self, exclusive):
-    """
-    Parameters:
-     - exclusive
-    """
-    self.send_getCaptchaTask(exclusive)
-    return self.recv_getCaptchaTask()
-
-  def send_getCaptchaTask(self, exclusive):
-    self._oprot.writeMessageBegin('getCaptchaTask', TMessageType.CALL, self._seqid)
-    args = getCaptchaTask_args()
-    args.exclusive = exclusive
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getCaptchaTask(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getCaptchaTask_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCaptchaTask failed: unknown result");
-
-  def getCaptchaTaskStatus(self, tid):
-    """
-    Parameters:
-     - tid
-    """
-    self.send_getCaptchaTaskStatus(tid)
-    return self.recv_getCaptchaTaskStatus()
-
-  def send_getCaptchaTaskStatus(self, tid):
-    self._oprot.writeMessageBegin('getCaptchaTaskStatus', TMessageType.CALL, self._seqid)
-    args = getCaptchaTaskStatus_args()
-    args.tid = tid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getCaptchaTaskStatus(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getCaptchaTaskStatus_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCaptchaTaskStatus failed: unknown result");
-
-  def setCaptchaResult(self, tid, result):
-    """
-    Parameters:
-     - tid
-     - result
-    """
-    self.send_setCaptchaResult(tid, result)
-    self.recv_setCaptchaResult()
-
-  def send_setCaptchaResult(self, tid, result):
-    self._oprot.writeMessageBegin('setCaptchaResult', TMessageType.CALL, self._seqid)
-    args = setCaptchaResult_args()
-    args.tid = tid
-    args.result = result
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_setCaptchaResult(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = setCaptchaResult_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
 
 class Processor(Iface, TProcessor):
   def __init__(self, handler):
     self._handler = handler
     self._processMap = {}
-    self._processMap["getConfigValue"] = Processor.process_getConfigValue
-    self._processMap["setConfigValue"] = Processor.process_setConfigValue
-    self._processMap["getConfig"] = Processor.process_getConfig
-    self._processMap["getPluginConfig"] = Processor.process_getPluginConfig
-    self._processMap["configureSection"] = Processor.process_configureSection
+    self._processMap["getServerVersion"] = Processor.process_getServerVersion
+    self._processMap["statusServer"] = Processor.process_statusServer
     self._processMap["pauseServer"] = Processor.process_pauseServer
     self._processMap["unpauseServer"] = Processor.process_unpauseServer
     self._processMap["togglePause"] = Processor.process_togglePause
-    self._processMap["statusServer"] = Processor.process_statusServer
     self._processMap["freeSpace"] = Processor.process_freeSpace
-    self._processMap["getServerVersion"] = Processor.process_getServerVersion
     self._processMap["kill"] = Processor.process_kill
     self._processMap["restart"] = Processor.process_restart
     self._processMap["getLog"] = Processor.process_getLog
     self._processMap["isTimeDownload"] = Processor.process_isTimeDownload
     self._processMap["isTimeReconnect"] = Processor.process_isTimeReconnect
     self._processMap["toggleReconnect"] = Processor.process_toggleReconnect
-    self._processMap["generatePackages"] = Processor.process_generatePackages
+    self._processMap["scanDownloadFolder"] = Processor.process_scanDownloadFolder
+    self._processMap["getProgressInfo"] = Processor.process_getProgressInfo
+    self._processMap["getConfigValue"] = Processor.process_getConfigValue
+    self._processMap["setConfigValue"] = Processor.process_setConfigValue
+    self._processMap["getConfig"] = Processor.process_getConfig
+    self._processMap["getPluginConfig"] = Processor.process_getPluginConfig
+    self._processMap["configureSection"] = Processor.process_configureSection
+    self._processMap["setConfigHandler"] = Processor.process_setConfigHandler
     self._processMap["checkURLs"] = Processor.process_checkURLs
     self._processMap["parseURLs"] = Processor.process_parseURLs
     self._processMap["checkOnlineStatus"] = Processor.process_checkOnlineStatus
     self._processMap["checkOnlineStatusContainer"] = Processor.process_checkOnlineStatusContainer
     self._processMap["pollResults"] = Processor.process_pollResults
-    self._processMap["statusDownloads"] = Processor.process_statusDownloads
-    self._processMap["getPackageData"] = Processor.process_getPackageData
-    self._processMap["getPackageInfo"] = Processor.process_getPackageInfo
-    self._processMap["getFileData"] = Processor.process_getFileData
-    self._processMap["getQueue"] = Processor.process_getQueue
-    self._processMap["getCollector"] = Processor.process_getCollector
-    self._processMap["getQueueData"] = Processor.process_getQueueData
-    self._processMap["getCollectorData"] = Processor.process_getCollectorData
-    self._processMap["getPackageOrder"] = Processor.process_getPackageOrder
-    self._processMap["getFileOrder"] = Processor.process_getFileOrder
+    self._processMap["generatePackages"] = Processor.process_generatePackages
     self._processMap["generateAndAddPackages"] = Processor.process_generateAndAddPackages
+    self._processMap["autoAddLinks"] = Processor.process_autoAddLinks
+    self._processMap["createPackage"] = Processor.process_createPackage
     self._processMap["addPackage"] = Processor.process_addPackage
-    self._processMap["addFiles"] = Processor.process_addFiles
+    self._processMap["addPackageP"] = Processor.process_addPackageP
+    self._processMap["addPackageChild"] = Processor.process_addPackageChild
     self._processMap["uploadContainer"] = Processor.process_uploadContainer
+    self._processMap["addLinks"] = Processor.process_addLinks
     self._processMap["deleteFiles"] = Processor.process_deleteFiles
     self._processMap["deletePackages"] = Processor.process_deletePackages
-    self._processMap["pushToQueue"] = Processor.process_pushToQueue
-    self._processMap["pullFromQueue"] = Processor.process_pullFromQueue
+    self._processMap["getCollector"] = Processor.process_getCollector
+    self._processMap["addToCollector"] = Processor.process_addToCollector
+    self._processMap["addFromCollector"] = Processor.process_addFromCollector
+    self._processMap["renameCollPack"] = Processor.process_renameCollPack
+    self._processMap["deleteCollPack"] = Processor.process_deleteCollPack
+    self._processMap["deleteCollLink"] = Processor.process_deleteCollLink
+    self._processMap["getAllFiles"] = Processor.process_getAllFiles
+    self._processMap["getAllUnfinishedFiles"] = Processor.process_getAllUnfinishedFiles
+    self._processMap["getFileTree"] = Processor.process_getFileTree
+    self._processMap["getUnfinishedFileTree"] = Processor.process_getUnfinishedFileTree
+    self._processMap["getPackageContent"] = Processor.process_getPackageContent
+    self._processMap["getPackageInfo"] = Processor.process_getPackageInfo
+    self._processMap["getFileInfo"] = Processor.process_getFileInfo
+    self._processMap["findFiles"] = Processor.process_findFiles
     self._processMap["restartPackage"] = Processor.process_restartPackage
     self._processMap["restartFile"] = Processor.process_restartFile
     self._processMap["recheckPackage"] = Processor.process_recheckPackage
-    self._processMap["stopAllDownloads"] = Processor.process_stopAllDownloads
     self._processMap["stopDownloads"] = Processor.process_stopDownloads
-    self._processMap["setPackageName"] = Processor.process_setPackageName
+    self._processMap["stopAllDownloads"] = Processor.process_stopAllDownloads
+    self._processMap["restartFailed"] = Processor.process_restartFailed
+    self._processMap["setFilePaused"] = Processor.process_setFilePaused
+    self._processMap["setPackagePaused"] = Processor.process_setPackagePaused
+    self._processMap["setPackageFolder"] = Processor.process_setPackageFolder
+    self._processMap["setPackageData"] = Processor.process_setPackageData
     self._processMap["movePackage"] = Processor.process_movePackage
     self._processMap["moveFiles"] = Processor.process_moveFiles
     self._processMap["orderPackage"] = Processor.process_orderPackage
-    self._processMap["orderFile"] = Processor.process_orderFile
-    self._processMap["setPackageData"] = Processor.process_setPackageData
-    self._processMap["deleteFinished"] = Processor.process_deleteFinished
-    self._processMap["restartFailed"] = Processor.process_restartFailed
+    self._processMap["orderFiles"] = Processor.process_orderFiles
+    self._processMap["isInteractionWaiting"] = Processor.process_isInteractionWaiting
+    self._processMap["getInteractionTask"] = Processor.process_getInteractionTask
+    self._processMap["setInteractionResult"] = Processor.process_setInteractionResult
+    self._processMap["generateDownloadLink"] = Processor.process_generateDownloadLink
+    self._processMap["getAddonHandler"] = Processor.process_getAddonHandler
+    self._processMap["callAddonHandler"] = Processor.process_callAddonHandler
     self._processMap["getEvents"] = Processor.process_getEvents
     self._processMap["getAccounts"] = Processor.process_getAccounts
     self._processMap["getAccountTypes"] = Processor.process_getAccountTypes
@@ -2526,10 +3077,6 @@ class Processor(Iface, TProcessor):
     self._processMap["call"] = Processor.process_call
     self._processMap["getAllInfo"] = Processor.process_getAllInfo
     self._processMap["getInfoByPlugin"] = Processor.process_getInfoByPlugin
-    self._processMap["isCaptchaWaiting"] = Processor.process_isCaptchaWaiting
-    self._processMap["getCaptchaTask"] = Processor.process_getCaptchaTask
-    self._processMap["getCaptchaTaskStatus"] = Processor.process_getCaptchaTaskStatus
-    self._processMap["setCaptchaResult"] = Processor.process_setCaptchaResult
 
   def process(self, iprot, oprot):
     (name, type, seqid) = iprot.readMessageBegin()
@@ -2546,57 +3093,24 @@ class Processor(Iface, TProcessor):
       self._processMap[name](self, seqid, iprot, oprot)
     return True
 
-  def process_getConfigValue(self, seqid, iprot, oprot):
-    args = getConfigValue_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getConfigValue_result()
-    result.success = self._handler.getConfigValue(args.section, args.option)
-    oprot.writeMessageBegin("getConfigValue", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_setConfigValue(self, seqid, iprot, oprot):
-    args = setConfigValue_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = setConfigValue_result()
-    self._handler.setConfigValue(args.section, args.option, args.value)
-    oprot.writeMessageBegin("setConfigValue", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getConfig(self, seqid, iprot, oprot):
-    args = getConfig_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getConfig_result()
-    result.success = self._handler.getConfig()
-    oprot.writeMessageBegin("getConfig", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getPluginConfig(self, seqid, iprot, oprot):
-    args = getPluginConfig_args()
+  def process_getServerVersion(self, seqid, iprot, oprot):
+    args = getServerVersion_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getPluginConfig_result()
-    result.success = self._handler.getPluginConfig()
-    oprot.writeMessageBegin("getPluginConfig", TMessageType.REPLY, seqid)
+    result = getServerVersion_result()
+    result.success = self._handler.getServerVersion()
+    oprot.writeMessageBegin("getServerVersion", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_configureSection(self, seqid, iprot, oprot):
-    args = configureSection_args()
+  def process_statusServer(self, seqid, iprot, oprot):
+    args = statusServer_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = configureSection_result()
-    result.success = self._handler.configureSection(args.section)
-    oprot.writeMessageBegin("configureSection", TMessageType.REPLY, seqid)
+    result = statusServer_result()
+    result.success = self._handler.statusServer()
+    oprot.writeMessageBegin("statusServer", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
@@ -2634,17 +3148,6 @@ class Processor(Iface, TProcessor):
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_statusServer(self, seqid, iprot, oprot):
-    args = statusServer_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = statusServer_result()
-    result.success = self._handler.statusServer()
-    oprot.writeMessageBegin("statusServer", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
   def process_freeSpace(self, seqid, iprot, oprot):
     args = freeSpace_args()
     args.read(iprot)
@@ -2656,17 +3159,6 @@ class Processor(Iface, TProcessor):
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_getServerVersion(self, seqid, iprot, oprot):
-    args = getServerVersion_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getServerVersion_result()
-    result.success = self._handler.getServerVersion()
-    oprot.writeMessageBegin("getServerVersion", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
   def process_kill(self, seqid, iprot, oprot):
     args = kill_args()
     args.read(iprot)
@@ -2733,13 +3225,90 @@ class Processor(Iface, TProcessor):
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_generatePackages(self, seqid, iprot, oprot):
-    args = generatePackages_args()
+  def process_scanDownloadFolder(self, seqid, iprot, oprot):
+    args = scanDownloadFolder_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = generatePackages_result()
-    result.success = self._handler.generatePackages(args.links)
-    oprot.writeMessageBegin("generatePackages", TMessageType.REPLY, seqid)
+    result = scanDownloadFolder_result()
+    self._handler.scanDownloadFolder()
+    oprot.writeMessageBegin("scanDownloadFolder", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getProgressInfo(self, seqid, iprot, oprot):
+    args = getProgressInfo_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getProgressInfo_result()
+    result.success = self._handler.getProgressInfo()
+    oprot.writeMessageBegin("getProgressInfo", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getConfigValue(self, seqid, iprot, oprot):
+    args = getConfigValue_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getConfigValue_result()
+    result.success = self._handler.getConfigValue(args.section, args.option)
+    oprot.writeMessageBegin("getConfigValue", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_setConfigValue(self, seqid, iprot, oprot):
+    args = setConfigValue_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = setConfigValue_result()
+    self._handler.setConfigValue(args.section, args.option, args.value)
+    oprot.writeMessageBegin("setConfigValue", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getConfig(self, seqid, iprot, oprot):
+    args = getConfig_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getConfig_result()
+    result.success = self._handler.getConfig()
+    oprot.writeMessageBegin("getConfig", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getPluginConfig(self, seqid, iprot, oprot):
+    args = getPluginConfig_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getPluginConfig_result()
+    result.success = self._handler.getPluginConfig()
+    oprot.writeMessageBegin("getPluginConfig", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_configureSection(self, seqid, iprot, oprot):
+    args = configureSection_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = configureSection_result()
+    result.success = self._handler.configureSection(args.section)
+    oprot.writeMessageBegin("configureSection", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_setConfigHandler(self, seqid, iprot, oprot):
+    args = setConfigHandler_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = setConfigHandler_result()
+    self._handler.setConfigHandler(args.plugin, args.iid, args.value)
+    oprot.writeMessageBegin("setConfigHandler", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
@@ -2799,66 +3368,126 @@ class Processor(Iface, TProcessor):
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_statusDownloads(self, seqid, iprot, oprot):
-    args = statusDownloads_args()
+  def process_generatePackages(self, seqid, iprot, oprot):
+    args = generatePackages_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = statusDownloads_result()
-    result.success = self._handler.statusDownloads()
-    oprot.writeMessageBegin("statusDownloads", TMessageType.REPLY, seqid)
+    result = generatePackages_result()
+    result.success = self._handler.generatePackages(args.links)
+    oprot.writeMessageBegin("generatePackages", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_getPackageData(self, seqid, iprot, oprot):
-    args = getPackageData_args()
+  def process_generateAndAddPackages(self, seqid, iprot, oprot):
+    args = generateAndAddPackages_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getPackageData_result()
-    try:
-      result.success = self._handler.getPackageData(args.pid)
-    except PackageDoesNotExists, e:
-      result.e = e
-    oprot.writeMessageBegin("getPackageData", TMessageType.REPLY, seqid)
+    result = generateAndAddPackages_result()
+    result.success = self._handler.generateAndAddPackages(args.links, args.paused)
+    oprot.writeMessageBegin("generateAndAddPackages", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_getPackageInfo(self, seqid, iprot, oprot):
-    args = getPackageInfo_args()
+  def process_autoAddLinks(self, seqid, iprot, oprot):
+    args = autoAddLinks_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getPackageInfo_result()
+    result = autoAddLinks_result()
+    result.success = self._handler.autoAddLinks(args.links)
+    oprot.writeMessageBegin("autoAddLinks", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_createPackage(self, seqid, iprot, oprot):
+    args = createPackage_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = createPackage_result()
+    result.success = self._handler.createPackage(args.name, args.folder, args.root, args.password, args.site, args.comment, args.paused)
+    oprot.writeMessageBegin("createPackage", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_addPackage(self, seqid, iprot, oprot):
+    args = addPackage_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = addPackage_result()
+    result.success = self._handler.addPackage(args.name, args.links, args.password)
+    oprot.writeMessageBegin("addPackage", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_addPackageP(self, seqid, iprot, oprot):
+    args = addPackageP_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = addPackageP_result()
+    result.success = self._handler.addPackageP(args.name, args.links, args.password, args.paused)
+    oprot.writeMessageBegin("addPackageP", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_addPackageChild(self, seqid, iprot, oprot):
+    args = addPackageChild_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = addPackageChild_result()
+    result.success = self._handler.addPackageChild(args.name, args.links, args.password, args.root, args.paused)
+    oprot.writeMessageBegin("addPackageChild", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_uploadContainer(self, seqid, iprot, oprot):
+    args = uploadContainer_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = uploadContainer_result()
+    result.success = self._handler.uploadContainer(args.filename, args.data)
+    oprot.writeMessageBegin("uploadContainer", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_addLinks(self, seqid, iprot, oprot):
+    args = addLinks_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = addLinks_result()
     try:
-      result.success = self._handler.getPackageInfo(args.pid)
+      self._handler.addLinks(args.pid, args.links)
     except PackageDoesNotExists, e:
       result.e = e
-    oprot.writeMessageBegin("getPackageInfo", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("addLinks", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_getFileData(self, seqid, iprot, oprot):
-    args = getFileData_args()
+  def process_deleteFiles(self, seqid, iprot, oprot):
+    args = deleteFiles_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getFileData_result()
-    try:
-      result.success = self._handler.getFileData(args.fid)
-    except FileDoesNotExists, e:
-      result.e = e
-    oprot.writeMessageBegin("getFileData", TMessageType.REPLY, seqid)
+    result = deleteFiles_result()
+    self._handler.deleteFiles(args.fids)
+    oprot.writeMessageBegin("deleteFiles", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_getQueue(self, seqid, iprot, oprot):
-    args = getQueue_args()
+  def process_deletePackages(self, seqid, iprot, oprot):
+    args = deletePackages_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getQueue_result()
-    result.success = self._handler.getQueue()
-    oprot.writeMessageBegin("getQueue", TMessageType.REPLY, seqid)
+    result = deletePackages_result()
+    self._handler.deletePackages(args.pids)
+    oprot.writeMessageBegin("deletePackages", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
@@ -2874,134 +3503,151 @@ class Processor(Iface, TProcessor):
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_getQueueData(self, seqid, iprot, oprot):
-    args = getQueueData_args()
+  def process_addToCollector(self, seqid, iprot, oprot):
+    args = addToCollector_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getQueueData_result()
-    result.success = self._handler.getQueueData()
-    oprot.writeMessageBegin("getQueueData", TMessageType.REPLY, seqid)
+    result = addToCollector_result()
+    self._handler.addToCollector(args.links)
+    oprot.writeMessageBegin("addToCollector", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_getCollectorData(self, seqid, iprot, oprot):
-    args = getCollectorData_args()
+  def process_addFromCollector(self, seqid, iprot, oprot):
+    args = addFromCollector_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getCollectorData_result()
-    result.success = self._handler.getCollectorData()
-    oprot.writeMessageBegin("getCollectorData", TMessageType.REPLY, seqid)
+    result = addFromCollector_result()
+    result.success = self._handler.addFromCollector(args.name, args.paused)
+    oprot.writeMessageBegin("addFromCollector", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_getPackageOrder(self, seqid, iprot, oprot):
-    args = getPackageOrder_args()
+  def process_renameCollPack(self, seqid, iprot, oprot):
+    args = renameCollPack_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getPackageOrder_result()
-    result.success = self._handler.getPackageOrder(args.destination)
-    oprot.writeMessageBegin("getPackageOrder", TMessageType.REPLY, seqid)
+    result = renameCollPack_result()
+    self._handler.renameCollPack(args.name, args.new_name)
+    oprot.writeMessageBegin("renameCollPack", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_getFileOrder(self, seqid, iprot, oprot):
-    args = getFileOrder_args()
+  def process_deleteCollPack(self, seqid, iprot, oprot):
+    args = deleteCollPack_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getFileOrder_result()
-    result.success = self._handler.getFileOrder(args.pid)
-    oprot.writeMessageBegin("getFileOrder", TMessageType.REPLY, seqid)
+    result = deleteCollPack_result()
+    self._handler.deleteCollPack(args.name)
+    oprot.writeMessageBegin("deleteCollPack", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_generateAndAddPackages(self, seqid, iprot, oprot):
-    args = generateAndAddPackages_args()
+  def process_deleteCollLink(self, seqid, iprot, oprot):
+    args = deleteCollLink_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = generateAndAddPackages_result()
-    result.success = self._handler.generateAndAddPackages(args.links, args.dest)
-    oprot.writeMessageBegin("generateAndAddPackages", TMessageType.REPLY, seqid)
+    result = deleteCollLink_result()
+    self._handler.deleteCollLink(args.url)
+    oprot.writeMessageBegin("deleteCollLink", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_addPackage(self, seqid, iprot, oprot):
-    args = addPackage_args()
+  def process_getAllFiles(self, seqid, iprot, oprot):
+    args = getAllFiles_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = addPackage_result()
-    result.success = self._handler.addPackage(args.name, args.links, args.dest, args.password)
-    oprot.writeMessageBegin("addPackage", TMessageType.REPLY, seqid)
+    result = getAllFiles_result()
+    result.success = self._handler.getAllFiles()
+    oprot.writeMessageBegin("getAllFiles", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_addFiles(self, seqid, iprot, oprot):
-    args = addFiles_args()
+  def process_getAllUnfinishedFiles(self, seqid, iprot, oprot):
+    args = getAllUnfinishedFiles_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = addFiles_result()
-    self._handler.addFiles(args.pid, args.links)
-    oprot.writeMessageBegin("addFiles", TMessageType.REPLY, seqid)
+    result = getAllUnfinishedFiles_result()
+    result.success = self._handler.getAllUnfinishedFiles()
+    oprot.writeMessageBegin("getAllUnfinishedFiles", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_uploadContainer(self, seqid, iprot, oprot):
-    args = uploadContainer_args()
+  def process_getFileTree(self, seqid, iprot, oprot):
+    args = getFileTree_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = uploadContainer_result()
-    self._handler.uploadContainer(args.filename, args.data)
-    oprot.writeMessageBegin("uploadContainer", TMessageType.REPLY, seqid)
+    result = getFileTree_result()
+    result.success = self._handler.getFileTree(args.pid, args.full)
+    oprot.writeMessageBegin("getFileTree", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_deleteFiles(self, seqid, iprot, oprot):
-    args = deleteFiles_args()
+  def process_getUnfinishedFileTree(self, seqid, iprot, oprot):
+    args = getUnfinishedFileTree_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = deleteFiles_result()
-    self._handler.deleteFiles(args.fids)
-    oprot.writeMessageBegin("deleteFiles", TMessageType.REPLY, seqid)
+    result = getUnfinishedFileTree_result()
+    result.success = self._handler.getUnfinishedFileTree(args.pid, args.full)
+    oprot.writeMessageBegin("getUnfinishedFileTree", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_deletePackages(self, seqid, iprot, oprot):
-    args = deletePackages_args()
+  def process_getPackageContent(self, seqid, iprot, oprot):
+    args = getPackageContent_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = deletePackages_result()
-    self._handler.deletePackages(args.pids)
-    oprot.writeMessageBegin("deletePackages", TMessageType.REPLY, seqid)
+    result = getPackageContent_result()
+    result.success = self._handler.getPackageContent(args.pid)
+    oprot.writeMessageBegin("getPackageContent", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_pushToQueue(self, seqid, iprot, oprot):
-    args = pushToQueue_args()
+  def process_getPackageInfo(self, seqid, iprot, oprot):
+    args = getPackageInfo_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = pushToQueue_result()
-    self._handler.pushToQueue(args.pid)
-    oprot.writeMessageBegin("pushToQueue", TMessageType.REPLY, seqid)
+    result = getPackageInfo_result()
+    try:
+      result.success = self._handler.getPackageInfo(args.pid)
+    except PackageDoesNotExists, e:
+      result.e = e
+    oprot.writeMessageBegin("getPackageInfo", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_pullFromQueue(self, seqid, iprot, oprot):
-    args = pullFromQueue_args()
+  def process_getFileInfo(self, seqid, iprot, oprot):
+    args = getFileInfo_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = pullFromQueue_result()
-    self._handler.pullFromQueue(args.pid)
-    oprot.writeMessageBegin("pullFromQueue", TMessageType.REPLY, seqid)
+    result = getFileInfo_result()
+    try:
+      result.success = self._handler.getFileInfo(args.fid)
+    except FileDoesNotExists, e:
+      result.e = e
+    oprot.writeMessageBegin("getFileInfo", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_findFiles(self, seqid, iprot, oprot):
+    args = findFiles_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = findFiles_result()
+    result.success = self._handler.findFiles(args.pattern)
+    oprot.writeMessageBegin("findFiles", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
@@ -3039,6 +3685,17 @@ class Processor(Iface, TProcessor):
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
+  def process_stopDownloads(self, seqid, iprot, oprot):
+    args = stopDownloads_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = stopDownloads_result()
+    self._handler.stopDownloads(args.fids)
+    oprot.writeMessageBegin("stopDownloads", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
   def process_stopAllDownloads(self, seqid, iprot, oprot):
     args = stopAllDownloads_args()
     args.read(iprot)
@@ -3050,24 +3707,69 @@ class Processor(Iface, TProcessor):
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_stopDownloads(self, seqid, iprot, oprot):
-    args = stopDownloads_args()
+  def process_restartFailed(self, seqid, iprot, oprot):
+    args = restartFailed_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = stopDownloads_result()
-    self._handler.stopDownloads(args.fids)
-    oprot.writeMessageBegin("stopDownloads", TMessageType.REPLY, seqid)
+    result = restartFailed_result()
+    self._handler.restartFailed()
+    oprot.writeMessageBegin("restartFailed", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_setFilePaused(self, seqid, iprot, oprot):
+    args = setFilePaused_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = setFilePaused_result()
+    try:
+      self._handler.setFilePaused(args.fid, args.paused)
+    except FileDoesNotExists, e:
+      result.e = e
+    oprot.writeMessageBegin("setFilePaused", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_setPackagePaused(self, seqid, iprot, oprot):
+    args = setPackagePaused_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = setPackagePaused_result()
+    try:
+      self._handler.setPackagePaused(args.pid, args.paused)
+    except PackageDoesNotExists, e:
+      result.e = e
+    oprot.writeMessageBegin("setPackagePaused", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_setPackageFolder(self, seqid, iprot, oprot):
+    args = setPackageFolder_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = setPackageFolder_result()
+    try:
+      result.success = self._handler.setPackageFolder(args.pid, args.path)
+    except PackageDoesNotExists, e:
+      result.e = e
+    oprot.writeMessageBegin("setPackageFolder", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_setPackageName(self, seqid, iprot, oprot):
-    args = setPackageName_args()
+  def process_setPackageData(self, seqid, iprot, oprot):
+    args = setPackageData_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = setPackageName_result()
-    self._handler.setPackageName(args.pid, args.name)
-    oprot.writeMessageBegin("setPackageName", TMessageType.REPLY, seqid)
+    result = setPackageData_result()
+    try:
+      self._handler.setPackageData(args.pid, args.data)
+    except PackageDoesNotExists, e:
+      result.e = e
+    oprot.writeMessageBegin("setPackageData", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
@@ -3077,7 +3779,10 @@ class Processor(Iface, TProcessor):
     args.read(iprot)
     iprot.readMessageEnd()
     result = movePackage_result()
-    self._handler.movePackage(args.destination, args.pid)
+    try:
+      result.success = self._handler.movePackage(args.pid, args.root)
+    except PackageDoesNotExists, e:
+      result.e = e
     oprot.writeMessageBegin("movePackage", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
@@ -3088,7 +3793,10 @@ class Processor(Iface, TProcessor):
     args.read(iprot)
     iprot.readMessageEnd()
     result = moveFiles_result()
-    self._handler.moveFiles(args.fids, args.pid)
+    try:
+      result.success = self._handler.moveFiles(args.fids, args.pid)
+    except PackageDoesNotExists, e:
+      result.e = e
     oprot.writeMessageBegin("moveFiles", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
@@ -3099,55 +3807,85 @@ class Processor(Iface, TProcessor):
     args.read(iprot)
     iprot.readMessageEnd()
     result = orderPackage_result()
-    self._handler.orderPackage(args.pid, args.position)
+    self._handler.orderPackage(args.pids, args.position)
     oprot.writeMessageBegin("orderPackage", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_orderFile(self, seqid, iprot, oprot):
-    args = orderFile_args()
+  def process_orderFiles(self, seqid, iprot, oprot):
+    args = orderFiles_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = orderFile_result()
-    self._handler.orderFile(args.fid, args.position)
-    oprot.writeMessageBegin("orderFile", TMessageType.REPLY, seqid)
+    result = orderFiles_result()
+    self._handler.orderFiles(args.fids, args.pid, args.position)
+    oprot.writeMessageBegin("orderFiles", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_setPackageData(self, seqid, iprot, oprot):
-    args = setPackageData_args()
+  def process_isInteractionWaiting(self, seqid, iprot, oprot):
+    args = isInteractionWaiting_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = setPackageData_result()
-    try:
-      self._handler.setPackageData(args.pid, args.data)
-    except PackageDoesNotExists, e:
-      result.e = e
-    oprot.writeMessageBegin("setPackageData", TMessageType.REPLY, seqid)
+    result = isInteractionWaiting_result()
+    result.success = self._handler.isInteractionWaiting(args.mode)
+    oprot.writeMessageBegin("isInteractionWaiting", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_deleteFinished(self, seqid, iprot, oprot):
-    args = deleteFinished_args()
+  def process_getInteractionTask(self, seqid, iprot, oprot):
+    args = getInteractionTask_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = deleteFinished_result()
-    result.success = self._handler.deleteFinished()
-    oprot.writeMessageBegin("deleteFinished", TMessageType.REPLY, seqid)
+    result = getInteractionTask_result()
+    result.success = self._handler.getInteractionTask(args.mode)
+    oprot.writeMessageBegin("getInteractionTask", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_restartFailed(self, seqid, iprot, oprot):
-    args = restartFailed_args()
+  def process_setInteractionResult(self, seqid, iprot, oprot):
+    args = setInteractionResult_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = restartFailed_result()
-    self._handler.restartFailed()
-    oprot.writeMessageBegin("restartFailed", TMessageType.REPLY, seqid)
+    result = setInteractionResult_result()
+    self._handler.setInteractionResult(args.iid, args.result)
+    oprot.writeMessageBegin("setInteractionResult", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_generateDownloadLink(self, seqid, iprot, oprot):
+    args = generateDownloadLink_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = generateDownloadLink_result()
+    result.success = self._handler.generateDownloadLink(args.fid, args.timeout)
+    oprot.writeMessageBegin("generateDownloadLink", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getAddonHandler(self, seqid, iprot, oprot):
+    args = getAddonHandler_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getAddonHandler_result()
+    result.success = self._handler.getAddonHandler()
+    oprot.writeMessageBegin("getAddonHandler", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_callAddonHandler(self, seqid, iprot, oprot):
+    args = callAddonHandler_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = callAddonHandler_result()
+    self._handler.callAddonHandler(args.plugin, args.func, args.pid_or_fid)
+    oprot.writeMessageBegin("callAddonHandler", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
@@ -3271,7 +4009,7 @@ class Processor(Iface, TProcessor):
     iprot.readMessageEnd()
     result = call_result()
     try:
-      result.success = self._handler.call(args.info)
+      result.success = self._handler.call(args.plugin, args.func, args.arguments)
     except ServiceDoesNotExists, ex:
       result.ex = ex
     except ServiceException, e:
@@ -3303,77 +4041,46 @@ class Processor(Iface, TProcessor):
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_isCaptchaWaiting(self, seqid, iprot, oprot):
-    args = isCaptchaWaiting_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = isCaptchaWaiting_result()
-    result.success = self._handler.isCaptchaWaiting()
-    oprot.writeMessageBegin("isCaptchaWaiting", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
 
-  def process_getCaptchaTask(self, seqid, iprot, oprot):
-    args = getCaptchaTask_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getCaptchaTask_result()
-    result.success = self._handler.getCaptchaTask(args.exclusive)
-    oprot.writeMessageBegin("getCaptchaTask", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+# HELPER FUNCTIONS AND STRUCTURES
 
-  def process_getCaptchaTaskStatus(self, seqid, iprot, oprot):
-    args = getCaptchaTaskStatus_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getCaptchaTaskStatus_result()
-    result.success = self._handler.getCaptchaTaskStatus(args.tid)
-    oprot.writeMessageBegin("getCaptchaTaskStatus", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+class getServerVersion_args(TBase):
 
-  def process_setCaptchaResult(self, seqid, iprot, oprot):
-    args = setCaptchaResult_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = setCaptchaResult_result()
-    self._handler.setCaptchaResult(args.tid, args.result)
-    oprot.writeMessageBegin("setCaptchaResult", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  __slots__ = [ 
+   ]
 
+  thrift_spec = (
+  )
 
-# HELPER FUNCTIONS AND STRUCTURES
 
-class getConfigValue_args(TBase):
+class getServerVersion_result(TBase):
   """
   Attributes:
-   - section
-   - option
+   - success
   """
 
   __slots__ = [ 
-    'section',
-    'option',
+    'success',
    ]
 
   thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'section', None, None, ), # 1
-    (2, TType.STRING, 'option', None, None, ), # 2
+    (0, TType.STRING, 'success', None, None, ), # 0
   )
 
-  def __init__(self, section=None, option=None,):
-    self.section = section
-    self.option = option
+  def __init__(self, success=None,):
+    self.success = success
 
 
-class getConfigValue_result(TBase):
+class statusServer_args(TBase):
+
+  __slots__ = [ 
+   ]
+
+  thrift_spec = (
+  )
+
+
+class statusServer_result(TBase):
   """
   Attributes:
    - success
@@ -3384,41 +4091,23 @@ class getConfigValue_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.STRING, 'success', None, None, ), # 0
+    (0, TType.STRUCT, 'success', (ServerStatus, ServerStatus.thrift_spec), None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class setConfigValue_args(TBase):
-  """
-  Attributes:
-   - section
-   - option
-   - value
-  """
+class pauseServer_args(TBase):
 
   __slots__ = [ 
-    'section',
-    'option',
-    'value',
    ]
 
   thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'section', None, None, ), # 1
-    (2, TType.STRING, 'option', None, None, ), # 2
-    (3, TType.STRING, 'value', None, None, ), # 3
   )
 
-  def __init__(self, section=None, option=None, value=None,):
-    self.section = section
-    self.option = option
-    self.value = value
 
-
-class setConfigValue_result(TBase):
+class pauseServer_result(TBase):
 
   __slots__ = [ 
    ]
@@ -3427,7 +4116,7 @@ class setConfigValue_result(TBase):
   )
 
 
-class getConfig_args(TBase):
+class unpauseServer_args(TBase):
 
   __slots__ = [ 
    ]
@@ -3436,25 +4125,16 @@ class getConfig_args(TBase):
   )
 
 
-class getConfig_result(TBase):
-  """
-  Attributes:
-   - success
-  """
+class unpauseServer_result(TBase):
 
   __slots__ = [ 
-    'success',
    ]
 
   thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(ConfigSection, ConfigSection.thrift_spec)), None, ), # 0
   )
 
-  def __init__(self, success=None,):
-    self.success = success
-
 
-class getPluginConfig_args(TBase):
+class togglePause_args(TBase):
 
   __slots__ = [ 
    ]
@@ -3463,7 +4143,7 @@ class getPluginConfig_args(TBase):
   )
 
 
-class getPluginConfig_result(TBase):
+class togglePause_result(TBase):
   """
   Attributes:
    - success
@@ -3474,33 +4154,23 @@ class getPluginConfig_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(ConfigSection, ConfigSection.thrift_spec)), None, ), # 0
+    (0, TType.BOOL, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class configureSection_args(TBase):
-  """
-  Attributes:
-   - section
-  """
+class freeSpace_args(TBase):
 
   __slots__ = [ 
-    'section',
    ]
 
   thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'section', None, None, ), # 1
   )
 
-  def __init__(self, section=None,):
-    self.section = section
 
-
-class configureSection_result(TBase):
+class freeSpace_result(TBase):
   """
   Attributes:
    - success
@@ -3511,14 +4181,14 @@ class configureSection_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (ConfigSection, ConfigSection.thrift_spec), None, ), # 0
+    (0, TType.I64, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class pauseServer_args(TBase):
+class kill_args(TBase):
 
   __slots__ = [ 
    ]
@@ -3527,7 +4197,7 @@ class pauseServer_args(TBase):
   )
 
 
-class pauseServer_result(TBase):
+class kill_result(TBase):
 
   __slots__ = [ 
    ]
@@ -3536,7 +4206,7 @@ class pauseServer_result(TBase):
   )
 
 
-class unpauseServer_args(TBase):
+class restart_args(TBase):
 
   __slots__ = [ 
    ]
@@ -3545,7 +4215,7 @@ class unpauseServer_args(TBase):
   )
 
 
-class unpauseServer_result(TBase):
+class restart_result(TBase):
 
   __slots__ = [ 
    ]
@@ -3554,16 +4224,26 @@ class unpauseServer_result(TBase):
   )
 
 
-class togglePause_args(TBase):
+class getLog_args(TBase):
+  """
+  Attributes:
+   - offset
+  """
 
   __slots__ = [ 
+    'offset',
    ]
 
   thrift_spec = (
+    None, # 0
+    (1, TType.I32, 'offset', None, None, ), # 1
   )
 
+  def __init__(self, offset=None,):
+    self.offset = offset
 
-class togglePause_result(TBase):
+
+class getLog_result(TBase):
   """
   Attributes:
    - success
@@ -3574,14 +4254,14 @@ class togglePause_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class statusServer_args(TBase):
+class isTimeDownload_args(TBase):
 
   __slots__ = [ 
    ]
@@ -3590,7 +4270,7 @@ class statusServer_args(TBase):
   )
 
 
-class statusServer_result(TBase):
+class isTimeDownload_result(TBase):
   """
   Attributes:
    - success
@@ -3601,14 +4281,14 @@ class statusServer_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (ServerStatus, ServerStatus.thrift_spec), None, ), # 0
+    (0, TType.BOOL, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class freeSpace_args(TBase):
+class isTimeReconnect_args(TBase):
 
   __slots__ = [ 
    ]
@@ -3617,7 +4297,7 @@ class freeSpace_args(TBase):
   )
 
 
-class freeSpace_result(TBase):
+class isTimeReconnect_result(TBase):
   """
   Attributes:
    - success
@@ -3628,14 +4308,14 @@ class freeSpace_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.I64, 'success', None, None, ), # 0
+    (0, TType.BOOL, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class getServerVersion_args(TBase):
+class toggleReconnect_args(TBase):
 
   __slots__ = [ 
    ]
@@ -3644,7 +4324,7 @@ class getServerVersion_args(TBase):
   )
 
 
-class getServerVersion_result(TBase):
+class toggleReconnect_result(TBase):
   """
   Attributes:
    - success
@@ -3655,14 +4335,14 @@ class getServerVersion_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.STRING, 'success', None, None, ), # 0
+    (0, TType.BOOL, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class kill_args(TBase):
+class scanDownloadFolder_args(TBase):
 
   __slots__ = [ 
    ]
@@ -3671,7 +4351,7 @@ class kill_args(TBase):
   )
 
 
-class kill_result(TBase):
+class scanDownloadFolder_result(TBase):
 
   __slots__ = [ 
    ]
@@ -3680,7 +4360,7 @@ class kill_result(TBase):
   )
 
 
-class restart_args(TBase):
+class getProgressInfo_args(TBase):
 
   __slots__ = [ 
    ]
@@ -3689,35 +4369,48 @@ class restart_args(TBase):
   )
 
 
-class restart_result(TBase):
+class getProgressInfo_result(TBase):
+  """
+  Attributes:
+   - success
+  """
 
   __slots__ = [ 
+    'success',
    ]
 
   thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(ProgressInfo, ProgressInfo.thrift_spec)), None, ), # 0
   )
 
+  def __init__(self, success=None,):
+    self.success = success
 
-class getLog_args(TBase):
+
+class getConfigValue_args(TBase):
   """
   Attributes:
-   - offset
+   - section
+   - option
   """
 
   __slots__ = [ 
-    'offset',
+    'section',
+    'option',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'offset', None, None, ), # 1
+    (1, TType.STRING, 'section', None, None, ), # 1
+    (2, TType.STRING, 'option', None, None, ), # 2
   )
 
-  def __init__(self, offset=None,):
-    self.offset = offset
+  def __init__(self, section=None, option=None,):
+    self.section = section
+    self.option = option
 
 
-class getLog_result(TBase):
+class getConfigValue_result(TBase):
   """
   Attributes:
    - success
@@ -3728,41 +4421,50 @@ class getLog_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
+    (0, TType.STRING, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class isTimeDownload_args(TBase):
+class setConfigValue_args(TBase):
+  """
+  Attributes:
+   - section
+   - option
+   - value
+  """
 
   __slots__ = [ 
+    'section',
+    'option',
+    'value',
    ]
 
   thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'section', None, None, ), # 1
+    (2, TType.STRING, 'option', None, None, ), # 2
+    (3, TType.STRING, 'value', None, None, ), # 3
   )
 
+  def __init__(self, section=None, option=None, value=None,):
+    self.section = section
+    self.option = option
+    self.value = value
 
-class isTimeDownload_result(TBase):
-  """
-  Attributes:
-   - success
-  """
+
+class setConfigValue_result(TBase):
 
   __slots__ = [ 
-    'success',
    ]
 
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
   )
 
-  def __init__(self, success=None,):
-    self.success = success
-
 
-class isTimeReconnect_args(TBase):
+class getConfig_args(TBase):
 
   __slots__ = [ 
    ]
@@ -3771,7 +4473,7 @@ class isTimeReconnect_args(TBase):
   )
 
 
-class isTimeReconnect_result(TBase):
+class getConfig_result(TBase):
   """
   Attributes:
    - success
@@ -3782,14 +4484,14 @@ class isTimeReconnect_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(ConfigSection, ConfigSection.thrift_spec)), None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class toggleReconnect_args(TBase):
+class getPluginConfig_args(TBase):
 
   __slots__ = [ 
    ]
@@ -3798,7 +4500,7 @@ class toggleReconnect_args(TBase):
   )
 
 
-class toggleReconnect_result(TBase):
+class getPluginConfig_result(TBase):
   """
   Attributes:
    - success
@@ -3809,33 +4511,33 @@ class toggleReconnect_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(ConfigSection, ConfigSection.thrift_spec)), None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class generatePackages_args(TBase):
+class configureSection_args(TBase):
   """
   Attributes:
-   - links
+   - section
   """
 
   __slots__ = [ 
-    'links',
+    'section',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.LIST, 'links', (TType.STRING,None), None, ), # 1
+    (1, TType.STRING, 'section', None, None, ), # 1
   )
 
-  def __init__(self, links=None,):
-    self.links = links
+  def __init__(self, section=None,):
+    self.section = section
 
 
-class generatePackages_result(TBase):
+class configureSection_result(TBase):
   """
   Attributes:
    - success
@@ -3846,13 +4548,49 @@ class generatePackages_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRING,None)), None, ), # 0
+    (0, TType.STRUCT, 'success', (ConfigSection, ConfigSection.thrift_spec), None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
+class setConfigHandler_args(TBase):
+  """
+  Attributes:
+   - plugin
+   - iid
+   - value
+  """
+
+  __slots__ = [ 
+    'plugin',
+    'iid',
+    'value',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'plugin', None, None, ), # 1
+    (2, TType.I32, 'iid', None, None, ), # 2
+    (3, TType.STRING, 'value', None, None, ), # 3
+  )
+
+  def __init__(self, plugin=None, iid=None, value=None,):
+    self.plugin = plugin
+    self.iid = iid
+    self.value = value
+
+
+class setConfigHandler_result(TBase):
+
+  __slots__ = [ 
+   ]
+
+  thrift_spec = (
+  )
+
+
 class checkURLs_args(TBase):
   """
   Attributes:
@@ -4050,16 +4788,26 @@ class pollResults_result(TBase):
     self.success = success
 
 
-class statusDownloads_args(TBase):
+class generatePackages_args(TBase):
+  """
+  Attributes:
+   - links
+  """
 
   __slots__ = [ 
+    'links',
    ]
 
   thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'links', (TType.STRING,None), None, ), # 1
   )
 
+  def __init__(self, links=None,):
+    self.links = links
+
 
-class statusDownloads_result(TBase):
+class generatePackages_result(TBase):
   """
   Attributes:
    - success
@@ -4070,146 +4818,180 @@ class statusDownloads_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(DownloadInfo, DownloadInfo.thrift_spec)), None, ), # 0
+    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRING,None)), None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class getPackageData_args(TBase):
+class generateAndAddPackages_args(TBase):
   """
   Attributes:
-   - pid
+   - links
+   - paused
   """
 
   __slots__ = [ 
-    'pid',
+    'links',
+    'paused',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
+    (1, TType.LIST, 'links', (TType.STRING,None), None, ), # 1
+    (2, TType.BOOL, 'paused', None, None, ), # 2
   )
 
-  def __init__(self, pid=None,):
-    self.pid = pid
+  def __init__(self, links=None, paused=None,):
+    self.links = links
+    self.paused = paused
 
 
-class getPackageData_result(TBase):
+class generateAndAddPackages_result(TBase):
   """
   Attributes:
    - success
-   - e
   """
 
   __slots__ = [ 
     'success',
-    'e',
    ]
 
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (PackageData, PackageData.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
+    (0, TType.LIST, 'success', (TType.I32,None), None, ), # 0
   )
 
-  def __init__(self, success=None, e=None,):
+  def __init__(self, success=None,):
     self.success = success
-    self.e = e
 
 
-class getPackageInfo_args(TBase):
+class autoAddLinks_args(TBase):
   """
   Attributes:
-   - pid
+   - links
   """
 
   __slots__ = [ 
-    'pid',
+    'links',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
+    (1, TType.LIST, 'links', (TType.STRING,None), None, ), # 1
   )
 
-  def __init__(self, pid=None,):
-    self.pid = pid
+  def __init__(self, links=None,):
+    self.links = links
 
 
-class getPackageInfo_result(TBase):
+class autoAddLinks_result(TBase):
   """
   Attributes:
    - success
-   - e
   """
 
   __slots__ = [ 
     'success',
-    'e',
    ]
 
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (PackageData, PackageData.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
+    (0, TType.LIST, 'success', (TType.I32,None), None, ), # 0
   )
 
-  def __init__(self, success=None, e=None,):
+  def __init__(self, success=None,):
     self.success = success
-    self.e = e
 
 
-class getFileData_args(TBase):
+class createPackage_args(TBase):
   """
   Attributes:
-   - fid
+   - name
+   - folder
+   - root
+   - password
+   - site
+   - comment
+   - paused
   """
 
   __slots__ = [ 
-    'fid',
+    'name',
+    'folder',
+    'root',
+    'password',
+    'site',
+    'comment',
+    'paused',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'fid', None, None, ), # 1
+    (1, TType.STRING, 'name', None, None, ), # 1
+    (2, TType.STRING, 'folder', None, None, ), # 2
+    (3, TType.I32, 'root', None, None, ), # 3
+    (4, TType.STRING, 'password', None, None, ), # 4
+    (5, TType.STRING, 'site', None, None, ), # 5
+    (6, TType.STRING, 'comment', None, None, ), # 6
+    (7, TType.BOOL, 'paused', None, None, ), # 7
   )
 
-  def __init__(self, fid=None,):
-    self.fid = fid
+  def __init__(self, name=None, folder=None, root=None, password=None, site=None, comment=None, paused=None,):
+    self.name = name
+    self.folder = folder
+    self.root = root
+    self.password = password
+    self.site = site
+    self.comment = comment
+    self.paused = paused
 
 
-class getFileData_result(TBase):
+class createPackage_result(TBase):
   """
   Attributes:
    - success
-   - e
   """
 
   __slots__ = [ 
     'success',
-    'e',
    ]
 
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (FileData, FileData.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'e', (FileDoesNotExists, FileDoesNotExists.thrift_spec), None, ), # 1
+    (0, TType.I32, 'success', None, None, ), # 0
   )
 
-  def __init__(self, success=None, e=None,):
+  def __init__(self, success=None,):
     self.success = success
-    self.e = e
 
 
-class getQueue_args(TBase):
+class addPackage_args(TBase):
+  """
+  Attributes:
+   - name
+   - links
+   - password
+  """
 
   __slots__ = [ 
+    'name',
+    'links',
+    'password',
    ]
 
   thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'name', None, None, ), # 1
+    (2, TType.LIST, 'links', (TType.STRING,None), None, ), # 2
+    (3, TType.STRING, 'password', None, None, ), # 3
   )
 
+  def __init__(self, name=None, links=None, password=None,):
+    self.name = name
+    self.links = links
+    self.password = password
+
 
-class getQueue_result(TBase):
+class addPackage_result(TBase):
   """
   Attributes:
    - success
@@ -4220,23 +5002,45 @@ class getQueue_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
+    (0, TType.I32, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class getCollector_args(TBase):
+class addPackageP_args(TBase):
+  """
+  Attributes:
+   - name
+   - links
+   - password
+   - paused
+  """
 
   __slots__ = [ 
+    'name',
+    'links',
+    'password',
+    'paused',
    ]
 
   thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'name', None, None, ), # 1
+    (2, TType.LIST, 'links', (TType.STRING,None), None, ), # 2
+    (3, TType.STRING, 'password', None, None, ), # 3
+    (4, TType.BOOL, 'paused', None, None, ), # 4
   )
 
+  def __init__(self, name=None, links=None, password=None, paused=None,):
+    self.name = name
+    self.links = links
+    self.password = password
+    self.paused = paused
+
 
-class getCollector_result(TBase):
+class addPackageP_result(TBase):
   """
   Attributes:
    - success
@@ -4247,23 +5051,49 @@ class getCollector_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
+    (0, TType.I32, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class getQueueData_args(TBase):
+class addPackageChild_args(TBase):
+  """
+  Attributes:
+   - name
+   - links
+   - password
+   - root
+   - paused
+  """
 
   __slots__ = [ 
+    'name',
+    'links',
+    'password',
+    'root',
+    'paused',
    ]
 
   thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'name', None, None, ), # 1
+    (2, TType.LIST, 'links', (TType.STRING,None), None, ), # 2
+    (3, TType.STRING, 'password', None, None, ), # 3
+    (4, TType.I32, 'root', None, None, ), # 4
+    (5, TType.BOOL, 'paused', None, None, ), # 5
   )
 
+  def __init__(self, name=None, links=None, password=None, root=None, paused=None,):
+    self.name = name
+    self.links = links
+    self.password = password
+    self.root = root
+    self.paused = paused
+
 
-class getQueueData_result(TBase):
+class addPackageChild_result(TBase):
   """
   Attributes:
    - success
@@ -4274,23 +5104,37 @@ class getQueueData_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
+    (0, TType.I32, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class getCollectorData_args(TBase):
+class uploadContainer_args(TBase):
+  """
+  Attributes:
+   - filename
+   - data
+  """
 
   __slots__ = [ 
+    'filename',
+    'data',
    ]
 
   thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'filename', None, None, ), # 1
+    (2, TType.STRING, 'data', None, None, ), # 2
   )
 
+  def __init__(self, filename=None, data=None,):
+    self.filename = filename
+    self.data = data
 
-class getCollectorData_result(TBase):
+
+class uploadContainer_result(TBase):
   """
   Attributes:
    - success
@@ -4301,70 +5145,121 @@ class getCollectorData_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
+    (0, TType.I32, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class getPackageOrder_args(TBase):
+class addLinks_args(TBase):
   """
   Attributes:
-   - destination
+   - pid
+   - links
   """
 
   __slots__ = [ 
-    'destination',
+    'pid',
+    'links',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'destination', None, None, ), # 1
+    (1, TType.I32, 'pid', None, None, ), # 1
+    (2, TType.LIST, 'links', (TType.STRING,None), None, ), # 2
   )
 
-  def __init__(self, destination=None,):
-    self.destination = destination
+  def __init__(self, pid=None, links=None,):
+    self.pid = pid
+    self.links = links
 
 
-class getPackageOrder_result(TBase):
+class addLinks_result(TBase):
   """
   Attributes:
-   - success
+   - e
   """
 
   __slots__ = [ 
-    'success',
+    'e',
    ]
 
   thrift_spec = (
-    (0, TType.MAP, 'success', (TType.I16,None,TType.I32,None), None, ), # 0
+    None, # 0
+    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
   )
 
-  def __init__(self, success=None,):
-    self.success = success
+  def __init__(self, e=None,):
+    self.e = e
 
 
-class getFileOrder_args(TBase):
+class deleteFiles_args(TBase):
   """
   Attributes:
-   - pid
+   - fids
   """
 
   __slots__ = [ 
-    'pid',
+    'fids',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
+    (1, TType.LIST, 'fids', (TType.I32,None), None, ), # 1
   )
 
-  def __init__(self, pid=None,):
-    self.pid = pid
+  def __init__(self, fids=None,):
+    self.fids = fids
+
+
+class deleteFiles_result(TBase):
+
+  __slots__ = [ 
+   ]
+
+  thrift_spec = (
+  )
+
+
+class deletePackages_args(TBase):
+  """
+  Attributes:
+   - pids
+  """
+
+  __slots__ = [ 
+    'pids',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'pids', (TType.I32,None), None, ), # 1
+  )
+
+  def __init__(self, pids=None,):
+    self.pids = pids
+
+
+class deletePackages_result(TBase):
+
+  __slots__ = [ 
+   ]
+
+  thrift_spec = (
+  )
+
+
+class getCollector_args(TBase):
 
+  __slots__ = [ 
+   ]
 
-class getFileOrder_result(TBase):
+  thrift_spec = (
+  )
+
+
+class getCollector_result(TBase):
   """
   Attributes:
    - success
@@ -4375,37 +5270,65 @@ class getFileOrder_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.MAP, 'success', (TType.I16,None,TType.I32,None), None, ), # 0
+    (0, TType.LIST, 'success', (TType.STRUCT,(LinkStatus, LinkStatus.thrift_spec)), None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class generateAndAddPackages_args(TBase):
+class addToCollector_args(TBase):
   """
   Attributes:
    - links
-   - dest
   """
 
   __slots__ = [ 
     'links',
-    'dest',
    ]
 
   thrift_spec = (
     None, # 0
     (1, TType.LIST, 'links', (TType.STRING,None), None, ), # 1
-    (2, TType.I32, 'dest', None, None, ), # 2
   )
 
-  def __init__(self, links=None, dest=None,):
+  def __init__(self, links=None,):
     self.links = links
-    self.dest = dest
 
 
-class generateAndAddPackages_result(TBase):
+class addToCollector_result(TBase):
+
+  __slots__ = [ 
+   ]
+
+  thrift_spec = (
+  )
+
+
+class addFromCollector_args(TBase):
+  """
+  Attributes:
+   - name
+   - paused
+  """
+
+  __slots__ = [ 
+    'name',
+    'paused',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'name', None, None, ), # 1
+    (2, TType.BOOL, 'paused', None, None, ), # 2
+  )
+
+  def __init__(self, name=None, paused=None,):
+    self.name = name
+    self.paused = paused
+
+
+class addFromCollector_result(TBase):
   """
   Attributes:
    - success
@@ -4416,86 +5339,93 @@ class generateAndAddPackages_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.I32,None), None, ), # 0
+    (0, TType.I32, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class addPackage_args(TBase):
+class renameCollPack_args(TBase):
   """
   Attributes:
    - name
-   - links
-   - dest
-   - password
+   - new_name
   """
 
   __slots__ = [ 
     'name',
-    'links',
-    'dest',
-    'password',
+    'new_name',
    ]
 
   thrift_spec = (
     None, # 0
     (1, TType.STRING, 'name', None, None, ), # 1
-    (2, TType.LIST, 'links', (TType.STRING,None), None, ), # 2
-    (3, TType.I32, 'dest', None, None, ), # 3
-    (4, TType.STRING, 'password', None, None, ), # 4
+    (2, TType.STRING, 'new_name', None, None, ), # 2
   )
 
-  def __init__(self, name=None, links=None, dest=None, password=None,):
+  def __init__(self, name=None, new_name=None,):
     self.name = name
-    self.links = links
-    self.dest = dest
-    self.password = password
+    self.new_name = new_name
 
 
-class addPackage_result(TBase):
+class renameCollPack_result(TBase):
+
+  __slots__ = [ 
+   ]
+
+  thrift_spec = (
+  )
+
+
+class deleteCollPack_args(TBase):
   """
   Attributes:
-   - success
+   - name
   """
 
   __slots__ = [ 
-    'success',
+    'name',
    ]
 
   thrift_spec = (
-    (0, TType.I32, 'success', None, None, ), # 0
+    None, # 0
+    (1, TType.STRING, 'name', None, None, ), # 1
   )
 
-  def __init__(self, success=None,):
-    self.success = success
+  def __init__(self, name=None,):
+    self.name = name
+
+
+class deleteCollPack_result(TBase):
+
+  __slots__ = [ 
+   ]
+
+  thrift_spec = (
+  )
 
 
-class addFiles_args(TBase):
+class deleteCollLink_args(TBase):
   """
   Attributes:
-   - pid
-   - links
+   - url
   """
 
   __slots__ = [ 
-    'pid',
-    'links',
+    'url',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-    (2, TType.LIST, 'links', (TType.STRING,None), None, ), # 2
+    (1, TType.STRING, 'url', None, None, ), # 1
   )
 
-  def __init__(self, pid=None, links=None,):
-    self.pid = pid
-    self.links = links
+  def __init__(self, url=None,):
+    self.url = url
 
 
-class addFiles_result(TBase):
+class deleteCollLink_result(TBase):
 
   __slots__ = [ 
    ]
@@ -4504,30 +5434,34 @@ class addFiles_result(TBase):
   )
 
 
-class uploadContainer_args(TBase):
+class getAllFiles_args(TBase):
+
+  __slots__ = [ 
+   ]
+
+  thrift_spec = (
+  )
+
+
+class getAllFiles_result(TBase):
   """
   Attributes:
-   - filename
-   - data
+   - success
   """
 
   __slots__ = [ 
-    'filename',
-    'data',
+    'success',
    ]
 
   thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'filename', None, None, ), # 1
-    (2, TType.STRING, 'data', None, None, ), # 2
+    (0, TType.STRUCT, 'success', (PackageView, PackageView.thrift_spec), None, ), # 0
   )
 
-  def __init__(self, filename=None, data=None,):
-    self.filename = filename
-    self.data = data
+  def __init__(self, success=None,):
+    self.success = success
 
 
-class uploadContainer_result(TBase):
+class getAllUnfinishedFiles_args(TBase):
 
   __slots__ = [ 
    ]
@@ -4536,63 +5470,107 @@ class uploadContainer_result(TBase):
   )
 
 
-class deleteFiles_args(TBase):
+class getAllUnfinishedFiles_result(TBase):
   """
   Attributes:
-   - fids
+   - success
   """
 
   __slots__ = [ 
-    'fids',
+    'success',
+   ]
+
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (PackageView, PackageView.thrift_spec), None, ), # 0
+  )
+
+  def __init__(self, success=None,):
+    self.success = success
+
+
+class getFileTree_args(TBase):
+  """
+  Attributes:
+   - pid
+   - full
+  """
+
+  __slots__ = [ 
+    'pid',
+    'full',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.LIST, 'fids', (TType.I32,None), None, ), # 1
+    (1, TType.I32, 'pid', None, None, ), # 1
+    (2, TType.BOOL, 'full', None, None, ), # 2
   )
 
-  def __init__(self, fids=None,):
-    self.fids = fids
+  def __init__(self, pid=None, full=None,):
+    self.pid = pid
+    self.full = full
 
 
-class deleteFiles_result(TBase):
+class getFileTree_result(TBase):
+  """
+  Attributes:
+   - success
+  """
 
   __slots__ = [ 
+    'success',
    ]
 
   thrift_spec = (
+    (0, TType.STRUCT, 'success', (PackageView, PackageView.thrift_spec), None, ), # 0
   )
 
+  def __init__(self, success=None,):
+    self.success = success
 
-class deletePackages_args(TBase):
+
+class getUnfinishedFileTree_args(TBase):
   """
   Attributes:
-   - pids
+   - pid
+   - full
   """
 
   __slots__ = [ 
-    'pids',
+    'pid',
+    'full',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.LIST, 'pids', (TType.I32,None), None, ), # 1
+    (1, TType.I32, 'pid', None, None, ), # 1
+    (2, TType.BOOL, 'full', None, None, ), # 2
   )
 
-  def __init__(self, pids=None,):
-    self.pids = pids
+  def __init__(self, pid=None, full=None,):
+    self.pid = pid
+    self.full = full
 
 
-class deletePackages_result(TBase):
+class getUnfinishedFileTree_result(TBase):
+  """
+  Attributes:
+   - success
+  """
 
   __slots__ = [ 
+    'success',
    ]
 
   thrift_spec = (
+    (0, TType.STRUCT, 'success', (PackageView, PackageView.thrift_spec), None, ), # 0
   )
 
+  def __init__(self, success=None,):
+    self.success = success
+
 
-class pushToQueue_args(TBase):
+class getPackageContent_args(TBase):
   """
   Attributes:
    - pid
@@ -4611,16 +5589,25 @@ class pushToQueue_args(TBase):
     self.pid = pid
 
 
-class pushToQueue_result(TBase):
+class getPackageContent_result(TBase):
+  """
+  Attributes:
+   - success
+  """
 
   __slots__ = [ 
+    'success',
    ]
 
   thrift_spec = (
+    (0, TType.STRUCT, 'success', (PackageView, PackageView.thrift_spec), None, ), # 0
   )
 
+  def __init__(self, success=None,):
+    self.success = success
+
 
-class pullFromQueue_args(TBase):
+class getPackageInfo_args(TBase):
   """
   Attributes:
    - pid
@@ -4639,14 +5626,105 @@ class pullFromQueue_args(TBase):
     self.pid = pid
 
 
-class pullFromQueue_result(TBase):
+class getPackageInfo_result(TBase):
+  """
+  Attributes:
+   - success
+   - e
+  """
 
   __slots__ = [ 
+    'success',
+    'e',
    ]
 
   thrift_spec = (
+    (0, TType.STRUCT, 'success', (PackageInfo, PackageInfo.thrift_spec), None, ), # 0
+    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
   )
 
+  def __init__(self, success=None, e=None,):
+    self.success = success
+    self.e = e
+
+
+class getFileInfo_args(TBase):
+  """
+  Attributes:
+   - fid
+  """
+
+  __slots__ = [ 
+    'fid',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.I32, 'fid', None, None, ), # 1
+  )
+
+  def __init__(self, fid=None,):
+    self.fid = fid
+
+
+class getFileInfo_result(TBase):
+  """
+  Attributes:
+   - success
+   - e
+  """
+
+  __slots__ = [ 
+    'success',
+    'e',
+   ]
+
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (FileInfo, FileInfo.thrift_spec), None, ), # 0
+    (1, TType.STRUCT, 'e', (FileDoesNotExists, FileDoesNotExists.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, success=None, e=None,):
+    self.success = success
+    self.e = e
+
+
+class findFiles_args(TBase):
+  """
+  Attributes:
+   - pattern
+  """
+
+  __slots__ = [ 
+    'pattern',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'pattern', None, None, ), # 1
+  )
+
+  def __init__(self, pattern=None,):
+    self.pattern = pattern
+
+
+class findFiles_result(TBase):
+  """
+  Attributes:
+   - success
+  """
+
+  __slots__ = [ 
+    'success',
+   ]
+
+  thrift_spec = (
+    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(FileInfo, FileInfo.thrift_spec)), None, ), # 0
+  )
+
+  def __init__(self, success=None,):
+    self.success = success
+
 
 class restartPackage_args(TBase):
   """
@@ -4732,6 +5810,34 @@ class recheckPackage_result(TBase):
   )
 
 
+class stopDownloads_args(TBase):
+  """
+  Attributes:
+   - fids
+  """
+
+  __slots__ = [ 
+    'fids',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'fids', (TType.I32,None), None, ), # 1
+  )
+
+  def __init__(self, fids=None,):
+    self.fids = fids
+
+
+class stopDownloads_result(TBase):
+
+  __slots__ = [ 
+   ]
+
+  thrift_spec = (
+  )
+
+
 class stopAllDownloads_args(TBase):
 
   __slots__ = [ 
@@ -4750,97 +5856,239 @@ class stopAllDownloads_result(TBase):
   )
 
 
-class stopDownloads_args(TBase):
+class restartFailed_args(TBase):
+
+  __slots__ = [ 
+   ]
+
+  thrift_spec = (
+  )
+
+
+class restartFailed_result(TBase):
+
+  __slots__ = [ 
+   ]
+
+  thrift_spec = (
+  )
+
+
+class setFilePaused_args(TBase):
   """
   Attributes:
-   - fids
+   - fid
+   - paused
   """
 
   __slots__ = [ 
-    'fids',
+    'fid',
+    'paused',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.LIST, 'fids', (TType.I32,None), None, ), # 1
+    (1, TType.I32, 'fid', None, None, ), # 1
+    (2, TType.BOOL, 'paused', None, None, ), # 2
   )
 
-  def __init__(self, fids=None,):
-    self.fids = fids
+  def __init__(self, fid=None, paused=None,):
+    self.fid = fid
+    self.paused = paused
 
 
-class stopDownloads_result(TBase):
+class setFilePaused_result(TBase):
+  """
+  Attributes:
+   - e
+  """
 
   __slots__ = [ 
+    'e',
    ]
 
   thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'e', (FileDoesNotExists, FileDoesNotExists.thrift_spec), None, ), # 1
   )
 
+  def __init__(self, e=None,):
+    self.e = e
+
 
-class setPackageName_args(TBase):
+class setPackagePaused_args(TBase):
   """
   Attributes:
    - pid
-   - name
+   - paused
   """
 
   __slots__ = [ 
     'pid',
-    'name',
+    'paused',
    ]
 
   thrift_spec = (
     None, # 0
     (1, TType.I32, 'pid', None, None, ), # 1
-    (2, TType.STRING, 'name', None, None, ), # 2
+    (2, TType.BOOL, 'paused', None, None, ), # 2
   )
 
-  def __init__(self, pid=None, name=None,):
+  def __init__(self, pid=None, paused=None,):
     self.pid = pid
-    self.name = name
+    self.paused = paused
+
+
+class setPackagePaused_result(TBase):
+  """
+  Attributes:
+   - e
+  """
+
+  __slots__ = [ 
+    'e',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, e=None,):
+    self.e = e
+
+
+class setPackageFolder_args(TBase):
+  """
+  Attributes:
+   - pid
+   - path
+  """
 
+  __slots__ = [ 
+    'pid',
+    'path',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.I32, 'pid', None, None, ), # 1
+    (2, TType.STRING, 'path', None, None, ), # 2
+  )
+
+  def __init__(self, pid=None, path=None,):
+    self.pid = pid
+    self.path = path
 
-class setPackageName_result(TBase):
+
+class setPackageFolder_result(TBase):
+  """
+  Attributes:
+   - success
+   - e
+  """
 
   __slots__ = [ 
+    'success',
+    'e',
    ]
 
   thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
   )
 
+  def __init__(self, success=None, e=None,):
+    self.success = success
+    self.e = e
+
+
+class setPackageData_args(TBase):
+  """
+  Attributes:
+   - pid
+   - data
+  """
+
+  __slots__ = [ 
+    'pid',
+    'data',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.I32, 'pid', None, None, ), # 1
+    (2, TType.MAP, 'data', (TType.STRING,None,TType.STRING,None), None, ), # 2
+  )
+
+  def __init__(self, pid=None, data=None,):
+    self.pid = pid
+    self.data = data
+
+
+class setPackageData_result(TBase):
+  """
+  Attributes:
+   - e
+  """
+
+  __slots__ = [ 
+    'e',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
+  )
+
+  def __init__(self, e=None,):
+    self.e = e
+
 
 class movePackage_args(TBase):
   """
   Attributes:
-   - destination
    - pid
+   - root
   """
 
   __slots__ = [ 
-    'destination',
     'pid',
+    'root',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'destination', None, None, ), # 1
-    (2, TType.I32, 'pid', None, None, ), # 2
+    (1, TType.I32, 'pid', None, None, ), # 1
+    (2, TType.I32, 'root', None, None, ), # 2
   )
 
-  def __init__(self, destination=None, pid=None,):
-    self.destination = destination
+  def __init__(self, pid=None, root=None,):
     self.pid = pid
+    self.root = root
 
 
 class movePackage_result(TBase):
+  """
+  Attributes:
+   - success
+   - e
+  """
 
   __slots__ = [ 
+    'success',
+    'e',
    ]
 
   thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
   )
 
+  def __init__(self, success=None, e=None,):
+    self.success = success
+    self.e = e
+
 
 class moveFiles_args(TBase):
   """
@@ -4866,34 +6114,47 @@ class moveFiles_args(TBase):
 
 
 class moveFiles_result(TBase):
+  """
+  Attributes:
+   - success
+   - e
+  """
 
   __slots__ = [ 
+    'success',
+    'e',
    ]
 
   thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
   )
 
+  def __init__(self, success=None, e=None,):
+    self.success = success
+    self.e = e
+
 
 class orderPackage_args(TBase):
   """
   Attributes:
-   - pid
+   - pids
    - position
   """
 
   __slots__ = [ 
-    'pid',
+    'pids',
     'position',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
+    (1, TType.LIST, 'pids', (TType.I32,None), None, ), # 1
     (2, TType.I16, 'position', None, None, ), # 2
   )
 
-  def __init__(self, pid=None, position=None,):
-    self.pid = pid
+  def __init__(self, pids=None, position=None,):
+    self.pids = pids
     self.position = position
 
 
@@ -4906,30 +6167,34 @@ class orderPackage_result(TBase):
   )
 
 
-class orderFile_args(TBase):
+class orderFiles_args(TBase):
   """
   Attributes:
-   - fid
+   - fids
+   - pid
    - position
   """
 
   __slots__ = [ 
-    'fid',
+    'fids',
+    'pid',
     'position',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'fid', None, None, ), # 1
-    (2, TType.I16, 'position', None, None, ), # 2
+    (1, TType.LIST, 'fids', (TType.I32,None), None, ), # 1
+    (2, TType.I32, 'pid', None, None, ), # 2
+    (3, TType.I16, 'position', None, None, ), # 3
   )
 
-  def __init__(self, fid=None, position=None,):
-    self.fid = fid
+  def __init__(self, fids=None, pid=None, position=None,):
+    self.fids = fids
+    self.pid = pid
     self.position = position
 
 
-class orderFile_result(TBase):
+class orderFiles_result(TBase):
 
   __slots__ = [ 
    ]
@@ -4938,49 +6203,104 @@ class orderFile_result(TBase):
   )
 
 
-class setPackageData_args(TBase):
+class isInteractionWaiting_args(TBase):
   """
   Attributes:
-   - pid
-   - data
+   - mode
   """
 
   __slots__ = [ 
-    'pid',
-    'data',
+    'mode',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-    (2, TType.MAP, 'data', (TType.STRING,None,TType.STRING,None), None, ), # 2
+    (1, TType.I16, 'mode', None, None, ), # 1
   )
 
-  def __init__(self, pid=None, data=None,):
-    self.pid = pid
-    self.data = data
+  def __init__(self, mode=None,):
+    self.mode = mode
 
 
-class setPackageData_result(TBase):
+class isInteractionWaiting_result(TBase):
   """
   Attributes:
-   - e
+   - success
   """
 
   __slots__ = [ 
-    'e',
+    'success',
+   ]
+
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+  )
+
+  def __init__(self, success=None,):
+    self.success = success
+
+
+class getInteractionTask_args(TBase):
+  """
+  Attributes:
+   - mode
+  """
+
+  __slots__ = [ 
+    'mode',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
+    (1, TType.I16, 'mode', None, None, ), # 1
   )
 
-  def __init__(self, e=None,):
-    self.e = e
+  def __init__(self, mode=None,):
+    self.mode = mode
+
+
+class getInteractionTask_result(TBase):
+  """
+  Attributes:
+   - success
+  """
+
+  __slots__ = [ 
+    'success',
+   ]
+
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (InteractionTask, InteractionTask.thrift_spec), None, ), # 0
+  )
+
+  def __init__(self, success=None,):
+    self.success = success
+
+
+class setInteractionResult_args(TBase):
+  """
+  Attributes:
+   - iid
+   - result
+  """
+
+  __slots__ = [ 
+    'iid',
+    'result',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.I32, 'iid', None, None, ), # 1
+    (2, TType.STRING, 'result', None, None, ), # 2
+  )
+
+  def __init__(self, iid=None, result=None,):
+    self.iid = iid
+    self.result = result
 
 
-class deleteFinished_args(TBase):
+class setInteractionResult_result(TBase):
 
   __slots__ = [ 
    ]
@@ -4989,7 +6309,30 @@ class deleteFinished_args(TBase):
   )
 
 
-class deleteFinished_result(TBase):
+class generateDownloadLink_args(TBase):
+  """
+  Attributes:
+   - fid
+   - timeout
+  """
+
+  __slots__ = [ 
+    'fid',
+    'timeout',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.I32, 'fid', None, None, ), # 1
+    (2, TType.I16, 'timeout', None, None, ), # 2
+  )
+
+  def __init__(self, fid=None, timeout=None,):
+    self.fid = fid
+    self.timeout = timeout
+
+
+class generateDownloadLink_result(TBase):
   """
   Attributes:
    - success
@@ -5000,14 +6343,14 @@ class deleteFinished_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.I32,None), None, ), # 0
+    (0, TType.STRING, 'success', None, None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
 
-class restartFailed_args(TBase):
+class getAddonHandler_args(TBase):
 
   __slots__ = [ 
    ]
@@ -5016,7 +6359,52 @@ class restartFailed_args(TBase):
   )
 
 
-class restartFailed_result(TBase):
+class getAddonHandler_result(TBase):
+  """
+  Attributes:
+   - success
+  """
+
+  __slots__ = [ 
+    'success',
+   ]
+
+  thrift_spec = (
+    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(AddonService, AddonService.thrift_spec))), None, ), # 0
+  )
+
+  def __init__(self, success=None,):
+    self.success = success
+
+
+class callAddonHandler_args(TBase):
+  """
+  Attributes:
+   - plugin
+   - func
+   - pid_or_fid
+  """
+
+  __slots__ = [ 
+    'plugin',
+    'func',
+    'pid_or_fid',
+   ]
+
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'plugin', None, None, ), # 1
+    (2, TType.STRING, 'func', None, None, ), # 2
+    (3, TType.I32, 'pid_or_fid', None, None, ), # 3
+  )
+
+  def __init__(self, plugin=None, func=None, pid_or_fid=None,):
+    self.plugin = plugin
+    self.func = func
+    self.pid_or_fid = pid_or_fid
+
+
+class callAddonHandler_result(TBase):
 
   __slots__ = [ 
    ]
@@ -5331,7 +6719,7 @@ class getServices_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.MAP,(TType.STRING,None,TType.STRING,None)), None, ), # 0
+    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(AddonService, AddonService.thrift_spec))), None, ), # 0
   )
 
   def __init__(self, success=None,):
@@ -5382,20 +6770,28 @@ class hasService_result(TBase):
 class call_args(TBase):
   """
   Attributes:
-   - info
+   - plugin
+   - func
+   - arguments
   """
 
   __slots__ = [ 
-    'info',
+    'plugin',
+    'func',
+    'arguments',
    ]
 
   thrift_spec = (
     None, # 0
-    (1, TType.STRUCT, 'info', (ServiceCall, ServiceCall.thrift_spec), None, ), # 1
+    (1, TType.STRING, 'plugin', None, None, ), # 1
+    (2, TType.STRING, 'func', None, None, ), # 2
+    (3, TType.STRING, 'arguments', None, None, ), # 3
   )
 
-  def __init__(self, info=None,):
-    self.info = info
+  def __init__(self, plugin=None, func=None, arguments=None,):
+    self.plugin = plugin
+    self.func = func
+    self.arguments = arguments
 
 
 class call_result(TBase):
@@ -5444,7 +6840,7 @@ class getAllInfo_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.MAP,(TType.STRING,None,TType.STRING,None)), None, ), # 0
+    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(AddonInfo, AddonInfo.thrift_spec))), None, ), # 0
   )
 
   def __init__(self, success=None,):
@@ -5481,142 +6877,9 @@ class getInfoByPlugin_result(TBase):
    ]
 
   thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class isCaptchaWaiting_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class isCaptchaWaiting_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.LIST, 'success', (TType.STRUCT,(AddonInfo, AddonInfo.thrift_spec)), None, ), # 0
   )
 
   def __init__(self, success=None,):
     self.success = success
 
-
-class getCaptchaTask_args(TBase):
-  """
-  Attributes:
-   - exclusive
-  """
-
-  __slots__ = [ 
-    'exclusive',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.BOOL, 'exclusive', None, None, ), # 1
-  )
-
-  def __init__(self, exclusive=None,):
-    self.exclusive = exclusive
-
-
-class getCaptchaTask_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRUCT, 'success', (CaptchaTask, CaptchaTask.thrift_spec), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getCaptchaTaskStatus_args(TBase):
-  """
-  Attributes:
-   - tid
-  """
-
-  __slots__ = [ 
-    'tid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'tid', None, None, ), # 1
-  )
-
-  def __init__(self, tid=None,):
-    self.tid = tid
-
-
-class getCaptchaTaskStatus_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRING, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class setCaptchaResult_args(TBase):
-  """
-  Attributes:
-   - tid
-   - result
-  """
-
-  __slots__ = [ 
-    'tid',
-    'result',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'tid', None, None, ), # 1
-    (2, TType.STRING, 'result', None, None, ), # 2
-  )
-
-  def __init__(self, tid=None, result=None,):
-    self.tid = tid
-    self.result = result
-
-
-class setCaptchaResult_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-