WebSVN – SmartDukaan – Diff – /trunk/PyProj/src/shop2020/thriftpy/model/v1/order/TransactionService.py

     pass
   def moveOrdersToCorrectWarehouse(self, ):
     pass
+  def getCreditorInfo(self, id, name):
+    """
+    Parameters:
+     - id
+     - name
+    """
+    pass
+  def updateCreditorInfo(self, creditor):
+    """
+    Parameters:
+     - creditor
+    """
+    pass
+  def getUserSanctionDetails(self, userId):
+    """
+    Parameters:
+     - userId
+    """
+    pass
+  def getUserSanctionDetailsForCreditor(self, userId, creditorId):
+    """
+    Parameters:
+     - userId
+     - creditorId
+    """
+    pass
+  def updateUserSanction(self, userSanaction):
+    """
+    Parameters:
+     - userSanaction
+    """
+    pass
+  def getCreditHistoryRecordsForTransaction(self, paymentId, creditorId, creditTxnType):
+    """
+    Parameters:
+     - paymentId
+     - creditorId
+     - creditTxnType
+    """
+    pass
+  def getCreditHistoryRecordsForUserAndCreditor(self, userId, creditTxnType):
+    """
+    Parameters:
+     - userId
+     - creditTxnType
+    """
+    pass
+  def processCreditTransaction(self, paymentId, creditTxns):
+    """
+    Parameters:
+     - paymentId
+     - creditTxns
+    """
+    pass
+  def getLoanPayableForUserToCreditor(self, userId, creditorId, dueDate):
+    """
+    Parameters:
+     - userId
+     - creditorId
+     - dueDate
+    """
+    pass
+  def getReturnOrderInfo(self, id):
+    """
+    Parameters:
+     - id
+    """
+    pass
+  def getReturnOrderInfoList(self, order_ids):
+    """
+    Parameters:
+     - order_ids
+    """
+    pass
+  def getReturnOrderInfoListAsByStatus(self, order_ids, statuses):
+    """
+    Parameters:
+     - order_ids
+     - statuses
+    """
+    pass
+  def updateReturnOrderInfo(self, returnInfo):
+    """
+    Parameters:
+     - returnInfo
+    """
+    pass
+  def bulkUpdateReturnOrderInfo(self, orderReturnInfosMap):
+    """
+    Parameters:
+     - orderReturnInfosMap
+    """
+    pass
+  def getReturnOrdersAsPerWarehouseId(self, warehouseId):
+    """
+    Parameters:
+     - warehouseId
+    """
+    pass
+  def createReturnTransaction(self, returnTransaction):
+    """
+    Parameters:
+     - returnTransaction
+    """
+    pass
+  def getReturnTransaction(self, id):
+    """
+    Parameters:
+     - id
+    """
+    pass
+  def getReturnOrdersForReturnTransaction(self, returnTransactionId):
+    """
+    Parameters:
+     - returnTransactionId
+    """
+    pass
+  def changeReturnTransactionStatus(self, returnTransactionId, status, returnOrderIds):
+    """
+    Parameters:
+     - returnTransactionId
+     - status
+     - returnOrderIds
+    """
+    pass
+  def createReturnPickupRequest(self, returnOrderIds, providerId):
+    """
+    Parameters:
+     - returnOrderIds
+     - providerId
+    """
+    pass
+  def updateReturnPickupRequest(self, returnPickupRequest):
+    """
+    Parameters:
+     - returnPickupRequest
+    """
+    pass
+  def getAllReturnOrdersForReturnPickupRequest(self, logisticsRequestId):
+    """
+    Parameters:
+     - logisticsRequestId
+    """
+    pass
+  def receiveReturnPickup(self, returnOrdersMap, id):
+    """
+    Parameters:
+     - returnOrdersMap
+     - id
+    """
+    pass
+  def validateReturnPickup(self, returnPickupId, returnOrdersMap):
+    """
+    Parameters:
+     - returnPickupId
+     - returnOrdersMap
+    """
+    pass
+  def processReturnPickup(self, returnPickupId, returnOrdersMap):
+    """
+    Parameters:
+     - returnPickupId
+     - returnOrdersMap
+    """
+    pass
+  def markReturnTransactionComplete(self, returnTransactionId):
+    """
+    Parameters:
+     - returnTransactionId
+    """
+    pass
+  def refundReturnTransactionPayment(self, refundOrdersMap, returntransactionId):
+    """
+    Parameters:
+     - refundOrdersMap
+     - returntransactionId
+    """
+    pass
+  def getReturnTransactionsForCustomer(self, statusList, customerMobile, customerEmail, returnTransactionId, customerId):
+    """
+    Parameters:
+     - statusList
+     - customerMobile
+     - customerEmail
+     - returnTransactionId
+     - customerId
+    """
+    pass
+  def verifyOrderForTransaction(self, transactionId):
+    """
+    Parameters:
+     - transactionId
+    """
+    pass
 class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
   def __init__(self, iprot, oprot=None):
     shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "moveOrdersToCorrectWarehouse failed: unknown result");
+  def getCreditorInfo(self, id, name):
+    """
+    Parameters:
+     - id
+     - name
+    """
+    self.send_getCreditorInfo(id, name)
+    return self.recv_getCreditorInfo()
+  def send_getCreditorInfo(self, id, name):
+    self._oprot.writeMessageBegin('getCreditorInfo', TMessageType.CALL, self._seqid)
+    args = getCreditorInfo_args()
+    args.id = id
+    args.name = name
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getCreditorInfo(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getCreditorInfo_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCreditorInfo failed: unknown result");
+  def updateCreditorInfo(self, creditor):
+    """
+    Parameters:
+     - creditor
+    """
+    self.send_updateCreditorInfo(creditor)
+    return self.recv_updateCreditorInfo()
+  def send_updateCreditorInfo(self, creditor):
+    self._oprot.writeMessageBegin('updateCreditorInfo', TMessageType.CALL, self._seqid)
+    args = updateCreditorInfo_args()
+    args.creditor = creditor
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateCreditorInfo(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateCreditorInfo_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateCreditorInfo failed: unknown result");
+  def getUserSanctionDetails(self, userId):
+    """
+    Parameters:
+     - userId
+    """
+    self.send_getUserSanctionDetails(userId)
+    return self.recv_getUserSanctionDetails()
+  def send_getUserSanctionDetails(self, userId):
+    self._oprot.writeMessageBegin('getUserSanctionDetails', TMessageType.CALL, self._seqid)
+    args = getUserSanctionDetails_args()
+    args.userId = userId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getUserSanctionDetails(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getUserSanctionDetails_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserSanctionDetails failed: unknown result");
+  def getUserSanctionDetailsForCreditor(self, userId, creditorId):
+    """
+    Parameters:
+     - userId
+     - creditorId
+    """
+    self.send_getUserSanctionDetailsForCreditor(userId, creditorId)
+    return self.recv_getUserSanctionDetailsForCreditor()
+  def send_getUserSanctionDetailsForCreditor(self, userId, creditorId):
+    self._oprot.writeMessageBegin('getUserSanctionDetailsForCreditor', TMessageType.CALL, self._seqid)
+    args = getUserSanctionDetailsForCreditor_args()
+    args.userId = userId
+    args.creditorId = creditorId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getUserSanctionDetailsForCreditor(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getUserSanctionDetailsForCreditor_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserSanctionDetailsForCreditor failed: unknown result");
+  def updateUserSanction(self, userSanaction):
+    """
+    Parameters:
+     - userSanaction
+    """
+    self.send_updateUserSanction(userSanaction)
+    return self.recv_updateUserSanction()
+  def send_updateUserSanction(self, userSanaction):
+    self._oprot.writeMessageBegin('updateUserSanction', TMessageType.CALL, self._seqid)
+    args = updateUserSanction_args()
+    args.userSanaction = userSanaction
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateUserSanction(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateUserSanction_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.pe is not None:
+      raise result.pe
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUserSanction failed: unknown result");
+  def getCreditHistoryRecordsForTransaction(self, paymentId, creditorId, creditTxnType):
+    """
+    Parameters:
+     - paymentId
+     - creditorId
+     - creditTxnType
+    """
+    self.send_getCreditHistoryRecordsForTransaction(paymentId, creditorId, creditTxnType)
+    return self.recv_getCreditHistoryRecordsForTransaction()
+  def send_getCreditHistoryRecordsForTransaction(self, paymentId, creditorId, creditTxnType):
+    self._oprot.writeMessageBegin('getCreditHistoryRecordsForTransaction', TMessageType.CALL, self._seqid)
+    args = getCreditHistoryRecordsForTransaction_args()
+    args.paymentId = paymentId
+    args.creditorId = creditorId
+    args.creditTxnType = creditTxnType
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getCreditHistoryRecordsForTransaction(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getCreditHistoryRecordsForTransaction_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCreditHistoryRecordsForTransaction failed: unknown result");
+  def getCreditHistoryRecordsForUserAndCreditor(self, userId, creditTxnType):
+    """
+    Parameters:
+     - userId
+     - creditTxnType
+    """
+    self.send_getCreditHistoryRecordsForUserAndCreditor(userId, creditTxnType)
+    return self.recv_getCreditHistoryRecordsForUserAndCreditor()
+  def send_getCreditHistoryRecordsForUserAndCreditor(self, userId, creditTxnType):
+    self._oprot.writeMessageBegin('getCreditHistoryRecordsForUserAndCreditor', TMessageType.CALL, self._seqid)
+    args = getCreditHistoryRecordsForUserAndCreditor_args()
+    args.userId = userId
+    args.creditTxnType = creditTxnType
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getCreditHistoryRecordsForUserAndCreditor(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getCreditHistoryRecordsForUserAndCreditor_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCreditHistoryRecordsForUserAndCreditor failed: unknown result");
+  def processCreditTransaction(self, paymentId, creditTxns):
+    """
+    Parameters:
+     - paymentId
+     - creditTxns
+    """
+    self.send_processCreditTransaction(paymentId, creditTxns)
+    return self.recv_processCreditTransaction()
+  def send_processCreditTransaction(self, paymentId, creditTxns):
+    self._oprot.writeMessageBegin('processCreditTransaction', TMessageType.CALL, self._seqid)
+    args = processCreditTransaction_args()
+    args.paymentId = paymentId
+    args.creditTxns = creditTxns
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_processCreditTransaction(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = processCreditTransaction_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.pe is not None:
+      raise result.pe
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "processCreditTransaction failed: unknown result");
+  def getLoanPayableForUserToCreditor(self, userId, creditorId, dueDate):
+    """
+    Parameters:
+     - userId
+     - creditorId
+     - dueDate
+    """
+    self.send_getLoanPayableForUserToCreditor(userId, creditorId, dueDate)
+    return self.recv_getLoanPayableForUserToCreditor()
+  def send_getLoanPayableForUserToCreditor(self, userId, creditorId, dueDate):
+    self._oprot.writeMessageBegin('getLoanPayableForUserToCreditor', TMessageType.CALL, self._seqid)
+    args = getLoanPayableForUserToCreditor_args()
+    args.userId = userId
+    args.creditorId = creditorId
+    args.dueDate = dueDate
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getLoanPayableForUserToCreditor(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getLoanPayableForUserToCreditor_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLoanPayableForUserToCreditor failed: unknown result");
+  def getReturnOrderInfo(self, id):
+    """
+    Parameters:
+     - id
+    """
+    self.send_getReturnOrderInfo(id)
+    return self.recv_getReturnOrderInfo()
+  def send_getReturnOrderInfo(self, id):
+    self._oprot.writeMessageBegin('getReturnOrderInfo', TMessageType.CALL, self._seqid)
+    args = getReturnOrderInfo_args()
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getReturnOrderInfo(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getReturnOrderInfo_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrderInfo failed: unknown result");
+  def getReturnOrderInfoList(self, order_ids):
+    """
+    Parameters:
+     - order_ids
+    """
+    self.send_getReturnOrderInfoList(order_ids)
+    return self.recv_getReturnOrderInfoList()
+  def send_getReturnOrderInfoList(self, order_ids):
+    self._oprot.writeMessageBegin('getReturnOrderInfoList', TMessageType.CALL, self._seqid)
+    args = getReturnOrderInfoList_args()
+    args.order_ids = order_ids
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getReturnOrderInfoList(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getReturnOrderInfoList_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrderInfoList failed: unknown result");
+  def getReturnOrderInfoListAsByStatus(self, order_ids, statuses):
+    """
+    Parameters:
+     - order_ids
+     - statuses
+    """
+    self.send_getReturnOrderInfoListAsByStatus(order_ids, statuses)
+    return self.recv_getReturnOrderInfoListAsByStatus()
+  def send_getReturnOrderInfoListAsByStatus(self, order_ids, statuses):
+    self._oprot.writeMessageBegin('getReturnOrderInfoListAsByStatus', TMessageType.CALL, self._seqid)
+    args = getReturnOrderInfoListAsByStatus_args()
+    args.order_ids = order_ids
+    args.statuses = statuses
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getReturnOrderInfoListAsByStatus(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getReturnOrderInfoListAsByStatus_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrderInfoListAsByStatus failed: unknown result");
+  def updateReturnOrderInfo(self, returnInfo):
+    """
+    Parameters:
+     - returnInfo
+    """
+    self.send_updateReturnOrderInfo(returnInfo)
+    return self.recv_updateReturnOrderInfo()
+  def send_updateReturnOrderInfo(self, returnInfo):
+    self._oprot.writeMessageBegin('updateReturnOrderInfo', TMessageType.CALL, self._seqid)
+    args = updateReturnOrderInfo_args()
+    args.returnInfo = returnInfo
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateReturnOrderInfo(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateReturnOrderInfo_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateReturnOrderInfo failed: unknown result");
+  def bulkUpdateReturnOrderInfo(self, orderReturnInfosMap):
+    """
+    Parameters:
+     - orderReturnInfosMap
+    """
+    self.send_bulkUpdateReturnOrderInfo(orderReturnInfosMap)
+    return self.recv_bulkUpdateReturnOrderInfo()
+  def send_bulkUpdateReturnOrderInfo(self, orderReturnInfosMap):
+    self._oprot.writeMessageBegin('bulkUpdateReturnOrderInfo', TMessageType.CALL, self._seqid)
+    args = bulkUpdateReturnOrderInfo_args()
+    args.orderReturnInfosMap = orderReturnInfosMap
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_bulkUpdateReturnOrderInfo(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = bulkUpdateReturnOrderInfo_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "bulkUpdateReturnOrderInfo failed: unknown result");
+  def getReturnOrdersAsPerWarehouseId(self, warehouseId):
+    """
+    Parameters:
+     - warehouseId
+    """
+    self.send_getReturnOrdersAsPerWarehouseId(warehouseId)
+    return self.recv_getReturnOrdersAsPerWarehouseId()
+  def send_getReturnOrdersAsPerWarehouseId(self, warehouseId):
+    self._oprot.writeMessageBegin('getReturnOrdersAsPerWarehouseId', TMessageType.CALL, self._seqid)
+    args = getReturnOrdersAsPerWarehouseId_args()
+    args.warehouseId = warehouseId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getReturnOrdersAsPerWarehouseId(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getReturnOrdersAsPerWarehouseId_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersAsPerWarehouseId failed: unknown result");
+  def createReturnTransaction(self, returnTransaction):
+    """
+    Parameters:
+     - returnTransaction
+    """
+    self.send_createReturnTransaction(returnTransaction)
+    return self.recv_createReturnTransaction()
+  def send_createReturnTransaction(self, returnTransaction):
+    self._oprot.writeMessageBegin('createReturnTransaction', TMessageType.CALL, self._seqid)
+    args = createReturnTransaction_args()
+    args.returnTransaction = returnTransaction
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_createReturnTransaction(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = createReturnTransaction_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "createReturnTransaction failed: unknown result");
+  def getReturnTransaction(self, id):
+    """
+    Parameters:
+     - id
+    """
+    self.send_getReturnTransaction(id)
+    return self.recv_getReturnTransaction()
+  def send_getReturnTransaction(self, id):
+    self._oprot.writeMessageBegin('getReturnTransaction', TMessageType.CALL, self._seqid)
+    args = getReturnTransaction_args()
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getReturnTransaction(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getReturnTransaction_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnTransaction failed: unknown result");
+  def getReturnOrdersForReturnTransaction(self, returnTransactionId):
+    """
+    Parameters:
+     - returnTransactionId
+    """
+    self.send_getReturnOrdersForReturnTransaction(returnTransactionId)
+    return self.recv_getReturnOrdersForReturnTransaction()
+  def send_getReturnOrdersForReturnTransaction(self, returnTransactionId):
+    self._oprot.writeMessageBegin('getReturnOrdersForReturnTransaction', TMessageType.CALL, self._seqid)
+    args = getReturnOrdersForReturnTransaction_args()
+    args.returnTransactionId = returnTransactionId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getReturnOrdersForReturnTransaction(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getReturnOrdersForReturnTransaction_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersForReturnTransaction failed: unknown result");
+  def changeReturnTransactionStatus(self, returnTransactionId, status, returnOrderIds):
+    """
+    Parameters:
+     - returnTransactionId
+     - status
+     - returnOrderIds
+    """
+    self.send_changeReturnTransactionStatus(returnTransactionId, status, returnOrderIds)
+    return self.recv_changeReturnTransactionStatus()
+  def send_changeReturnTransactionStatus(self, returnTransactionId, status, returnOrderIds):
+    self._oprot.writeMessageBegin('changeReturnTransactionStatus', TMessageType.CALL, self._seqid)
+    args = changeReturnTransactionStatus_args()
+    args.returnTransactionId = returnTransactionId
+    args.status = status
+    args.returnOrderIds = returnOrderIds
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_changeReturnTransactionStatus(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = changeReturnTransactionStatus_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeReturnTransactionStatus failed: unknown result");
+  def createReturnPickupRequest(self, returnOrderIds, providerId):
+    """
+    Parameters:
+     - returnOrderIds
+     - providerId
+    """
+    self.send_createReturnPickupRequest(returnOrderIds, providerId)
+    return self.recv_createReturnPickupRequest()
+  def send_createReturnPickupRequest(self, returnOrderIds, providerId):
+    self._oprot.writeMessageBegin('createReturnPickupRequest', TMessageType.CALL, self._seqid)
+    args = createReturnPickupRequest_args()
+    args.returnOrderIds = returnOrderIds
+    args.providerId = providerId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_createReturnPickupRequest(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = createReturnPickupRequest_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "createReturnPickupRequest failed: unknown result");
+  def updateReturnPickupRequest(self, returnPickupRequest):
+    """
+    Parameters:
+     - returnPickupRequest
+    """
+    self.send_updateReturnPickupRequest(returnPickupRequest)
+    return self.recv_updateReturnPickupRequest()
+  def send_updateReturnPickupRequest(self, returnPickupRequest):
+    self._oprot.writeMessageBegin('updateReturnPickupRequest', TMessageType.CALL, self._seqid)
+    args = updateReturnPickupRequest_args()
+    args.returnPickupRequest = returnPickupRequest
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateReturnPickupRequest(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateReturnPickupRequest_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateReturnPickupRequest failed: unknown result");
+  def getAllReturnOrdersForReturnPickupRequest(self, logisticsRequestId):
+    """
+    Parameters:
+     - logisticsRequestId
+    """
+    self.send_getAllReturnOrdersForReturnPickupRequest(logisticsRequestId)
+    return self.recv_getAllReturnOrdersForReturnPickupRequest()
+  def send_getAllReturnOrdersForReturnPickupRequest(self, logisticsRequestId):
+    self._oprot.writeMessageBegin('getAllReturnOrdersForReturnPickupRequest', TMessageType.CALL, self._seqid)
+    args = getAllReturnOrdersForReturnPickupRequest_args()
+    args.logisticsRequestId = logisticsRequestId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getAllReturnOrdersForReturnPickupRequest(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getAllReturnOrdersForReturnPickupRequest_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrdersForReturnPickupRequest failed: unknown result");
+  def receiveReturnPickup(self, returnOrdersMap, id):
+    """
+    Parameters:
+     - returnOrdersMap
+     - id
+    """
+    self.send_receiveReturnPickup(returnOrdersMap, id)
+    return self.recv_receiveReturnPickup()
+  def send_receiveReturnPickup(self, returnOrdersMap, id):
+    self._oprot.writeMessageBegin('receiveReturnPickup', TMessageType.CALL, self._seqid)
+    args = receiveReturnPickup_args()
+    args.returnOrdersMap = returnOrdersMap
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_receiveReturnPickup(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = receiveReturnPickup_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturnPickup failed: unknown result");
+  def validateReturnPickup(self, returnPickupId, returnOrdersMap):
+    """
+    Parameters:
+     - returnPickupId
+     - returnOrdersMap
+    """
+    self.send_validateReturnPickup(returnPickupId, returnOrdersMap)
+    return self.recv_validateReturnPickup()
+  def send_validateReturnPickup(self, returnPickupId, returnOrdersMap):
+    self._oprot.writeMessageBegin('validateReturnPickup', TMessageType.CALL, self._seqid)
+    args = validateReturnPickup_args()
+    args.returnPickupId = returnPickupId
+    args.returnOrdersMap = returnOrdersMap
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_validateReturnPickup(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = validateReturnPickup_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnPickup failed: unknown result");
+  def processReturnPickup(self, returnPickupId, returnOrdersMap):
+    """
+    Parameters:
+     - returnPickupId
+     - returnOrdersMap
+    """
+    self.send_processReturnPickup(returnPickupId, returnOrdersMap)
+    return self.recv_processReturnPickup()
+  def send_processReturnPickup(self, returnPickupId, returnOrdersMap):
+    self._oprot.writeMessageBegin('processReturnPickup', TMessageType.CALL, self._seqid)
+    args = processReturnPickup_args()
+    args.returnPickupId = returnPickupId
+    args.returnOrdersMap = returnOrdersMap
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_processReturnPickup(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = processReturnPickup_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "processReturnPickup failed: unknown result");
+  def markReturnTransactionComplete(self, returnTransactionId):
+    """
+    Parameters:
+     - returnTransactionId
+    """
+    self.send_markReturnTransactionComplete(returnTransactionId)
+    return self.recv_markReturnTransactionComplete()
+  def send_markReturnTransactionComplete(self, returnTransactionId):
+    self._oprot.writeMessageBegin('markReturnTransactionComplete', TMessageType.CALL, self._seqid)
+    args = markReturnTransactionComplete_args()
+    args.returnTransactionId = returnTransactionId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_markReturnTransactionComplete(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = markReturnTransactionComplete_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "markReturnTransactionComplete failed: unknown result");
+  def refundReturnTransactionPayment(self, refundOrdersMap, returntransactionId):
+    """
+    Parameters:
+     - refundOrdersMap
+     - returntransactionId
+    """
+    self.send_refundReturnTransactionPayment(refundOrdersMap, returntransactionId)
+    return self.recv_refundReturnTransactionPayment()
+  def send_refundReturnTransactionPayment(self, refundOrdersMap, returntransactionId):
+    self._oprot.writeMessageBegin('refundReturnTransactionPayment', TMessageType.CALL, self._seqid)
+    args = refundReturnTransactionPayment_args()
+    args.refundOrdersMap = refundOrdersMap
+    args.returntransactionId = returntransactionId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_refundReturnTransactionPayment(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = refundReturnTransactionPayment_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundReturnTransactionPayment failed: unknown result");
+  def getReturnTransactionsForCustomer(self, statusList, customerMobile, customerEmail, returnTransactionId, customerId):
+    """
+    Parameters:
+     - statusList
+     - customerMobile
+     - customerEmail
+     - returnTransactionId
+     - customerId
+    """
+    self.send_getReturnTransactionsForCustomer(statusList, customerMobile, customerEmail, returnTransactionId, customerId)
+    return self.recv_getReturnTransactionsForCustomer()
+  def send_getReturnTransactionsForCustomer(self, statusList, customerMobile, customerEmail, returnTransactionId, customerId):
+    self._oprot.writeMessageBegin('getReturnTransactionsForCustomer', TMessageType.CALL, self._seqid)
+    args = getReturnTransactionsForCustomer_args()
+    args.statusList = statusList
+    args.customerMobile = customerMobile
+    args.customerEmail = customerEmail
+    args.returnTransactionId = returnTransactionId
+    args.customerId = customerId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getReturnTransactionsForCustomer(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getReturnTransactionsForCustomer_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnTransactionsForCustomer failed: unknown result");
+  def verifyOrderForTransaction(self, transactionId):
+    """
+    Parameters:
+     - transactionId
+    """
+    self.send_verifyOrderForTransaction(transactionId)
+    return self.recv_verifyOrderForTransaction()
+  def send_verifyOrderForTransaction(self, transactionId):
+    self._oprot.writeMessageBegin('verifyOrderForTransaction', TMessageType.CALL, self._seqid)
+    args = verifyOrderForTransaction_args()
+    args.transactionId = transactionId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_verifyOrderForTransaction(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = verifyOrderForTransaction_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ex is not None:
+      raise result.ex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrderForTransaction failed: unknown result");
 class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
   def __init__(self, handler):
     shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
     self._processMap["createTransaction"] = Processor.process_createTransaction
     self._processMap["createHomeShopOrder"] = Processor.process_createHomeShopOrder
     self._processMap["getHomeShopOrder"] = Processor.process_getHomeShopOrder
     self._processMap["homeShopOrderExists"] = Processor.process_homeShopOrderExists
     self._processMap["splitBulkOrder"] = Processor.process_splitBulkOrder
     self._processMap["moveOrdersToCorrectWarehouse"] = Processor.process_moveOrdersToCorrectWarehouse
+    self._processMap["getCreditorInfo"] = Processor.process_getCreditorInfo
+    self._processMap["updateCreditorInfo"] = Processor.process_updateCreditorInfo
+    self._processMap["getUserSanctionDetails"] = Processor.process_getUserSanctionDetails
+    self._processMap["getUserSanctionDetailsForCreditor"] = Processor.process_getUserSanctionDetailsForCreditor
+    self._processMap["updateUserSanction"] = Processor.process_updateUserSanction
+    self._processMap["getCreditHistoryRecordsForTransaction"] = Processor.process_getCreditHistoryRecordsForTransaction
+    self._processMap["getCreditHistoryRecordsForUserAndCreditor"] = Processor.process_getCreditHistoryRecordsForUserAndCreditor
+    self._processMap["processCreditTransaction"] = Processor.process_processCreditTransaction
+    self._processMap["getLoanPayableForUserToCreditor"] = Processor.process_getLoanPayableForUserToCreditor
+    self._processMap["getReturnOrderInfo"] = Processor.process_getReturnOrderInfo
+    self._processMap["getReturnOrderInfoList"] = Processor.process_getReturnOrderInfoList
+    self._processMap["getReturnOrderInfoListAsByStatus"] = Processor.process_getReturnOrderInfoListAsByStatus
+    self._processMap["updateReturnOrderInfo"] = Processor.process_updateReturnOrderInfo
+    self._processMap["bulkUpdateReturnOrderInfo"] = Processor.process_bulkUpdateReturnOrderInfo
+    self._processMap["getReturnOrdersAsPerWarehouseId"] = Processor.process_getReturnOrdersAsPerWarehouseId
+    self._processMap["createReturnTransaction"] = Processor.process_createReturnTransaction
+    self._processMap["getReturnTransaction"] = Processor.process_getReturnTransaction
+    self._processMap["getReturnOrdersForReturnTransaction"] = Processor.process_getReturnOrdersForReturnTransaction
+    self._processMap["changeReturnTransactionStatus"] = Processor.process_changeReturnTransactionStatus
+    self._processMap["createReturnPickupRequest"] = Processor.process_createReturnPickupRequest
+    self._processMap["updateReturnPickupRequest"] = Processor.process_updateReturnPickupRequest
+    self._processMap["getAllReturnOrdersForReturnPickupRequest"] = Processor.process_getAllReturnOrdersForReturnPickupRequest
+    self._processMap["receiveReturnPickup"] = Processor.process_receiveReturnPickup
+    self._processMap["validateReturnPickup"] = Processor.process_validateReturnPickup
+    self._processMap["processReturnPickup"] = Processor.process_processReturnPickup
+    self._processMap["markReturnTransactionComplete"] = Processor.process_markReturnTransactionComplete
+    self._processMap["refundReturnTransactionPayment"] = Processor.process_refundReturnTransactionPayment
+    self._processMap["getReturnTransactionsForCustomer"] = Processor.process_getReturnTransactionsForCustomer
+    self._processMap["verifyOrderForTransaction"] = Processor.process_verifyOrderForTransaction
   def process(self, iprot, oprot):
     (name, type, seqid) = iprot.readMessageBegin()
     if name not in self._processMap:
       iprot.skip(TType.STRUCT)
     oprot.writeMessageBegin("moveOrdersToCorrectWarehouse", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_getCreditorInfo(self, seqid, iprot, oprot):
+    args = getCreditorInfo_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getCreditorInfo_result()
+    result.success = self._handler.getCreditorInfo(args.id, args.name)
+    oprot.writeMessageBegin("getCreditorInfo", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateCreditorInfo(self, seqid, iprot, oprot):
+    args = updateCreditorInfo_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateCreditorInfo_result()
+    result.success = self._handler.updateCreditorInfo(args.creditor)
+    oprot.writeMessageBegin("updateCreditorInfo", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getUserSanctionDetails(self, seqid, iprot, oprot):
+    args = getUserSanctionDetails_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getUserSanctionDetails_result()
+    result.success = self._handler.getUserSanctionDetails(args.userId)
+    oprot.writeMessageBegin("getUserSanctionDetails", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getUserSanctionDetailsForCreditor(self, seqid, iprot, oprot):
+    args = getUserSanctionDetailsForCreditor_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getUserSanctionDetailsForCreditor_result()
+    result.success = self._handler.getUserSanctionDetailsForCreditor(args.userId, args.creditorId)
+    oprot.writeMessageBegin("getUserSanctionDetailsForCreditor", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateUserSanction(self, seqid, iprot, oprot):
+    args = updateUserSanction_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateUserSanction_result()
+    try:
+      result.success = self._handler.updateUserSanction(args.userSanaction)
+    except TransactionServiceException, pe:
+      result.pe = pe
+    oprot.writeMessageBegin("updateUserSanction", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getCreditHistoryRecordsForTransaction(self, seqid, iprot, oprot):
+    args = getCreditHistoryRecordsForTransaction_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getCreditHistoryRecordsForTransaction_result()
+    result.success = self._handler.getCreditHistoryRecordsForTransaction(args.paymentId, args.creditorId, args.creditTxnType)
+    oprot.writeMessageBegin("getCreditHistoryRecordsForTransaction", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getCreditHistoryRecordsForUserAndCreditor(self, seqid, iprot, oprot):
+    args = getCreditHistoryRecordsForUserAndCreditor_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getCreditHistoryRecordsForUserAndCreditor_result()
+    result.success = self._handler.getCreditHistoryRecordsForUserAndCreditor(args.userId, args.creditTxnType)
+    oprot.writeMessageBegin("getCreditHistoryRecordsForUserAndCreditor", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_processCreditTransaction(self, seqid, iprot, oprot):
+    args = processCreditTransaction_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = processCreditTransaction_result()
+    try:
+      result.success = self._handler.processCreditTransaction(args.paymentId, args.creditTxns)
+    except TransactionServiceException, pe:
+      result.pe = pe
+    oprot.writeMessageBegin("processCreditTransaction", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getLoanPayableForUserToCreditor(self, seqid, iprot, oprot):
+    args = getLoanPayableForUserToCreditor_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getLoanPayableForUserToCreditor_result()
+    result.success = self._handler.getLoanPayableForUserToCreditor(args.userId, args.creditorId, args.dueDate)
+    oprot.writeMessageBegin("getLoanPayableForUserToCreditor", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getReturnOrderInfo(self, seqid, iprot, oprot):
+    args = getReturnOrderInfo_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getReturnOrderInfo_result()
+    try:
+      result.success = self._handler.getReturnOrderInfo(args.id)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("getReturnOrderInfo", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getReturnOrderInfoList(self, seqid, iprot, oprot):
+    args = getReturnOrderInfoList_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getReturnOrderInfoList_result()
+    result.success = self._handler.getReturnOrderInfoList(args.order_ids)
+    oprot.writeMessageBegin("getReturnOrderInfoList", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getReturnOrderInfoListAsByStatus(self, seqid, iprot, oprot):
+    args = getReturnOrderInfoListAsByStatus_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getReturnOrderInfoListAsByStatus_result()
+    result.success = self._handler.getReturnOrderInfoListAsByStatus(args.order_ids, args.statuses)
+    oprot.writeMessageBegin("getReturnOrderInfoListAsByStatus", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateReturnOrderInfo(self, seqid, iprot, oprot):
+    args = updateReturnOrderInfo_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateReturnOrderInfo_result()
+    try:
+      result.success = self._handler.updateReturnOrderInfo(args.returnInfo)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("updateReturnOrderInfo", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_bulkUpdateReturnOrderInfo(self, seqid, iprot, oprot):
+    args = bulkUpdateReturnOrderInfo_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = bulkUpdateReturnOrderInfo_result()
+    try:
+      result.success = self._handler.bulkUpdateReturnOrderInfo(args.orderReturnInfosMap)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("bulkUpdateReturnOrderInfo", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getReturnOrdersAsPerWarehouseId(self, seqid, iprot, oprot):
+    args = getReturnOrdersAsPerWarehouseId_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getReturnOrdersAsPerWarehouseId_result()
+    result.success = self._handler.getReturnOrdersAsPerWarehouseId(args.warehouseId)
+    oprot.writeMessageBegin("getReturnOrdersAsPerWarehouseId", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_createReturnTransaction(self, seqid, iprot, oprot):
+    args = createReturnTransaction_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = createReturnTransaction_result()
+    try:
+      result.success = self._handler.createReturnTransaction(args.returnTransaction)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("createReturnTransaction", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getReturnTransaction(self, seqid, iprot, oprot):
+    args = getReturnTransaction_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getReturnTransaction_result()
+    try:
+      result.success = self._handler.getReturnTransaction(args.id)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("getReturnTransaction", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getReturnOrdersForReturnTransaction(self, seqid, iprot, oprot):
+    args = getReturnOrdersForReturnTransaction_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getReturnOrdersForReturnTransaction_result()
+    try:
+      result.success = self._handler.getReturnOrdersForReturnTransaction(args.returnTransactionId)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("getReturnOrdersForReturnTransaction", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_changeReturnTransactionStatus(self, seqid, iprot, oprot):
+    args = changeReturnTransactionStatus_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = changeReturnTransactionStatus_result()
+    try:
+      result.success = self._handler.changeReturnTransactionStatus(args.returnTransactionId, args.status, args.returnOrderIds)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("changeReturnTransactionStatus", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_createReturnPickupRequest(self, seqid, iprot, oprot):
+    args = createReturnPickupRequest_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = createReturnPickupRequest_result()
+    try:
+      result.success = self._handler.createReturnPickupRequest(args.returnOrderIds, args.providerId)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("createReturnPickupRequest", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateReturnPickupRequest(self, seqid, iprot, oprot):
+    args = updateReturnPickupRequest_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateReturnPickupRequest_result()
+    try:
+      result.success = self._handler.updateReturnPickupRequest(args.returnPickupRequest)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("updateReturnPickupRequest", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getAllReturnOrdersForReturnPickupRequest(self, seqid, iprot, oprot):
+    args = getAllReturnOrdersForReturnPickupRequest_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getAllReturnOrdersForReturnPickupRequest_result()
+    try:
+      result.success = self._handler.getAllReturnOrdersForReturnPickupRequest(args.logisticsRequestId)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("getAllReturnOrdersForReturnPickupRequest", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_receiveReturnPickup(self, seqid, iprot, oprot):
+    args = receiveReturnPickup_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = receiveReturnPickup_result()
+    try:
+      result.success = self._handler.receiveReturnPickup(args.returnOrdersMap, args.id)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("receiveReturnPickup", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_validateReturnPickup(self, seqid, iprot, oprot):
+    args = validateReturnPickup_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = validateReturnPickup_result()
+    try:
+      result.success = self._handler.validateReturnPickup(args.returnPickupId, args.returnOrdersMap)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("validateReturnPickup", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_processReturnPickup(self, seqid, iprot, oprot):
+    args = processReturnPickup_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = processReturnPickup_result()
+    try:
+      result.success = self._handler.processReturnPickup(args.returnPickupId, args.returnOrdersMap)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("processReturnPickup", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_markReturnTransactionComplete(self, seqid, iprot, oprot):
+    args = markReturnTransactionComplete_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = markReturnTransactionComplete_result()
+    try:
+      result.success = self._handler.markReturnTransactionComplete(args.returnTransactionId)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("markReturnTransactionComplete", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_refundReturnTransactionPayment(self, seqid, iprot, oprot):
+    args = refundReturnTransactionPayment_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = refundReturnTransactionPayment_result()
+    try:
+      result.success = self._handler.refundReturnTransactionPayment(args.refundOrdersMap, args.returntransactionId)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("refundReturnTransactionPayment", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getReturnTransactionsForCustomer(self, seqid, iprot, oprot):
+    args = getReturnTransactionsForCustomer_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getReturnTransactionsForCustomer_result()
+    try:
+      result.success = self._handler.getReturnTransactionsForCustomer(args.statusList, args.customerMobile, args.customerEmail, args.returnTransactionId, args.customerId)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("getReturnTransactionsForCustomer", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_verifyOrderForTransaction(self, seqid, iprot, oprot):
+    args = verifyOrderForTransaction_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = verifyOrderForTransaction_result()
+    try:
+      result.success = self._handler.verifyOrderForTransaction(args.transactionId)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("verifyOrderForTransaction", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
 # HELPER FUNCTIONS AND STRUCTURES
 class createTransaction_args:
   """
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype109, _size106) = iprot.readListBegin()
+          (_etype116, _size113) = iprot.readListBegin()
-          for _i110 in xrange(_size106):
+          for _i117 in xrange(_size113):
-            _elem111 = Transaction()
+            _elem118 = Transaction()
-            _elem111.read(iprot)
+            _elem118.read(iprot)
-            self.success.append(_elem111)
+            self.success.append(_elem118)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getTransactionsForCustomer_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter112 in self.success:
+      for iter119 in self.success:
-        iter112.write(oprot)
+        iter119.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype116, _size113) = iprot.readListBegin()
+          (_etype123, _size120) = iprot.readListBegin()
-          for _i117 in xrange(_size113):
+          for _i124 in xrange(_size120):
-            _elem118 = Transaction()
+            _elem125 = Transaction()
-            _elem118.read(iprot)
+            _elem125.read(iprot)
-            self.success.append(_elem118)
+            self.success.append(_elem125)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter119 in self.success:
+      for iter126 in self.success:
-        iter119.write(oprot)
+        iter126.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.statuses = []
-          (_etype123, _size120) = iprot.readListBegin()
+          (_etype130, _size127) = iprot.readListBegin()
-          for _i124 in xrange(_size120):
+          for _i131 in xrange(_size127):
-            _elem125 = iprot.readI32();
+            _elem132 = iprot.readI32();
-            self.statuses.append(_elem125)
+            self.statuses.append(_elem132)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('getAllOrders_args')
     if self.statuses is not None:
       oprot.writeFieldBegin('statuses', TType.LIST, 1)
       oprot.writeListBegin(TType.I32, len(self.statuses))
-      for iter126 in self.statuses:
+      for iter133 in self.statuses:
-        oprot.writeI32(iter126)
+        oprot.writeI32(iter133)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.from_date is not None:
       oprot.writeFieldBegin('from_date', TType.I64, 2)
       oprot.writeI64(self.from_date)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype130, _size127) = iprot.readListBegin()
+          (_etype137, _size134) = iprot.readListBegin()
-          for _i131 in xrange(_size127):
+          for _i138 in xrange(_size134):
-            _elem132 = Order()
+            _elem139 = Order()
-            _elem132.read(iprot)
+            _elem139.read(iprot)
-            self.success.append(_elem132)
+            self.success.append(_elem139)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getAllOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter133 in self.success:
+      for iter140 in self.success:
-        iter133.write(oprot)
+        iter140.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.statuses = []
-          (_etype137, _size134) = iprot.readListBegin()
+          (_etype144, _size141) = iprot.readListBegin()
-          for _i138 in xrange(_size134):
+          for _i145 in xrange(_size141):
-            _elem139 = iprot.readI32();
+            _elem146 = iprot.readI32();
-            self.statuses.append(_elem139)
+            self.statuses.append(_elem146)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('getOrdersInBatch_args')
     if self.statuses is not None:
       oprot.writeFieldBegin('statuses', TType.LIST, 1)
       oprot.writeListBegin(TType.I32, len(self.statuses))
-      for iter140 in self.statuses:
+      for iter147 in self.statuses:
-        oprot.writeI32(iter140)
+        oprot.writeI32(iter147)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.offset is not None:
       oprot.writeFieldBegin('offset', TType.I64, 2)
       oprot.writeI64(self.offset)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype144, _size141) = iprot.readListBegin()
+          (_etype151, _size148) = iprot.readListBegin()
-          for _i145 in xrange(_size141):
+          for _i152 in xrange(_size148):
-            _elem146 = Order()
+            _elem153 = Order()
-            _elem146.read(iprot)
+            _elem153.read(iprot)
-            self.success.append(_elem146)
+            self.success.append(_elem153)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrdersInBatch_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter147 in self.success:
+      for iter154 in self.success:
-        iter147.write(oprot)
+        iter154.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.statuses = []
-          (_etype151, _size148) = iprot.readListBegin()
+          (_etype158, _size155) = iprot.readListBegin()
-          for _i152 in xrange(_size148):
+          for _i159 in xrange(_size155):
-            _elem153 = iprot.readI32();
+            _elem160 = iprot.readI32();
-            self.statuses.append(_elem153)
+            self.statuses.append(_elem160)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('getOrderCount_args')
     if self.statuses is not None:
       oprot.writeFieldBegin('statuses', TType.LIST, 1)
       oprot.writeListBegin(TType.I32, len(self.statuses))
-      for iter154 in self.statuses:
+      for iter161 in self.statuses:
-        oprot.writeI32(iter154)
+        oprot.writeI32(iter161)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.warehouseId is not None:
       oprot.writeFieldBegin('warehouseId', TType.I64, 2)
       oprot.writeI64(self.warehouseId)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype158, _size155) = iprot.readListBegin()
+          (_etype165, _size162) = iprot.readListBegin()
-          for _i159 in xrange(_size155):
+          for _i166 in xrange(_size162):
-            _elem160 = Order()
+            _elem167 = Order()
-            _elem160.read(iprot)
+            _elem167.read(iprot)
-            self.success.append(_elem160)
+            self.success.append(_elem167)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrdersByBillingDate_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter161 in self.success:
+      for iter168 in self.success:
-        iter161.write(oprot)
+        iter168.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype165, _size162) = iprot.readListBegin()
+          (_etype172, _size169) = iprot.readListBegin()
-          for _i166 in xrange(_size162):
+          for _i173 in xrange(_size169):
-            _elem167 = Order()
+            _elem174 = Order()
-            _elem167.read(iprot)
+            _elem174.read(iprot)
-            self.success.append(_elem167)
+            self.success.append(_elem174)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrdersByShippingDate_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter168 in self.success:
+      for iter175 in self.success:
-        iter168.write(oprot)
+        iter175.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype172, _size169) = iprot.readListBegin()
+          (_etype179, _size176) = iprot.readListBegin()
-          for _i173 in xrange(_size169):
+          for _i180 in xrange(_size176):
-            _elem174 = iprot.readI64();
+            _elem181 = iprot.readI64();
-            self.success.append(_elem174)
+            self.success.append(_elem181)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.I64, len(self.success))
-      for iter175 in self.success:
+      for iter182 in self.success:
-        oprot.writeI64(iter175)
+        oprot.writeI64(iter182)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype179, _size176) = iprot.readListBegin()
+          (_etype186, _size183) = iprot.readListBegin()
-          for _i180 in xrange(_size176):
+          for _i187 in xrange(_size183):
-            _elem181 = iprot.readI64();
+            _elem188 = iprot.readI64();
-            self.success.append(_elem181)
+            self.success.append(_elem188)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.I64, len(self.success))
-      for iter182 in self.success:
+      for iter189 in self.success:
-        oprot.writeI64(iter182)
+        oprot.writeI64(iter189)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype186, _size183) = iprot.readListBegin()
+          (_etype193, _size190) = iprot.readListBegin()
-          for _i187 in xrange(_size183):
+          for _i194 in xrange(_size190):
-            _elem188 = Order()
+            _elem195 = Order()
-            _elem188.read(iprot)
+            _elem195.read(iprot)
-            self.success.append(_elem188)
+            self.success.append(_elem195)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrdersForTransaction_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter189 in self.success:
+      for iter196 in self.success:
-        iter189.write(oprot)
+        iter196.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
         else:
           iprot.skip(ftype)
       elif fid == 4:
         if ftype == TType.LIST:
           self.statuses = []
-          (_etype193, _size190) = iprot.readListBegin()
+          (_etype200, _size197) = iprot.readListBegin()
-          for _i194 in xrange(_size190):
+          for _i201 in xrange(_size197):
-            _elem195 = iprot.readI32();
+            _elem202 = iprot.readI32();
-            self.statuses.append(_elem195)
+            self.statuses.append(_elem202)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.to_date)
       oprot.writeFieldEnd()
     if self.statuses is not None:
       oprot.writeFieldBegin('statuses', TType.LIST, 4)
       oprot.writeListBegin(TType.I32, len(self.statuses))
-      for iter196 in self.statuses:
+      for iter203 in self.statuses:
-        oprot.writeI32(iter196)
+        oprot.writeI32(iter203)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype200, _size197) = iprot.readListBegin()
+          (_etype207, _size204) = iprot.readListBegin()
-          for _i201 in xrange(_size197):
+          for _i208 in xrange(_size204):
-            _elem202 = Order()
+            _elem209 = Order()
-            _elem202.read(iprot)
+            _elem209.read(iprot)
-            self.success.append(_elem202)
+            self.success.append(_elem209)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrdersForCustomer_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter203 in self.success:
+      for iter210 in self.success:
-        iter203.write(oprot)
+        iter210.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype207, _size204) = iprot.readListBegin()
+          (_etype214, _size211) = iprot.readListBegin()
-          for _i208 in xrange(_size204):
+          for _i215 in xrange(_size211):
-            _elem209 = LineItem()
+            _elem216 = LineItem()
-            _elem209.read(iprot)
+            _elem216.read(iprot)
-            self.success.append(_elem209)
+            self.success.append(_elem216)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getLineItemsForOrder_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter210 in self.success:
+      for iter217 in self.success:
-        iter210.write(oprot)
+        iter217.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.order_ids = []
-          (_etype214, _size211) = iprot.readListBegin()
+          (_etype221, _size218) = iprot.readListBegin()
-          for _i215 in xrange(_size211):
+          for _i222 in xrange(_size218):
-            _elem216 = iprot.readI64();
+            _elem223 = iprot.readI64();
-            self.order_ids.append(_elem216)
+            self.order_ids.append(_elem223)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrderList_args')
     if self.order_ids is not None:
       oprot.writeFieldBegin('order_ids', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.order_ids))
-      for iter217 in self.order_ids:
+      for iter224 in self.order_ids:
-        oprot.writeI64(iter217)
+        oprot.writeI64(iter224)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype221, _size218) = iprot.readListBegin()
+          (_etype228, _size225) = iprot.readListBegin()
-          for _i222 in xrange(_size218):
+          for _i229 in xrange(_size225):
-            _elem223 = Order()
+            _elem230 = Order()
-            _elem223.read(iprot)
+            _elem230.read(iprot)
-            self.success.append(_elem223)
+            self.success.append(_elem230)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrderList_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter224 in self.success:
+      for iter231 in self.success:
-        iter224.write(oprot)
+        iter231.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.order_ids = []
-          (_etype228, _size225) = iprot.readListBegin()
+          (_etype235, _size232) = iprot.readListBegin()
-          for _i229 in xrange(_size225):
+          for _i236 in xrange(_size232):
-            _elem230 = iprot.readI64();
+            _elem237 = iprot.readI64();
-            self.order_ids.append(_elem230)
+            self.order_ids.append(_elem237)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('getOrderListForVendor_args')
     if self.order_ids is not None:
       oprot.writeFieldBegin('order_ids', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.order_ids))
-      for iter231 in self.order_ids:
+      for iter238 in self.order_ids:
-        oprot.writeI64(iter231)
+        oprot.writeI64(iter238)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.vendorId is not None:
       oprot.writeFieldBegin('vendorId', TType.I64, 2)
       oprot.writeI64(self.vendorId)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype235, _size232) = iprot.readListBegin()
+          (_etype242, _size239) = iprot.readListBegin()
-          for _i236 in xrange(_size232):
+          for _i243 in xrange(_size239):
-            _elem237 = Order()
+            _elem244 = Order()
-            _elem237.read(iprot)
+            _elem244.read(iprot)
-            self.success.append(_elem237)
+            self.success.append(_elem244)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrderListForVendor_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter238 in self.success:
+      for iter245 in self.success:
-        iter238.write(oprot)
+        iter245.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype242, _size239) = iprot.readListBegin()
+          (_etype249, _size246) = iprot.readListBegin()
-          for _i243 in xrange(_size239):
+          for _i250 in xrange(_size246):
-            _elem244 = Alert()
+            _elem251 = Alert()
-            _elem244.read(iprot)
+            _elem251.read(iprot)
-            self.success.append(_elem244)
+            self.success.append(_elem251)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAlerts_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter245 in self.success:
+      for iter252 in self.success:
-        iter245.write(oprot)
+        iter252.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype249, _size246) = iprot.readListBegin()
+          (_etype256, _size253) = iprot.readListBegin()
-          for _i250 in xrange(_size246):
+          for _i257 in xrange(_size253):
-            _elem251 = iprot.readDouble();
+            _elem258 = iprot.readDouble();
-            self.success.append(_elem251)
+            self.success.append(_elem258)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getValidOrdersAmountRange_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.DOUBLE, len(self.success))
-      for iter252 in self.success:
+      for iter259 in self.success:
-        oprot.writeDouble(iter252)
+        oprot.writeDouble(iter259)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype256, _size253) = iprot.readListBegin()
+          (_etype263, _size260) = iprot.readListBegin()
-          for _i257 in xrange(_size253):
+          for _i264 in xrange(_size260):
-            _elem258 = Order()
+            _elem265 = Order()
-            _elem258.read(iprot)
+            _elem265.read(iprot)
-            self.success.append(_elem258)
+            self.success.append(_elem265)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getValidOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter259 in self.success:
+      for iter266 in self.success:
-        iter259.write(oprot)
+        iter266.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype263, _size260) = iprot.readListBegin()
+          (_etype270, _size267) = iprot.readListBegin()
-          for _i264 in xrange(_size260):
+          for _i271 in xrange(_size267):
-            _elem265 = Order()
+            _elem272 = Order()
-            _elem265.read(iprot)
+            _elem272.read(iprot)
-            self.success.append(_elem265)
+            self.success.append(_elem272)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('batchOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter266 in self.success:
+      for iter273 in self.success:
-        iter266.write(oprot)
+        iter273.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
         else:
           iprot.skip(ftype)
       elif fid == 3:
         if ftype == TType.LIST:
           self.serialNumber = []
-          (_etype270, _size267) = iprot.readListBegin()
+          (_etype277, _size274) = iprot.readListBegin()
-          for _i271 in xrange(_size267):
+          for _i278 in xrange(_size274):
-            _elem272 = iprot.readString();
+            _elem279 = iprot.readString();
-            self.serialNumber.append(_elem272)
+            self.serialNumber.append(_elem279)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 4:
         if ftype == TType.LIST:
           self.itemNumber = []
-          (_etype276, _size273) = iprot.readListBegin()
+          (_etype283, _size280) = iprot.readListBegin()
-          for _i277 in xrange(_size273):
+          for _i284 in xrange(_size280):
-            _elem278 = iprot.readString();
+            _elem285 = iprot.readString();
-            self.itemNumber.append(_elem278)
+            self.itemNumber.append(_elem285)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 5:
         if ftype == TType.I64:
       oprot.writeString(self.invoice_number)
       oprot.writeFieldEnd()
     if self.serialNumber is not None:
       oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
       oprot.writeListBegin(TType.STRING, len(self.serialNumber))
-      for iter279 in self.serialNumber:
+      for iter286 in self.serialNumber:
-        oprot.writeString(iter279)
+        oprot.writeString(iter286)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.itemNumber is not None:
       oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
       oprot.writeListBegin(TType.STRING, len(self.itemNumber))
-      for iter280 in self.itemNumber:
+      for iter287 in self.itemNumber:
-        oprot.writeString(iter280)
+        oprot.writeString(iter287)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.freebieWarehouseId is not None:
       oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 5)
       oprot.writeI64(self.freebieWarehouseId)
         else:
           iprot.skip(ftype)
       elif fid == 4:
         if ftype == TType.LIST:
           self.orderIds = []
-          (_etype284, _size281) = iprot.readListBegin()
+          (_etype291, _size288) = iprot.readListBegin()
-          for _i285 in xrange(_size281):
+          for _i292 in xrange(_size288):
-            _elem286 = iprot.readI64();
+            _elem293 = iprot.readI64();
-            self.orderIds.append(_elem286)
+            self.orderIds.append(_elem293)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeBool(self.cod)
       oprot.writeFieldEnd()
     if self.orderIds is not None:
       oprot.writeFieldBegin('orderIds', TType.LIST, 4)
       oprot.writeListBegin(TType.I64, len(self.orderIds))
-      for iter287 in self.orderIds:
+      for iter294 in self.orderIds:
-        oprot.writeI64(iter287)
+        oprot.writeI64(iter294)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.LIST:
           self.orderIds = []
-          (_etype291, _size288) = iprot.readListBegin()
+          (_etype298, _size295) = iprot.readListBegin()
-          for _i292 in xrange(_size288):
+          for _i299 in xrange(_size295):
-            _elem293 = iprot.readI64();
+            _elem300 = iprot.readI64();
-            self.orderIds.append(_elem293)
+            self.orderIds.append(_elem300)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 3:
         if ftype == TType.LIST:
           self.awbs = []
-          (_etype297, _size294) = iprot.readListBegin()
+          (_etype304, _size301) = iprot.readListBegin()
-          for _i298 in xrange(_size294):
+          for _i305 in xrange(_size301):
-            _elem299 = iprot.readString();
+            _elem306 = iprot.readString();
-            self.awbs.append(_elem299)
+            self.awbs.append(_elem306)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.orderIds is not None:
       oprot.writeFieldBegin('orderIds', TType.LIST, 2)
       oprot.writeListBegin(TType.I64, len(self.orderIds))
-      for iter300 in self.orderIds:
+      for iter307 in self.orderIds:
-        oprot.writeI64(iter300)
+        oprot.writeI64(iter307)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.awbs is not None:
       oprot.writeFieldBegin('awbs', TType.LIST, 3)
       oprot.writeListBegin(TType.STRING, len(self.awbs))
-      for iter301 in self.awbs:
+      for iter308 in self.awbs:
-        oprot.writeString(iter301)
+        oprot.writeString(iter308)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.pickupDetails = {}
-          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
+          (_ktype310, _vtype311, _size309 ) = iprot.readMapBegin()
-          for _i306 in xrange(_size302):
+          for _i313 in xrange(_size309):
-            _key307 = iprot.readString();
+            _key314 = iprot.readString();
-            _val308 = iprot.readString();
+            _val315 = iprot.readString();
-            self.pickupDetails[_key307] = _val308
+            self.pickupDetails[_key314] = _val315
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.pickupDetails is not None:
       oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
-      for kiter309,viter310 in self.pickupDetails.items():
+      for kiter316,viter317 in self.pickupDetails.items():
-        oprot.writeString(kiter309)
+        oprot.writeString(kiter316)
-        oprot.writeString(viter310)
+        oprot.writeString(viter317)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype314, _size311) = iprot.readListBegin()
+          (_etype321, _size318) = iprot.readListBegin()
-          for _i315 in xrange(_size311):
+          for _i322 in xrange(_size318):
-            _elem316 = Order()
+            _elem323 = Order()
-            _elem316.read(iprot)
+            _elem323.read(iprot)
-            self.success.append(_elem316)
+            self.success.append(_elem323)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersNotPickedUp_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter317 in self.success:
+      for iter324 in self.success:
-        iter317.write(oprot)
+        iter324.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.deliveredOrders = {}
-          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
+          (_ktype326, _vtype327, _size325 ) = iprot.readMapBegin()
-          for _i322 in xrange(_size318):
+          for _i329 in xrange(_size325):
-            _key323 = iprot.readString();
+            _key330 = iprot.readString();
-            _val324 = iprot.readString();
+            _val331 = iprot.readString();
-            self.deliveredOrders[_key323] = _val324
+            self.deliveredOrders[_key330] = _val331
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.deliveredOrders is not None:
       oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
-      for kiter325,viter326 in self.deliveredOrders.items():
+      for kiter332,viter333 in self.deliveredOrders.items():
-        oprot.writeString(kiter325)
+        oprot.writeString(kiter332)
-        oprot.writeString(viter326)
+        oprot.writeString(viter333)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.returnedOrders = {}
-          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
+          (_ktype335, _vtype336, _size334 ) = iprot.readMapBegin()
-          for _i331 in xrange(_size327):
+          for _i338 in xrange(_size334):
-            _key332 = iprot.readString();
+            _key339 = iprot.readString();
-            _val333 = iprot.readString();
+            _val340 = iprot.readString();
-            self.returnedOrders[_key332] = _val333
+            self.returnedOrders[_key339] = _val340
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.returnedOrders is not None:
       oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
-      for kiter334,viter335 in self.returnedOrders.items():
+      for kiter341,viter342 in self.returnedOrders.items():
-        oprot.writeString(kiter334)
+        oprot.writeString(kiter341)
-        oprot.writeString(viter335)
+        oprot.writeString(viter342)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype339, _size336) = iprot.readListBegin()
+          (_etype346, _size343) = iprot.readListBegin()
-          for _i340 in xrange(_size336):
+          for _i347 in xrange(_size343):
-            _elem341 = Order()
+            _elem348 = Order()
-            _elem341.read(iprot)
+            _elem348.read(iprot)
-            self.success.append(_elem341)
+            self.success.append(_elem348)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getRTOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter342 in self.success:
+      for iter349 in self.success:
-        iter342.write(oprot)
+        iter349.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.undeliveredOrders = {}
-          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
+          (_ktype351, _vtype352, _size350 ) = iprot.readMapBegin()
-          for _i347 in xrange(_size343):
+          for _i354 in xrange(_size350):
-            _key348 = iprot.readString();
+            _key355 = iprot.readString();
-            _val349 = iprot.readString();
+            _val356 = iprot.readString();
-            self.undeliveredOrders[_key348] = _val349
+            self.undeliveredOrders[_key355] = _val356
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.undeliveredOrders is not None:
       oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
-      for kiter350,viter351 in self.undeliveredOrders.items():
+      for kiter357,viter358 in self.undeliveredOrders.items():
-        oprot.writeString(kiter350)
+        oprot.writeString(kiter357)
-        oprot.writeString(viter351)
+        oprot.writeString(viter358)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype355, _size352) = iprot.readListBegin()
+          (_etype362, _size359) = iprot.readListBegin()
-          for _i356 in xrange(_size352):
+          for _i363 in xrange(_size359):
-            _elem357 = Order()
+            _elem364 = Order()
-            _elem357.read(iprot)
+            _elem364.read(iprot)
-            self.success.append(_elem357)
+            self.success.append(_elem364)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter358 in self.success:
+      for iter365 in self.success:
-        iter358.write(oprot)
+        iter365.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.local_connected_orders = {}
-          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
+          (_ktype367, _vtype368, _size366 ) = iprot.readMapBegin()
-          for _i363 in xrange(_size359):
+          for _i370 in xrange(_size366):
-            _key364 = iprot.readString();
+            _key371 = iprot.readString();
-            _val365 = iprot.readString();
+            _val372 = iprot.readString();
-            self.local_connected_orders[_key364] = _val365
+            self.local_connected_orders[_key371] = _val372
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.local_connected_orders is not None:
       oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
-      for kiter366,viter367 in self.local_connected_orders.items():
+      for kiter373,viter374 in self.local_connected_orders.items():
-        oprot.writeString(kiter366)
+        oprot.writeString(kiter373)
-        oprot.writeString(viter367)
+        oprot.writeString(viter374)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype371, _size368) = iprot.readListBegin()
+          (_etype378, _size375) = iprot.readListBegin()
-          for _i372 in xrange(_size368):
+          for _i379 in xrange(_size375):
-            _elem373 = Order()
+            _elem380 = Order()
-            _elem373.read(iprot)
+            _elem380.read(iprot)
-            self.success.append(_elem373)
+            self.success.append(_elem380)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersNotLocalConnected_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter374 in self.success:
+      for iter381 in self.success:
-        iter374.write(oprot)
+        iter381.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.destination_city_reached_orders = {}
-          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
+          (_ktype383, _vtype384, _size382 ) = iprot.readMapBegin()
-          for _i379 in xrange(_size375):
+          for _i386 in xrange(_size382):
-            _key380 = iprot.readString();
+            _key387 = iprot.readString();
-            _val381 = iprot.readString();
+            _val388 = iprot.readString();
-            self.destination_city_reached_orders[_key380] = _val381
+            self.destination_city_reached_orders[_key387] = _val388
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.destination_city_reached_orders is not None:
       oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
-      for kiter382,viter383 in self.destination_city_reached_orders.items():
+      for kiter389,viter390 in self.destination_city_reached_orders.items():
-        oprot.writeString(kiter382)
+        oprot.writeString(kiter389)
-        oprot.writeString(viter383)
+        oprot.writeString(viter390)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.first_atdl_orders = {}
-          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
+          (_ktype392, _vtype393, _size391 ) = iprot.readMapBegin()
-          for _i388 in xrange(_size384):
+          for _i395 in xrange(_size391):
-            _key389 = iprot.readString();
+            _key396 = iprot.readString();
-            _val390 = iprot.readString();
+            _val397 = iprot.readString();
-            self.first_atdl_orders[_key389] = _val390
+            self.first_atdl_orders[_key396] = _val397
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.first_atdl_orders is not None:
       oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
-      for kiter391,viter392 in self.first_atdl_orders.items():
+      for kiter398,viter399 in self.first_atdl_orders.items():
-        oprot.writeString(kiter391)
+        oprot.writeString(kiter398)
-        oprot.writeString(viter392)
+        oprot.writeString(viter399)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype396, _size393) = iprot.readListBegin()
+          (_etype403, _size400) = iprot.readListBegin()
-          for _i397 in xrange(_size393):
+          for _i404 in xrange(_size400):
-            _elem398 = Order()
+            _elem405 = Order()
-            _elem398.read(iprot)
+            _elem405.read(iprot)
-            self.success.append(_elem398)
+            self.success.append(_elem405)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getUndeliveredOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter399 in self.success:
+      for iter406 in self.success:
-        iter399.write(oprot)
+        iter406.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype403, _size400) = iprot.readListBegin()
+          (_etype410, _size407) = iprot.readListBegin()
-          for _i404 in xrange(_size400):
+          for _i411 in xrange(_size407):
-            _elem405 = Order()
+            _elem412 = Order()
-            _elem405.read(iprot)
+            _elem412.read(iprot)
-            self.success.append(_elem405)
+            self.success.append(_elem412)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter406 in self.success:
+      for iter413 in self.success:
-        iter406.write(oprot)
+        iter413.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.pickupDetails = {}
-          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
+          (_ktype415, _vtype416, _size414 ) = iprot.readMapBegin()
-          for _i411 in xrange(_size407):
+          for _i418 in xrange(_size414):
-            _key412 = iprot.readString();
+            _key419 = iprot.readString();
-            _val413 = iprot.readString();
+            _val420 = iprot.readString();
-            self.pickupDetails[_key412] = _val413
+            self.pickupDetails[_key419] = _val420
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.pickupDetails is not None:
       oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
-      for kiter414,viter415 in self.pickupDetails.items():
+      for kiter421,viter422 in self.pickupDetails.items():
-        oprot.writeString(kiter414)
+        oprot.writeString(kiter421)
-        oprot.writeString(viter415)
+        oprot.writeString(viter422)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype419, _size416) = iprot.readListBegin()
+          (_etype426, _size423) = iprot.readListBegin()
-          for _i420 in xrange(_size416):
+          for _i427 in xrange(_size423):
-            _elem421 = Order()
+            _elem428 = Order()
-            _elem421.read(iprot)
+            _elem428.read(iprot)
-            self.success.append(_elem421)
+            self.success.append(_elem428)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getDoasNotPickedUp_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter422 in self.success:
+      for iter429 in self.success:
-        iter422.write(oprot)
+        iter429.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.pickupDetails = {}
-          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
+          (_ktype431, _vtype432, _size430 ) = iprot.readMapBegin()
-          for _i427 in xrange(_size423):
+          for _i434 in xrange(_size430):
-            _key428 = iprot.readString();
+            _key435 = iprot.readString();
-            _val429 = iprot.readString();
+            _val436 = iprot.readString();
-            self.pickupDetails[_key428] = _val429
+            self.pickupDetails[_key435] = _val436
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.pickupDetails is not None:
       oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
-      for kiter430,viter431 in self.pickupDetails.items():
+      for kiter437,viter438 in self.pickupDetails.items():
-        oprot.writeString(kiter430)
+        oprot.writeString(kiter437)
-        oprot.writeString(viter431)
+        oprot.writeString(viter438)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype435, _size432) = iprot.readListBegin()
+          (_etype442, _size439) = iprot.readListBegin()
-          for _i436 in xrange(_size432):
+          for _i443 in xrange(_size439):
-            _elem437 = Order()
+            _elem444 = Order()
-            _elem437.read(iprot)
+            _elem444.read(iprot)
-            self.success.append(_elem437)
+            self.success.append(_elem444)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter438 in self.success:
+      for iter445 in self.success:
-        iter438.write(oprot)
+        iter445.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype442, _size439) = iprot.readListBegin()
+          (_etype449, _size446) = iprot.readListBegin()
-          for _i443 in xrange(_size439):
+          for _i450 in xrange(_size446):
-            _elem444 = ReturnOrder()
+            _elem451 = ReturnOrder()
-            _elem444.read(iprot)
+            _elem451.read(iprot)
-            self.success.append(_elem444)
+            self.success.append(_elem451)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReturnOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter445 in self.success:
+      for iter452 in self.success:
-        iter445.write(oprot)
+        iter452.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype449, _size446) = iprot.readListBegin()
+          (_etype456, _size453) = iprot.readListBegin()
-          for _i450 in xrange(_size446):
+          for _i457 in xrange(_size453):
-            _elem451 = ReturnOrder()
+            _elem458 = ReturnOrder()
-            _elem451.read(iprot)
+            _elem458.read(iprot)
-            self.success.append(_elem451)
+            self.success.append(_elem458)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllReturnOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter452 in self.success:
+      for iter459 in self.success:
-        iter452.write(oprot)
+        iter459.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.MAP:
           self.collectedAmountMap = {}
-          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
+          (_ktype461, _vtype462, _size460 ) = iprot.readMapBegin()
-          for _i457 in xrange(_size453):
+          for _i464 in xrange(_size460):
-            _key458 = iprot.readString();
+            _key465 = iprot.readString();
-            _val459 = iprot.readDouble();
+            _val466 = iprot.readDouble();
-            self.collectedAmountMap[_key458] = _val459
+            self.collectedAmountMap[_key465] = _val466
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.STRING:
       return
     oprot.writeStructBegin('reconcileCodCollection_args')
     if self.collectedAmountMap is not None:
       oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
       oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
-      for kiter460,viter461 in self.collectedAmountMap.items():
+      for kiter467,viter468 in self.collectedAmountMap.items():
-        oprot.writeString(kiter460)
+        oprot.writeString(kiter467)
-        oprot.writeDouble(viter461)
+        oprot.writeDouble(viter468)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.xferBy is not None:
       oprot.writeFieldBegin('xferBy', TType.STRING, 2)
       oprot.writeString(self.xferBy)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
+          (_ktype470, _vtype471, _size469 ) = iprot.readMapBegin()
-          for _i466 in xrange(_size462):
+          for _i473 in xrange(_size469):
-            _key467 = iprot.readString();
+            _key474 = iprot.readString();
-            _val468 = iprot.readString();
+            _val475 = iprot.readString();
-            self.success[_key467] = _val468
+            self.success[_key474] = _val475
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('reconcileCodCollection_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
-      for kiter469,viter470 in self.success.items():
+      for kiter476,viter477 in self.success.items():
-        oprot.writeString(kiter469)
+        oprot.writeString(kiter476)
-        oprot.writeString(viter470)
+        oprot.writeString(viter477)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype474, _size471) = iprot.readListBegin()
+          (_etype481, _size478) = iprot.readListBegin()
-          for _i475 in xrange(_size471):
+          for _i482 in xrange(_size478):
-            _elem476 = iprot.readI64();
+            _elem483 = iprot.readI64();
-            self.success.append(_elem476)
+            self.success.append(_elem483)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.I64, len(self.success))
-      for iter477 in self.success:
+      for iter484 in self.success:
-        oprot.writeI64(iter477)
+        oprot.writeI64(iter484)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
+          (_ktype486, _vtype487, _size485 ) = iprot.readMapBegin()
-          for _i482 in xrange(_size478):
+          for _i489 in xrange(_size485):
-            _key483 = iprot.readI64();
+            _key490 = iprot.readI64();
-            _val484 = iprot.readI64();
+            _val491 = iprot.readI64();
-            self.success[_key483] = _val484
+            self.success[_key490] = _val491
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
-      for kiter485,viter486 in self.success.items():
+      for kiter492,viter493 in self.success.items():
-        oprot.writeI64(kiter485)
+        oprot.writeI64(kiter492)
-        oprot.writeI64(viter486)
+        oprot.writeI64(viter493)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.itemIds = []
-          (_etype490, _size487) = iprot.readListBegin()
+          (_etype497, _size494) = iprot.readListBegin()
-          for _i491 in xrange(_size487):
+          for _i498 in xrange(_size494):
-            _elem492 = iprot.readI64();
+            _elem499 = iprot.readI64();
-            self.itemIds.append(_elem492)
+            self.itemIds.append(_elem499)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersForItemIds_args')
     if self.itemIds is not None:
       oprot.writeFieldBegin('itemIds', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.itemIds))
-      for iter493 in self.itemIds:
+      for iter500 in self.itemIds:
-        oprot.writeI64(iter493)
+        oprot.writeI64(iter500)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype497, _size494) = iprot.readListBegin()
+          (_etype504, _size501) = iprot.readListBegin()
-          for _i498 in xrange(_size494):
+          for _i505 in xrange(_size501):
-            _elem499 = Order()
+            _elem506 = Order()
-            _elem499.read(iprot)
+            _elem506.read(iprot)
-            self.success.append(_elem499)
+            self.success.append(_elem506)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersForItemIds_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter500 in self.success:
+      for iter507 in self.success:
-        iter500.write(oprot)
+        iter507.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
+          (_ktype509, _vtype510, _size508 ) = iprot.readMapBegin()
-          for _i505 in xrange(_size501):
+          for _i512 in xrange(_size508):
-            _key506 = iprot.readI32();
+            _key513 = iprot.readI32();
-            _val507 = TimeoutSummary()
+            _val514 = TimeoutSummary()
-            _val507.read(iprot)
+            _val514.read(iprot)
-            self.success[_key506] = _val507
+            self.success[_key513] = _val514
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('markOrdersAsTimeout_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
-      for kiter508,viter509 in self.success.items():
+      for kiter515,viter516 in self.success.items():
-        oprot.writeI32(kiter508)
+        oprot.writeI32(kiter515)
-        viter509.write(oprot)
+        viter516.write(oprot)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype513, _size510) = iprot.readListBegin()
+          (_etype520, _size517) = iprot.readListBegin()
-          for _i514 in xrange(_size510):
+          for _i521 in xrange(_size517):
-            _elem515 = Order()
+            _elem522 = Order()
-            _elem515.read(iprot)
+            _elem522.read(iprot)
-            self.success.append(_elem515)
+            self.success.append(_elem522)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrderForAwb_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter516 in self.success:
+      for iter523 in self.success:
-        iter516.write(oprot)
+        iter523.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.LIST:
           self.order_status_list = []
-          (_etype520, _size517) = iprot.readListBegin()
+          (_etype527, _size524) = iprot.readListBegin()
-          for _i521 in xrange(_size517):
+          for _i528 in xrange(_size524):
-            _elem522 = iprot.readI32();
+            _elem529 = iprot.readI32();
-            self.order_status_list.append(_elem522)
+            self.order_status_list.append(_elem529)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.logistics_provider_id)
       oprot.writeFieldEnd()
     if self.order_status_list is not None:
       oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
       oprot.writeListBegin(TType.I32, len(self.order_status_list))
-      for iter523 in self.order_status_list:
+      for iter530 in self.order_status_list:
-        oprot.writeI32(iter523)
+        oprot.writeI32(iter530)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype527, _size524) = iprot.readListBegin()
+          (_etype534, _size531) = iprot.readListBegin()
-          for _i528 in xrange(_size524):
+          for _i535 in xrange(_size531):
-            _elem529 = Order()
+            _elem536 = Order()
-            _elem529.read(iprot)
+            _elem536.read(iprot)
-            self.success.append(_elem529)
+            self.success.append(_elem536)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrdersForProviderForStatus_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter530 in self.success:
+      for iter537 in self.success:
-        iter530.write(oprot)
+        iter537.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype534, _size531) = iprot.readListBegin()
+          (_etype541, _size538) = iprot.readListBegin()
-          for _i535 in xrange(_size531):
+          for _i542 in xrange(_size538):
-            _elem536 = Order()
+            _elem543 = Order()
-            _elem536.read(iprot)
+            _elem543.read(iprot)
-            self.success.append(_elem536)
+            self.success.append(_elem543)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getBilledOrdersForVendor_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter537 in self.success:
+      for iter544 in self.success:
-        iter537.write(oprot)
+        iter544.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype541, _size538) = iprot.readListBegin()
+          (_etype548, _size545) = iprot.readListBegin()
-          for _i542 in xrange(_size538):
+          for _i549 in xrange(_size545):
-            _elem543 = Order()
+            _elem550 = Order()
-            _elem543.read(iprot)
+            _elem550.read(iprot)
-            self.success.append(_elem543)
+            self.success.append(_elem550)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getSlippedSippingDateOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter544 in self.success:
+      for iter551 in self.success:
-        iter544.write(oprot)
+        iter551.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype548, _size545) = iprot.readListBegin()
+          (_etype555, _size552) = iprot.readListBegin()
-          for _i549 in xrange(_size545):
+          for _i556 in xrange(_size552):
-            _elem550 = Order()
+            _elem557 = Order()
-            _elem550.read(iprot)
+            _elem557.read(iprot)
-            self.success.append(_elem550)
+            self.success.append(_elem557)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getCancelledOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter551 in self.success:
+      for iter558 in self.success:
-        iter551.write(oprot)
+        iter558.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.MAP:
           self.mapAWBAndAmount = {}
-          (_ktype553, _vtype554, _size552 ) = iprot.readMapBegin()
+          (_ktype560, _vtype561, _size559 ) = iprot.readMapBegin()
-          for _i556 in xrange(_size552):
+          for _i563 in xrange(_size559):
-            _key557 = iprot.readI64();
+            _key564 = iprot.readI64();
-            _val558 = iprot.readDouble();
+            _val565 = iprot.readDouble();
-            self.mapAWBAndAmount[_key557] = _val558
+            self.mapAWBAndAmount[_key564] = _val565
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('saveBluedartSettlements_args')
     if self.mapAWBAndAmount is not None:
       oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
       oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
-      for kiter559,viter560 in self.mapAWBAndAmount.items():
+      for kiter566,viter567 in self.mapAWBAndAmount.items():
-        oprot.writeI64(kiter559)
+        oprot.writeI64(kiter566)
-        oprot.writeDouble(viter560)
+        oprot.writeDouble(viter567)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype562, _vtype563, _size561 ) = iprot.readMapBegin()
+          (_ktype569, _vtype570, _size568 ) = iprot.readMapBegin()
-          for _i565 in xrange(_size561):
+          for _i572 in xrange(_size568):
-            _key566 = iprot.readI64();
+            _key573 = iprot.readI64();
-            _val567 = iprot.readString();
+            _val574 = iprot.readString();
-            self.success[_key566] = _val567
+            self.success[_key573] = _val574
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getEBSSettlementSummaries_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
-      for kiter568,viter569 in self.success.items():
+      for kiter575,viter576 in self.success.items():
-        oprot.writeI64(kiter568)
+        oprot.writeI64(kiter575)
-        oprot.writeString(viter569)
+        oprot.writeString(viter576)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype573, _size570) = iprot.readListBegin()
+          (_etype580, _size577) = iprot.readListBegin()
-          for _i574 in xrange(_size570):
+          for _i581 in xrange(_size577):
-            _elem575 = PaymentSettlement()
+            _elem582 = PaymentSettlement()
-            _elem575.read(iprot)
+            _elem582.read(iprot)
-            self.success.append(_elem575)
+            self.success.append(_elem582)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getSettlementsByDate_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter576 in self.success:
+      for iter583 in self.success:
-        iter576.write(oprot)
+        iter583.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.orderIds = []
-          (_etype580, _size577) = iprot.readListBegin()
+          (_etype587, _size584) = iprot.readListBegin()
-          for _i581 in xrange(_size577):
+          for _i588 in xrange(_size584):
-            _elem582 = iprot.readI64();
+            _elem589 = iprot.readI64();
-            self.orderIds.append(_elem582)
+            self.orderIds.append(_elem589)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReshippedOrderIds_args')
     if self.orderIds is not None:
       oprot.writeFieldBegin('orderIds', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.orderIds))
-      for iter583 in self.orderIds:
+      for iter590 in self.orderIds:
-        oprot.writeI64(iter583)
+        oprot.writeI64(iter590)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype587, _size584) = iprot.readListBegin()
+          (_etype594, _size591) = iprot.readListBegin()
-          for _i588 in xrange(_size584):
+          for _i595 in xrange(_size591):
-            _elem589 = iprot.readI64();
+            _elem596 = iprot.readI64();
-            self.success.append(_elem589)
+            self.success.append(_elem596)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getReshippedOrderIds_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.I64, len(self.success))
-      for iter590 in self.success:
+      for iter597 in self.success:
-        oprot.writeI64(iter590)
+        oprot.writeI64(iter597)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype594, _size591) = iprot.readListBegin()
+          (_etype601, _size598) = iprot.readListBegin()
-          for _i595 in xrange(_size591):
+          for _i602 in xrange(_size598):
-            _elem596 = Order()
+            _elem603 = Order()
-            _elem596.read(iprot)
+            _elem603.read(iprot)
-            self.success.append(_elem596)
+            self.success.append(_elem603)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getBilledOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter597 in self.success:
+      for iter604 in self.success:
-        iter597.write(oprot)
+        iter604.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype599, _vtype600, _size598 ) = iprot.readMapBegin()
+          (_ktype606, _vtype607, _size605 ) = iprot.readMapBegin()
-          for _i602 in xrange(_size598):
+          for _i609 in xrange(_size605):
-            _key603 = iprot.readI64();
+            _key610 = iprot.readI64();
-            _val604 = iprot.readI64();
+            _val611 = iprot.readI64();
-            self.success[_key603] = _val604
+            self.success[_key610] = _val611
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getStatusDistributionOfOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
-      for kiter605,viter606 in self.success.items():
+      for kiter612,viter613 in self.success.items():
-        oprot.writeI64(kiter605)
+        oprot.writeI64(kiter612)
-        oprot.writeI64(viter606)
+        oprot.writeI64(viter613)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype610, _size607) = iprot.readListBegin()
+          (_etype617, _size614) = iprot.readListBegin()
-          for _i611 in xrange(_size607):
+          for _i618 in xrange(_size614):
-            _elem612 = iprot.readI64();
+            _elem619 = iprot.readI64();
-            self.success.append(_elem612)
+            self.success.append(_elem619)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrderIdsForStatus_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.I64, len(self.success))
-      for iter613 in self.success:
+      for iter620 in self.success:
-        oprot.writeI64(iter613)
+        oprot.writeI64(iter620)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype617, _size614) = iprot.readListBegin()
+          (_etype624, _size621) = iprot.readListBegin()
-          for _i618 in xrange(_size614):
+          for _i625 in xrange(_size621):
-            _elem619 = Order()
+            _elem626 = Order()
-            _elem619.read(iprot)
+            _elem626.read(iprot)
-            self.success.append(_elem619)
+            self.success.append(_elem626)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter620 in self.success:
+      for iter627 in self.success:
-        iter620.write(oprot)
+        iter627.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype624, _size621) = iprot.readListBegin()
+          (_etype631, _size628) = iprot.readListBegin()
-          for _i625 in xrange(_size621):
+          for _i632 in xrange(_size628):
-            _elem626 = CODVerificationAgent()
+            _elem633 = CODVerificationAgent()
-            _elem626.read(iprot)
+            _elem633.read(iprot)
-            self.success.append(_elem626)
+            self.success.append(_elem633)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllVerificationAgents_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter627 in self.success:
+      for iter634 in self.success:
-        iter627.write(oprot)
+        iter634.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype631, _size628) = iprot.readListBegin()
+          (_etype638, _size635) = iprot.readListBegin()
-          for _i632 in xrange(_size628):
+          for _i639 in xrange(_size635):
-            _elem633 = Attribute()
+            _elem640 = Attribute()
-            _elem633.read(iprot)
+            _elem640.read(iprot)
-            self.success.append(_elem633)
+            self.success.append(_elem640)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllAttributesForOrderId_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter634 in self.success:
+      for iter641 in self.success:
-        iter634.write(oprot)
+        iter641.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == -1:
         if ftype == TType.LIST:
           self.attributes = []
-          (_etype638, _size635) = iprot.readListBegin()
+          (_etype645, _size642) = iprot.readListBegin()
-          for _i639 in xrange(_size635):
+          for _i646 in xrange(_size642):
-            _elem640 = Attribute()
+            _elem647 = Attribute()
-            _elem640.read(iprot)
+            _elem647.read(iprot)
-            self.attributes.append(_elem640)
+            self.attributes.append(_elem647)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('setOrderAttributes_args')
     if self.attributes is not None:
       oprot.writeFieldBegin('attributes', TType.LIST, -1)
       oprot.writeListBegin(TType.STRUCT, len(self.attributes))
-      for iter641 in self.attributes:
+      for iter648 in self.attributes:
-        iter641.write(oprot)
+        iter648.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.orderId is not None:
       oprot.writeFieldBegin('orderId', TType.I64, 1)
       oprot.writeI64(self.orderId)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype645, _size642) = iprot.readListBegin()
+          (_etype652, _size649) = iprot.readListBegin()
-          for _i646 in xrange(_size642):
+          for _i653 in xrange(_size649):
-            _elem647 = Order()
+            _elem654 = Order()
-            _elem647.read(iprot)
+            _elem654.read(iprot)
-            self.success.append(_elem647)
+            self.success.append(_elem654)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReceivePendingOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter648 in self.success:
+      for iter655 in self.success:
-        iter648.write(oprot)
+        iter655.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype652, _size649) = iprot.readListBegin()
+          (_etype659, _size656) = iprot.readListBegin()
-          for _i653 in xrange(_size649):
+          for _i660 in xrange(_size656):
-            _elem654 = Order()
+            _elem661 = Order()
-            _elem654.read(iprot)
+            _elem661.read(iprot)
-            self.success.append(_elem654)
+            self.success.append(_elem661)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReceivedAtStoreOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter655 in self.success:
+      for iter662 in self.success:
-        iter655.write(oprot)
+        iter662.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype659, _size656) = iprot.readListBegin()
+          (_etype666, _size663) = iprot.readListBegin()
-          for _i660 in xrange(_size656):
+          for _i667 in xrange(_size663):
-            _elem661 = Order()
+            _elem668 = Order()
-            _elem661.read(iprot)
+            _elem668.read(iprot)
-            self.success.append(_elem661)
+            self.success.append(_elem668)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersCollectionAtStore_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter662 in self.success:
+      for iter669 in self.success:
-        iter662.write(oprot)
+        iter669.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype666, _size663) = iprot.readListBegin()
+          (_etype673, _size670) = iprot.readListBegin()
-          for _i667 in xrange(_size663):
+          for _i674 in xrange(_size670):
-            _elem668 = RechargeOrder()
+            _elem675 = RechargeOrder()
-            _elem668.read(iprot)
+            _elem675.read(iprot)
-            self.success.append(_elem668)
+            self.success.append(_elem675)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getRechargeOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter669 in self.success:
+      for iter676 in self.success:
-        iter669.write(oprot)
+        iter676.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype673, _size670) = iprot.readListBegin()
+          (_etype680, _size677) = iprot.readListBegin()
-          for _i674 in xrange(_size670):
+          for _i681 in xrange(_size677):
-            _elem675 = UserWalletHistory()
+            _elem682 = UserWalletHistory()
-            _elem675.read(iprot)
+            _elem682.read(iprot)
-            self.success.append(_elem675)
+            self.success.append(_elem682)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getUserWalletHistory_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter676 in self.success:
+      for iter683 in self.success:
-        iter676.write(oprot)
+        iter683.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype678, _vtype679, _size677 ) = iprot.readMapBegin()
+          (_ktype685, _vtype686, _size684 ) = iprot.readMapBegin()
-          for _i681 in xrange(_size677):
+          for _i688 in xrange(_size684):
-            _key682 = iprot.readI64();
+            _key689 = iprot.readI64();
-            _val683 = iprot.readString();
+            _val690 = iprot.readString();
-            self.success[_key682] = _val683
+            self.success[_key689] = _val690
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getServiceProviders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
-      for kiter684,viter685 in self.success.items():
+      for kiter691,viter692 in self.success.items():
-        oprot.writeI64(kiter684)
+        oprot.writeI64(kiter691)
-        oprot.writeString(viter685)
+        oprot.writeString(viter692)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype689, _size686) = iprot.readListBegin()
+          (_etype696, _size693) = iprot.readListBegin()
-          for _i690 in xrange(_size686):
+          for _i697 in xrange(_size693):
-            _elem691 = RechargeOrder()
+            _elem698 = RechargeOrder()
-            _elem691.read(iprot)
+            _elem698.read(iprot)
-            self.success.append(_elem691)
+            self.success.append(_elem698)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getRechargeOrdersForDevice_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter692 in self.success:
+      for iter699 in self.success:
-        iter692.write(oprot)
+        iter699.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype696, _size693) = iprot.readListBegin()
+          (_etype703, _size700) = iprot.readListBegin()
-          for _i697 in xrange(_size693):
+          for _i704 in xrange(_size700):
-            _elem698 = RechargeOrder()
+            _elem705 = RechargeOrder()
-            _elem698.read(iprot)
+            _elem705.read(iprot)
-            self.success.append(_elem698)
+            self.success.append(_elem705)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getRechargeOrdersForStatus_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter699 in self.success:
+      for iter706 in self.success:
-        iter699.write(oprot)
+        iter706.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype703, _size700) = iprot.readListBegin()
+          (_etype710, _size707) = iprot.readListBegin()
-          for _i704 in xrange(_size700):
+          for _i711 in xrange(_size707):
-            _elem705 = RechargePlan()
+            _elem712 = RechargePlan()
-            _elem705.read(iprot)
+            _elem712.read(iprot)
-            self.success.append(_elem705)
+            self.success.append(_elem712)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getPlansForOperator_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter706 in self.success:
+      for iter713 in self.success:
-        iter706.write(oprot)
+        iter713.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype710, _size707) = iprot.readListBegin()
+          (_etype717, _size714) = iprot.readListBegin()
-          for _i711 in xrange(_size707):
+          for _i718 in xrange(_size714):
-            _elem712 = RechargeDenomination()
+            _elem719 = RechargeDenomination()
-            _elem712.read(iprot)
+            _elem719.read(iprot)
-            self.success.append(_elem712)
+            self.success.append(_elem719)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getRechargeDenominations_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter713 in self.success:
+      for iter720 in self.success:
-        iter713.write(oprot)
+        iter720.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype717, _size714) = iprot.readListBegin()
+          (_etype724, _size721) = iprot.readListBegin()
-          for _i718 in xrange(_size714):
+          for _i725 in xrange(_size721):
-            _elem719 = EmiScheme()
+            _elem726 = EmiScheme()
-            _elem719.read(iprot)
+            _elem726.read(iprot)
-            self.success.append(_elem719)
+            self.success.append(_elem726)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAvailableEmiSchemes_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter720 in self.success:
+      for iter727 in self.success:
-        iter720.write(oprot)
+        iter727.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype722, _vtype723, _size721 ) = iprot.readMapBegin()
+          (_ktype729, _vtype730, _size728 ) = iprot.readMapBegin()
-          for _i725 in xrange(_size721):
+          for _i732 in xrange(_size728):
-            _key726 = iprot.readI64();
+            _key733 = iprot.readI64();
-            _val727 = iprot.readDouble();
+            _val734 = iprot.readDouble();
-            self.success[_key726] = _val727
+            self.success[_key733] = _val734
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getMiscCharges_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
-      for kiter728,viter729 in self.success.items():
+      for kiter735,viter736 in self.success.items():
-        oprot.writeI64(kiter728)
+        oprot.writeI64(kiter735)
-        oprot.writeDouble(viter729)
+        oprot.writeDouble(viter736)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype733, _size730) = iprot.readListBegin()
+          (_etype740, _size737) = iprot.readListBegin()
-          for _i734 in xrange(_size730):
+          for _i741 in xrange(_size737):
-            _elem735 = Order()
+            _elem742 = Order()
-            _elem735.read(iprot)
+            _elem742.read(iprot)
-            self.success.append(_elem735)
+            self.success.append(_elem742)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getPhysicalOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter736 in self.success:
+      for iter743 in self.success:
-        iter736.write(oprot)
+        iter743.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype740, _size737) = iprot.readListBegin()
+          (_etype747, _size744) = iprot.readListBegin()
-          for _i741 in xrange(_size737):
+          for _i748 in xrange(_size744):
-            _elem742 = iprot.readString();
+            _elem749 = iprot.readString();
-            self.success.append(_elem742)
+            self.success.append(_elem749)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRING, len(self.success))
-      for iter743 in self.success:
+      for iter750 in self.success:
-        oprot.writeString(iter743)
+        oprot.writeString(iter750)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype747, _size744) = iprot.readListBegin()
+          (_etype754, _size751) = iprot.readListBegin()
-          for _i748 in xrange(_size744):
+          for _i755 in xrange(_size751):
-            _elem749 = RechargeTransaction()
+            _elem756 = RechargeTransaction()
-            _elem749.read(iprot)
+            _elem756.read(iprot)
-            self.success.append(_elem749)
+            self.success.append(_elem756)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getRechargeTransactions_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter750 in self.success:
+      for iter757 in self.success:
-        iter750.write(oprot)
+        iter757.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype754, _size751) = iprot.readListBegin()
+          (_etype761, _size758) = iprot.readListBegin()
-          for _i755 in xrange(_size751):
+          for _i762 in xrange(_size758):
-            _elem756 = RechargeTransaction()
+            _elem763 = RechargeTransaction()
-            _elem756.read(iprot)
+            _elem763.read(iprot)
-            self.success.append(_elem756)
+            self.success.append(_elem763)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getRechargeTrans_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter757 in self.success:
+      for iter764 in self.success:
-        iter757.write(oprot)
+        iter764.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype761, _size758) = iprot.readListBegin()
+          (_etype768, _size765) = iprot.readListBegin()
-          for _i762 in xrange(_size758):
+          for _i769 in xrange(_size765):
-            _elem763 = FRC()
+            _elem770 = FRC()
-            _elem763.read(iprot)
+            _elem770.read(iprot)
-            self.success.append(_elem763)
+            self.success.append(_elem770)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getFRCs_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter764 in self.success:
+      for iter771 in self.success:
-        iter764.write(oprot)
+        iter771.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype768, _size765) = iprot.readListBegin()
+          (_etype775, _size772) = iprot.readListBegin()
-          for _i769 in xrange(_size765):
+          for _i776 in xrange(_size772):
-            _elem770 = RechargeTransaction()
+            _elem777 = RechargeTransaction()
-            _elem770.read(iprot)
+            _elem777.read(iprot)
-            self.success.append(_elem770)
+            self.success.append(_elem777)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getRechargeTransactionsByNumber_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter771 in self.success:
+      for iter778 in self.success:
-        iter771.write(oprot)
+        iter778.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype775, _size772) = iprot.readListBegin()
+          (_etype782, _size779) = iprot.readListBegin()
-          for _i776 in xrange(_size772):
+          for _i783 in xrange(_size779):
-            _elem777 = TelecomCircle()
+            _elem784 = TelecomCircle()
-            _elem777.read(iprot)
+            _elem784.read(iprot)
-            self.success.append(_elem777)
+            self.success.append(_elem784)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllCircles_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter778 in self.success:
+      for iter785 in self.success:
-        iter778.write(oprot)
+        iter785.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.frcIdsToDelete = []
-          (_etype782, _size779) = iprot.readListBegin()
+          (_etype789, _size786) = iprot.readListBegin()
-          for _i783 in xrange(_size779):
+          for _i790 in xrange(_size786):
-            _elem784 = iprot.readI64();
+            _elem791 = iprot.readI64();
-            self.frcIdsToDelete.append(_elem784)
+            self.frcIdsToDelete.append(_elem791)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('deleteFrcs_args')
     if self.frcIdsToDelete is not None:
       oprot.writeFieldBegin('frcIdsToDelete', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.frcIdsToDelete))
-      for iter785 in self.frcIdsToDelete:
+      for iter792 in self.frcIdsToDelete:
-        oprot.writeI64(iter785)
+        oprot.writeI64(iter792)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype789, _size786) = iprot.readListBegin()
+          (_etype796, _size793) = iprot.readListBegin()
-          for _i790 in xrange(_size786):
+          for _i797 in xrange(_size793):
-            _elem791 = Order()
+            _elem798 = Order()
-            _elem791.read(iprot)
+            _elem798.read(iprot)
-            self.success.append(_elem791)
+            self.success.append(_elem798)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAmazonOrdersShipped_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter792 in self.success:
+      for iter799 in self.success:
-        iter792.write(oprot)
+        iter799.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype796, _size793) = iprot.readListBegin()
+          (_etype803, _size800) = iprot.readListBegin()
-          for _i797 in xrange(_size793):
+          for _i804 in xrange(_size800):
-            _elem798 = Order()
+            _elem805 = Order()
-            _elem798.read(iprot)
+            _elem805.read(iprot)
-            self.success.append(_elem798)
+            self.success.append(_elem805)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAmazonOrdersCancelled_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter799 in self.success:
+      for iter806 in self.success:
-        iter799.write(oprot)
+        iter806.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype803, _size800) = iprot.readListBegin()
+          (_etype810, _size807) = iprot.readListBegin()
-          for _i804 in xrange(_size800):
+          for _i811 in xrange(_size807):
-            _elem805 = AmazonOrder()
+            _elem812 = AmazonOrder()
-            _elem805.read(iprot)
+            _elem812.read(iprot)
-            self.success.append(_elem805)
+            self.success.append(_elem812)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAmazonOrderByAmazonOrderId_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter806 in self.success:
+      for iter813 in self.success:
-        iter806.write(oprot)
+        iter813.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 5:
         if ftype == TType.LIST:
           self.statuses = []
-          (_etype810, _size807) = iprot.readListBegin()
+          (_etype817, _size814) = iprot.readListBegin()
-          for _i811 in xrange(_size807):
+          for _i818 in xrange(_size814):
-            _elem812 = iprot.readI32();
+            _elem819 = iprot.readI32();
-            self.statuses.append(_elem812)
+            self.statuses.append(_elem819)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.endDate)
       oprot.writeFieldEnd()
     if self.statuses is not None:
       oprot.writeFieldBegin('statuses', TType.LIST, 5)
       oprot.writeListBegin(TType.I32, len(self.statuses))
-      for iter813 in self.statuses:
+      for iter820 in self.statuses:
-        oprot.writeI32(iter813)
+        oprot.writeI32(iter820)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype817, _size814) = iprot.readListBegin()
+          (_etype824, _size821) = iprot.readListBegin()
-          for _i818 in xrange(_size814):
+          for _i825 in xrange(_size821):
-            _elem819 = Order()
+            _elem826 = Order()
-            _elem819.read(iprot)
+            _elem826.read(iprot)
-            self.success.append(_elem819)
+            self.success.append(_elem826)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersForStore_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter820 in self.success:
+      for iter827 in self.success:
-        iter820.write(oprot)
+        iter827.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype824, _size821) = iprot.readListBegin()
+          (_etype831, _size828) = iprot.readListBegin()
-          for _i825 in xrange(_size821):
+          for _i832 in xrange(_size828):
-            _elem826 = iprot.readString();
+            _elem833 = iprot.readString();
-            self.success.append(_elem826)
+            self.success.append(_elem833)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllEdcBanks_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRING, len(self.success))
-      for iter827 in self.success:
+      for iter834 in self.success:
-        oprot.writeString(iter827)
+        oprot.writeString(iter834)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype831, _size828) = iprot.readListBegin()
+          (_etype838, _size835) = iprot.readListBegin()
-          for _i832 in xrange(_size828):
+          for _i839 in xrange(_size835):
-            _elem833 = StoreOrderCollection()
+            _elem840 = StoreOrderCollection()
-            _elem833.read(iprot)
+            _elem840.read(iprot)
-            self.success.append(_elem833)
+            self.success.append(_elem840)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getCollectionsForStore_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter834 in self.success:
+      for iter841 in self.success:
-        iter834.write(oprot)
+        iter841.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype838, _size835) = iprot.readListBegin()
+          (_etype845, _size842) = iprot.readListBegin()
-          for _i839 in xrange(_size835):
+          for _i846 in xrange(_size842):
-            _elem840 = AmazonOrdersToAcknowledge()
+            _elem847 = AmazonOrdersToAcknowledge()
-            _elem840.read(iprot)
+            _elem847.read(iprot)
-            self.success.append(_elem840)
+            self.success.append(_elem847)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAmazonOrdersToAcknowledge_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter841 in self.success:
+      for iter848 in self.success:
-        iter841.write(oprot)
+        iter848.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.MAP:
           self.amazonOrderDelivery = {}
-          (_ktype843, _vtype844, _size842 ) = iprot.readMapBegin()
+          (_ktype850, _vtype851, _size849 ) = iprot.readMapBegin()
-          for _i846 in xrange(_size842):
+          for _i853 in xrange(_size849):
-            _key847 = iprot.readI64();
+            _key854 = iprot.readI64();
-            _val848 = {}
+            _val855 = {}
-            (_ktype850, _vtype851, _size849 ) = iprot.readMapBegin()
+            (_ktype857, _vtype858, _size856 ) = iprot.readMapBegin()
-            for _i853 in xrange(_size849):
+            for _i860 in xrange(_size856):
-              _key854 = iprot.readString();
+              _key861 = iprot.readString();
-              _val855 = iprot.readString();
+              _val862 = iprot.readString();
-              _val848[_key854] = _val855
+              _val855[_key861] = _val862
             iprot.readMapEnd()
-            self.amazonOrderDelivery[_key847] = _val848
+            self.amazonOrderDelivery[_key854] = _val855
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('updateTimestampForAmazonOrder_args')
     if self.amazonOrderDelivery is not None:
       oprot.writeFieldBegin('amazonOrderDelivery', TType.MAP, 1)
       oprot.writeMapBegin(TType.I64, TType.MAP, len(self.amazonOrderDelivery))
-      for kiter856,viter857 in self.amazonOrderDelivery.items():
+      for kiter863,viter864 in self.amazonOrderDelivery.items():
-        oprot.writeI64(kiter856)
+        oprot.writeI64(kiter863)
-        oprot.writeMapBegin(TType.STRING, TType.STRING, len(viter857))
+        oprot.writeMapBegin(TType.STRING, TType.STRING, len(viter864))
-        for kiter858,viter859 in viter857.items():
+        for kiter865,viter866 in viter864.items():
-          oprot.writeString(kiter858)
+          oprot.writeString(kiter865)
-          oprot.writeString(viter859)
+          oprot.writeString(viter866)
         oprot.writeMapEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype863, _size860) = iprot.readListBegin()
+          (_etype870, _size867) = iprot.readListBegin()
-          for _i864 in xrange(_size860):
+          for _i871 in xrange(_size867):
-            _elem865 = Order()
+            _elem872 = Order()
-            _elem865.read(iprot)
+            _elem872.read(iprot)
-            self.success.append(_elem865)
+            self.success.append(_elem872)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersByMobileNumber_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter866 in self.success:
+      for iter873 in self.success:
-        iter866.write(oprot)
+        iter873.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype870, _size867) = iprot.readListBegin()
+          (_etype877, _size874) = iprot.readListBegin()
-          for _i871 in xrange(_size867):
+          for _i878 in xrange(_size874):
-            _elem872 = Order()
+            _elem879 = Order()
-            _elem872.read(iprot)
+            _elem879.read(iprot)
-            self.success.append(_elem872)
+            self.success.append(_elem879)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersByAmazonOrderCode_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter873 in self.success:
+      for iter880 in self.success:
-        iter873.write(oprot)
+        iter880.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype877, _size874) = iprot.readListBegin()
+          (_etype884, _size881) = iprot.readListBegin()
-          for _i878 in xrange(_size874):
+          for _i885 in xrange(_size881):
-            _elem879 = HotspotServiceMatrix()
+            _elem886 = HotspotServiceMatrix()
-            _elem879.read(iprot)
+            _elem886.read(iprot)
-            self.success.append(_elem879)
+            self.success.append(_elem886)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getHotspotServiceMatrices_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter880 in self.success:
+      for iter887 in self.success:
-        iter880.write(oprot)
+        iter887.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.vendors = []
-          (_etype884, _size881) = iprot.readListBegin()
+          (_etype891, _size888) = iprot.readListBegin()
-          for _i885 in xrange(_size881):
+          for _i892 in xrange(_size888):
-            _elem886 = iprot.readI64();
+            _elem893 = iprot.readI64();
-            self.vendors.append(_elem886)
+            self.vendors.append(_elem893)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.LIST:
           self.statuses = []
-          (_etype890, _size887) = iprot.readListBegin()
+          (_etype897, _size894) = iprot.readListBegin()
-          for _i891 in xrange(_size887):
+          for _i898 in xrange(_size894):
-            _elem892 = iprot.readI32();
+            _elem899 = iprot.readI32();
-            self.statuses.append(_elem892)
+            self.statuses.append(_elem899)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersByVendor_args')
     if self.vendors is not None:
       oprot.writeFieldBegin('vendors', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.vendors))
-      for iter893 in self.vendors:
+      for iter900 in self.vendors:
-        oprot.writeI64(iter893)
+        oprot.writeI64(iter900)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.statuses is not None:
       oprot.writeFieldBegin('statuses', TType.LIST, 2)
       oprot.writeListBegin(TType.I32, len(self.statuses))
-      for iter894 in self.statuses:
+      for iter901 in self.statuses:
-        oprot.writeI32(iter894)
+        oprot.writeI32(iter901)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype898, _size895) = iprot.readListBegin()
+          (_etype905, _size902) = iprot.readListBegin()
-          for _i899 in xrange(_size895):
+          for _i906 in xrange(_size902):
-            _elem900 = Order()
+            _elem907 = Order()
-            _elem900.read(iprot)
+            _elem907.read(iprot)
-            self.success.append(_elem900)
+            self.success.append(_elem907)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrdersByVendor_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter901 in self.success:
+      for iter908 in self.success:
-        iter901.write(oprot)
+        iter908.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype905, _size902) = iprot.readListBegin()
+          (_etype912, _size909) = iprot.readListBegin()
-          for _i906 in xrange(_size902):
+          for _i913 in xrange(_size909):
-            _elem907 = EbayOrder()
+            _elem914 = EbayOrder()
-            _elem907.read(iprot)
+            _elem914.read(iprot)
-            self.success.append(_elem907)
+            self.success.append(_elem914)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getEbayOrder_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter908 in self.success:
+      for iter915 in self.success:
-        iter908.write(oprot)
+        iter915.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype912, _size909) = iprot.readListBegin()
+          (_etype919, _size916) = iprot.readListBegin()
-          for _i913 in xrange(_size909):
+          for _i920 in xrange(_size916):
-            _elem914 = AmazonFbaSalesSnapshot()
+            _elem921 = AmazonFbaSalesSnapshot()
-            _elem914.read(iprot)
+            _elem921.read(iprot)
-            self.success.append(_elem914)
+            self.success.append(_elem921)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAmazonFbaSalesSnapshotForDays_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter915 in self.success:
+      for iter922 in self.success:
-        iter915.write(oprot)
+        iter922.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype919, _size916) = iprot.readListBegin()
+          (_etype926, _size923) = iprot.readListBegin()
-          for _i920 in xrange(_size916):
+          for _i927 in xrange(_size923):
-            _elem921 = SnapdealOrder()
+            _elem928 = SnapdealOrder()
-            _elem921.read(iprot)
+            _elem928.read(iprot)
-            self.success.append(_elem921)
+            self.success.append(_elem928)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getSnapdealOrder_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter922 in self.success:
+      for iter929 in self.success:
-        iter922.write(oprot)
+        iter929.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype924, _vtype925, _size923 ) = iprot.readMapBegin()
+          (_ktype931, _vtype932, _size930 ) = iprot.readMapBegin()
-          for _i927 in xrange(_size923):
+          for _i934 in xrange(_size930):
-            _key928 = iprot.readI64();
+            _key935 = iprot.readI64();
-            _val929 = iprot.readI64();
+            _val936 = iprot.readI64();
-            self.success[_key928] = _val929
+            self.success[_key935] = _val936
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersCreatedAfterTimestampForSource_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
-      for kiter930,viter931 in self.success.items():
+      for kiter937,viter938 in self.success.items():
-        oprot.writeI64(kiter930)
+        oprot.writeI64(kiter937)
-        oprot.writeI64(viter931)
+        oprot.writeI64(viter938)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype935, _size932) = iprot.readListBegin()
+          (_etype942, _size939) = iprot.readListBegin()
-          for _i936 in xrange(_size932):
+          for _i943 in xrange(_size939):
-            _elem937 = Order()
+            _elem944 = Order()
-            _elem937.read(iprot)
+            _elem944.read(iprot)
-            self.success.append(_elem937)
+            self.success.append(_elem944)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrderForAirwayBillNo_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter938 in self.success:
+      for iter945 in self.success:
-        iter938.write(oprot)
+        iter945.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.MAP:
           self.orders = {}
-          (_ktype940, _vtype941, _size939 ) = iprot.readMapBegin()
+          (_ktype947, _vtype948, _size946 ) = iprot.readMapBegin()
-          for _i943 in xrange(_size939):
+          for _i950 in xrange(_size946):
-            _key944 = iprot.readString();
+            _key951 = iprot.readString();
-            _val945 = []
+            _val952 = []
-            (_etype949, _size946) = iprot.readListBegin()
+            (_etype956, _size953) = iprot.readListBegin()
-            for _i950 in xrange(_size946):
+            for _i957 in xrange(_size953):
-              _elem951 = []
+              _elem958 = []
-              (_etype955, _size952) = iprot.readListBegin()
+              (_etype962, _size959) = iprot.readListBegin()
-              for _i956 in xrange(_size952):
+              for _i963 in xrange(_size959):
-                _elem957 = iprot.readString();
+                _elem964 = iprot.readString();
-                _elem951.append(_elem957)
+                _elem958.append(_elem964)
               iprot.readListEnd()
-              _val945.append(_elem951)
+              _val952.append(_elem958)
             iprot.readListEnd()
-            self.orders[_key944] = _val945
+            self.orders[_key951] = _val952
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('updateSnapdealOrdersStatus_args')
     if self.orders is not None:
       oprot.writeFieldBegin('orders', TType.MAP, 1)
       oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.orders))
-      for kiter958,viter959 in self.orders.items():
+      for kiter965,viter966 in self.orders.items():
-        oprot.writeString(kiter958)
+        oprot.writeString(kiter965)
-        oprot.writeListBegin(TType.LIST, len(viter959))
+        oprot.writeListBegin(TType.LIST, len(viter966))
-        for iter960 in viter959:
+        for iter967 in viter966:
-          oprot.writeListBegin(TType.STRING, len(iter960))
+          oprot.writeListBegin(TType.STRING, len(iter967))
-          for iter961 in iter960:
+          for iter968 in iter967:
-            oprot.writeString(iter961)
+            oprot.writeString(iter968)
           oprot.writeListEnd()
         oprot.writeListEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.delivered_orders = []
-          (_etype965, _size962) = iprot.readListBegin()
+          (_etype972, _size969) = iprot.readListBegin()
-          for _i966 in xrange(_size962):
+          for _i973 in xrange(_size969):
-            _elem967 = []
+            _elem974 = []
-            (_etype971, _size968) = iprot.readListBegin()
+            (_etype978, _size975) = iprot.readListBegin()
-            for _i972 in xrange(_size968):
+            for _i979 in xrange(_size975):
-              _elem973 = iprot.readString();
+              _elem980 = iprot.readString();
-              _elem967.append(_elem973)
+              _elem974.append(_elem980)
             iprot.readListEnd()
-            self.delivered_orders.append(_elem967)
+            self.delivered_orders.append(_elem974)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('updateFlipkartOrdersStatus_args')
     if self.delivered_orders is not None:
       oprot.writeFieldBegin('delivered_orders', TType.LIST, 1)
       oprot.writeListBegin(TType.LIST, len(self.delivered_orders))
-      for iter974 in self.delivered_orders:
+      for iter981 in self.delivered_orders:
-        oprot.writeListBegin(TType.STRING, len(iter974))
+        oprot.writeListBegin(TType.STRING, len(iter981))
-        for iter975 in iter974:
+        for iter982 in iter981:
-          oprot.writeString(iter975)
+          oprot.writeString(iter982)
         oprot.writeListEnd()
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.amazonfbasalessnapshotlist = []
-          (_etype979, _size976) = iprot.readListBegin()
+          (_etype986, _size983) = iprot.readListBegin()
-          for _i980 in xrange(_size976):
+          for _i987 in xrange(_size983):
-            _elem981 = AmazonFbaSalesSnapshot()
+            _elem988 = AmazonFbaSalesSnapshot()
-            _elem981.read(iprot)
+            _elem988.read(iprot)
-            self.amazonfbasalessnapshotlist.append(_elem981)
+            self.amazonfbasalessnapshotlist.append(_elem988)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('bulkAddOrUpdateAmazonFbaSalesSnapshot_args')
     if self.amazonfbasalessnapshotlist is not None:
       oprot.writeFieldBegin('amazonfbasalessnapshotlist', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.amazonfbasalessnapshotlist))
-      for iter982 in self.amazonfbasalessnapshotlist:
+      for iter989 in self.amazonfbasalessnapshotlist:
-        iter982.write(oprot)
+        iter989.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == -1:
         if ftype == TType.LIST:
           self.flipkartorderids = []
-          (_etype986, _size983) = iprot.readListBegin()
+          (_etype993, _size990) = iprot.readListBegin()
-          for _i987 in xrange(_size983):
+          for _i994 in xrange(_size990):
-            _elem988 = iprot.readString();
+            _elem995 = iprot.readString();
-            self.flipkartorderids.append(_elem988)
+            self.flipkartorderids.append(_elem995)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getCreatedOrdersForFlipkart_args')
     if self.flipkartorderids is not None:
       oprot.writeFieldBegin('flipkartorderids', TType.LIST, -1)
       oprot.writeListBegin(TType.STRING, len(self.flipkartorderids))
-      for iter989 in self.flipkartorderids:
+      for iter996 in self.flipkartorderids:
-        oprot.writeString(iter989)
+        oprot.writeString(iter996)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype991, _vtype992, _size990 ) = iprot.readMapBegin()
+          (_ktype998, _vtype999, _size997 ) = iprot.readMapBegin()
-          for _i994 in xrange(_size990):
+          for _i1001 in xrange(_size997):
-            _key995 = iprot.readI64();
+            _key1002 = iprot.readI64();
-            _val996 = iprot.readI64();
+            _val1003 = iprot.readI64();
-            self.success[_key995] = _val996
+            self.success[_key1002] = _val1003
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getCreatedOrdersForFlipkart_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
-      for kiter997,viter998 in self.success.items():
+      for kiter1004,viter1005 in self.success.items():
-        oprot.writeI64(kiter997)
+        oprot.writeI64(kiter1004)
-        oprot.writeI64(viter998)
+        oprot.writeI64(viter1005)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.fbaOrderReturns = []
-          (_etype1002, _size999) = iprot.readListBegin()
+          (_etype1009, _size1006) = iprot.readListBegin()
-          for _i1003 in xrange(_size999):
+          for _i1010 in xrange(_size1006):
-            _elem1004 = AmazonFbaOrderReturns()
+            _elem1011 = AmazonFbaOrderReturns()
-            _elem1004.read(iprot)
+            _elem1011.read(iprot)
-            self.fbaOrderReturns.append(_elem1004)
+            self.fbaOrderReturns.append(_elem1011)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('updateAmazonFbaOrdersReturns_args')
     if self.fbaOrderReturns is not None:
       oprot.writeFieldBegin('fbaOrderReturns', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.fbaOrderReturns))
-      for iter1005 in self.fbaOrderReturns:
+      for iter1012 in self.fbaOrderReturns:
-        iter1005.write(oprot)
+        iter1012.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype1009, _size1006) = iprot.readListBegin()
+          (_etype1016, _size1013) = iprot.readListBegin()
-          for _i1010 in xrange(_size1006):
+          for _i1017 in xrange(_size1013):
-            _elem1011 = AmazonFbaOrderReturns()
+            _elem1018 = AmazonFbaOrderReturns()
-            _elem1011.read(iprot)
+            _elem1018.read(iprot)
-            self.success.append(_elem1011)
+            self.success.append(_elem1018)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getAllAmazonFbaOrderReturnsByCurrentTime_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter1012 in self.success:
+      for iter1019 in self.success:
-        iter1012.write(oprot)
+        iter1019.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype1014, _vtype1015, _size1013 ) = iprot.readMapBegin()
+          (_ktype1021, _vtype1022, _size1020 ) = iprot.readMapBegin()
-          for _i1017 in xrange(_size1013):
+          for _i1024 in xrange(_size1020):
-            _key1018 = iprot.readI64();
+            _key1025 = iprot.readI64();
-            _val1019 = {}
+            _val1026 = {}
-            (_ktype1021, _vtype1022, _size1020 ) = iprot.readMapBegin()
+            (_ktype1028, _vtype1029, _size1027 ) = iprot.readMapBegin()
-            for _i1024 in xrange(_size1020):
+            for _i1031 in xrange(_size1027):
-              _key1025 = iprot.readString();
+              _key1032 = iprot.readString();
-              _val1026 = iprot.readI64();
+              _val1033 = iprot.readI64();
-              _val1019[_key1025] = _val1026
+              _val1026[_key1032] = _val1033
             iprot.readMapEnd()
-            self.success[_key1018] = _val1019
+            self.success[_key1025] = _val1026
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getTotalSaleReturnsFbaSkusCurentTime_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.MAP, len(self.success))
-      for kiter1027,viter1028 in self.success.items():
+      for kiter1034,viter1035 in self.success.items():
-        oprot.writeI64(kiter1027)
+        oprot.writeI64(kiter1034)
-        oprot.writeMapBegin(TType.STRING, TType.I64, len(viter1028))
+        oprot.writeMapBegin(TType.STRING, TType.I64, len(viter1035))
-        for kiter1029,viter1030 in viter1028.items():
+        for kiter1036,viter1037 in viter1035.items():
-          oprot.writeString(kiter1029)
+          oprot.writeString(kiter1036)
-          oprot.writeI64(viter1030)
+          oprot.writeI64(viter1037)
         oprot.writeMapEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype1034, _size1031) = iprot.readListBegin()
+          (_etype1041, _size1038) = iprot.readListBegin()
-          for _i1035 in xrange(_size1031):
+          for _i1042 in xrange(_size1038):
-            _elem1036 = FlipkartOrder()
+            _elem1043 = FlipkartOrder()
-            _elem1036.read(iprot)
+            _elem1043.read(iprot)
-            self.success.append(_elem1036)
+            self.success.append(_elem1043)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getVerificationPendingOrdersFK_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter1037 in self.success:
+      for iter1044 in self.success:
-        iter1037.write(oprot)
+        iter1044.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype1041, _size1038) = iprot.readListBegin()
+          (_etype1048, _size1045) = iprot.readListBegin()
-          for _i1042 in xrange(_size1038):
+          for _i1049 in xrange(_size1045):
-            _elem1043 = FlipkartAdvantageOrder()
+            _elem1050 = FlipkartAdvantageOrder()
-            _elem1043.read(iprot)
+            _elem1050.read(iprot)
-            self.success.append(_elem1043)
+            self.success.append(_elem1050)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getAllFAOrdersList_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter1044 in self.success:
+      for iter1051 in self.success:
-        iter1044.write(oprot)
+        iter1051.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.faOrdersList = []
-          (_etype1048, _size1045) = iprot.readListBegin()
+          (_etype1055, _size1052) = iprot.readListBegin()
-          for _i1049 in xrange(_size1045):
+          for _i1056 in xrange(_size1052):
-            _elem1050 = FlipkartAdvantageOrder()
+            _elem1057 = FlipkartAdvantageOrder()
-            _elem1050.read(iprot)
+            _elem1057.read(iprot)
-            self.faOrdersList.append(_elem1050)
+            self.faOrdersList.append(_elem1057)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('addUpdateFaOrdersBulk_args')
     if self.faOrdersList is not None:
       oprot.writeFieldBegin('faOrdersList', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.faOrdersList))
-      for iter1051 in self.faOrdersList:
+      for iter1058 in self.faOrdersList:
-        iter1051.write(oprot)
+        iter1058.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.flipkartfasalessnapshotlist = []
-          (_etype1055, _size1052) = iprot.readListBegin()
+          (_etype1062, _size1059) = iprot.readListBegin()
-          for _i1056 in xrange(_size1052):
+          for _i1063 in xrange(_size1059):
-            _elem1057 = FlipkartFaSalesSnapshot()
+            _elem1064 = FlipkartFaSalesSnapshot()
-            _elem1057.read(iprot)
+            _elem1064.read(iprot)
-            self.flipkartfasalessnapshotlist.append(_elem1057)
+            self.flipkartfasalessnapshotlist.append(_elem1064)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('bulkAddOrUpdateFlipkartFaSalesSnapshot_args')
     if self.flipkartfasalessnapshotlist is not None:
       oprot.writeFieldBegin('flipkartfasalessnapshotlist', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.flipkartfasalessnapshotlist))
-      for iter1058 in self.flipkartfasalessnapshotlist:
+      for iter1065 in self.flipkartfasalessnapshotlist:
-        iter1058.write(oprot)
+        iter1065.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype1062, _size1059) = iprot.readListBegin()
+          (_etype1069, _size1066) = iprot.readListBegin()
-          for _i1063 in xrange(_size1059):
+          for _i1070 in xrange(_size1066):
-            _elem1064 = FlipkartFaSalesSnapshot()
+            _elem1071 = FlipkartFaSalesSnapshot()
-            _elem1064.read(iprot)
+            _elem1071.read(iprot)
-            self.success.append(_elem1064)
+            self.success.append(_elem1071)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getFlipkartFaSalesSnapshotForDays_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter1065 in self.success:
+      for iter1072 in self.success:
-        iter1065.write(oprot)
+        iter1072.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == -1:
         if ftype == TType.LIST:
           self.orders = []
-          (_etype1069, _size1066) = iprot.readListBegin()
+          (_etype1076, _size1073) = iprot.readListBegin()
-          for _i1070 in xrange(_size1066):
+          for _i1077 in xrange(_size1073):
-            _elem1071 = iprot.readI64();
+            _elem1078 = iprot.readI64();
-            self.orders.append(_elem1071)
+            self.orders.append(_elem1078)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('acceptPackageOrders_args')
     if self.orders is not None:
       oprot.writeFieldBegin('orders', TType.LIST, -1)
       oprot.writeListBegin(TType.I64, len(self.orders))
-      for iter1072 in self.orders:
+      for iter1079 in self.orders:
-        oprot.writeI64(iter1072)
+        oprot.writeI64(iter1079)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype1076, _size1073) = iprot.readListBegin()
+          (_etype1083, _size1080) = iprot.readListBegin()
-          for _i1077 in xrange(_size1073):
+          for _i1084 in xrange(_size1080):
-            _elem1078 = Order()
+            _elem1085 = Order()
-            _elem1078.read(iprot)
+            _elem1085.read(iprot)
-            self.success.append(_elem1078)
+            self.success.append(_elem1085)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getGroupOrdersByLogisticsTxnId_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter1079 in self.success:
+      for iter1086 in self.success:
-        iter1079.write(oprot)
+        iter1086.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.order_ids = []
-          (_etype1083, _size1080) = iprot.readListBegin()
+          (_etype1090, _size1087) = iprot.readListBegin()
-          for _i1084 in xrange(_size1080):
+          for _i1091 in xrange(_size1087):
-            _elem1085 = iprot.readI64();
+            _elem1092 = iprot.readI64();
-            self.order_ids.append(_elem1085)
+            self.order_ids.append(_elem1092)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.STRING:
         else:
           iprot.skip(ftype)
       elif fid == 3:
         if ftype == TType.MAP:
           self.itemNumbersMap = {}
-          (_ktype1087, _vtype1088, _size1086 ) = iprot.readMapBegin()
+          (_ktype1094, _vtype1095, _size1093 ) = iprot.readMapBegin()
-          for _i1090 in xrange(_size1086):
+          for _i1097 in xrange(_size1093):
-            _key1091 = iprot.readI64();
+            _key1098 = iprot.readI64();
-            _val1092 = []
+            _val1099 = []
-            (_etype1096, _size1093) = iprot.readListBegin()
+            (_etype1103, _size1100) = iprot.readListBegin()
-            for _i1097 in xrange(_size1093):
+            for _i1104 in xrange(_size1100):
-              _elem1098 = iprot.readString();
+              _elem1105 = iprot.readString();
-              _val1092.append(_elem1098)
+              _val1099.append(_elem1105)
             iprot.readListEnd()
-            self.itemNumbersMap[_key1091] = _val1092
+            self.itemNumbersMap[_key1098] = _val1099
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 4:
         if ftype == TType.MAP:
           self.serialNumbersMap = {}
-          (_ktype1100, _vtype1101, _size1099 ) = iprot.readMapBegin()
+          (_ktype1107, _vtype1108, _size1106 ) = iprot.readMapBegin()
-          for _i1103 in xrange(_size1099):
+          for _i1110 in xrange(_size1106):
-            _key1104 = iprot.readI64();
+            _key1111 = iprot.readI64();
-            _val1105 = []
+            _val1112 = []
-            (_etype1109, _size1106) = iprot.readListBegin()
+            (_etype1116, _size1113) = iprot.readListBegin()
-            for _i1110 in xrange(_size1106):
+            for _i1117 in xrange(_size1113):
-              _elem1111 = iprot.readString();
+              _elem1118 = iprot.readString();
-              _val1105.append(_elem1111)
+              _val1112.append(_elem1118)
             iprot.readListEnd()
-            self.serialNumbersMap[_key1104] = _val1105
+            self.serialNumbersMap[_key1111] = _val1112
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 5:
         if ftype == TType.MAP:
           self.freebieWarehouseIdMap = {}
-          (_ktype1113, _vtype1114, _size1112 ) = iprot.readMapBegin()
+          (_ktype1120, _vtype1121, _size1119 ) = iprot.readMapBegin()
-          for _i1116 in xrange(_size1112):
+          for _i1123 in xrange(_size1119):
-            _key1117 = iprot.readI64();
+            _key1124 = iprot.readI64();
-            _val1118 = []
+            _val1125 = []
-            (_etype1122, _size1119) = iprot.readListBegin()
+            (_etype1129, _size1126) = iprot.readListBegin()
-            for _i1123 in xrange(_size1119):
+            for _i1130 in xrange(_size1126):
-              _elem1124 = iprot.readI64();
+              _elem1131 = iprot.readI64();
-              _val1118.append(_elem1124)
+              _val1125.append(_elem1131)
             iprot.readListEnd()
-            self.freebieWarehouseIdMap[_key1117] = _val1118
+            self.freebieWarehouseIdMap[_key1124] = _val1125
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 6:
         if ftype == TType.STRING:
       return
     oprot.writeStructBegin('addBillingDetailsForGrouppedOrders_args')
     if self.order_ids is not None:
       oprot.writeFieldBegin('order_ids', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.order_ids))
-      for iter1125 in self.order_ids:
+      for iter1132 in self.order_ids:
-        oprot.writeI64(iter1125)
+        oprot.writeI64(iter1132)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.invoice_number is not None:
       oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
       oprot.writeString(self.invoice_number)
       oprot.writeFieldEnd()
     if self.itemNumbersMap is not None:
       oprot.writeFieldBegin('itemNumbersMap', TType.MAP, 3)
       oprot.writeMapBegin(TType.I64, TType.LIST, len(self.itemNumbersMap))
-      for kiter1126,viter1127 in self.itemNumbersMap.items():
+      for kiter1133,viter1134 in self.itemNumbersMap.items():
-        oprot.writeI64(kiter1126)
+        oprot.writeI64(kiter1133)
-        oprot.writeListBegin(TType.STRING, len(viter1127))
+        oprot.writeListBegin(TType.STRING, len(viter1134))
-        for iter1128 in viter1127:
+        for iter1135 in viter1134:
-          oprot.writeString(iter1128)
+          oprot.writeString(iter1135)
         oprot.writeListEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.serialNumbersMap is not None:
       oprot.writeFieldBegin('serialNumbersMap', TType.MAP, 4)
       oprot.writeMapBegin(TType.I64, TType.LIST, len(self.serialNumbersMap))
-      for kiter1129,viter1130 in self.serialNumbersMap.items():
+      for kiter1136,viter1137 in self.serialNumbersMap.items():
-        oprot.writeI64(kiter1129)
+        oprot.writeI64(kiter1136)
-        oprot.writeListBegin(TType.STRING, len(viter1130))
+        oprot.writeListBegin(TType.STRING, len(viter1137))
-        for iter1131 in viter1130:
+        for iter1138 in viter1137:
-          oprot.writeString(iter1131)
+          oprot.writeString(iter1138)
         oprot.writeListEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.freebieWarehouseIdMap is not None:
       oprot.writeFieldBegin('freebieWarehouseIdMap', TType.MAP, 5)
       oprot.writeMapBegin(TType.I64, TType.LIST, len(self.freebieWarehouseIdMap))
-      for kiter1132,viter1133 in self.freebieWarehouseIdMap.items():
+      for kiter1139,viter1140 in self.freebieWarehouseIdMap.items():
-        oprot.writeI64(kiter1132)
+        oprot.writeI64(kiter1139)
-        oprot.writeListBegin(TType.I64, len(viter1133))
+        oprot.writeListBegin(TType.I64, len(viter1140))
-        for iter1134 in viter1133:
+        for iter1141 in viter1140:
-          oprot.writeI64(iter1134)
+          oprot.writeI64(iter1141)
         oprot.writeListEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.billed_by is not None:
       oprot.writeFieldBegin('billed_by', TType.STRING, 6)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype1138, _size1135) = iprot.readListBegin()
+          (_etype1145, _size1142) = iprot.readListBegin()
-          for _i1139 in xrange(_size1135):
+          for _i1146 in xrange(_size1142):
-            _elem1140 = HsOrder()
+            _elem1147 = HsOrder()
-            _elem1140.read(iprot)
+            _elem1147.read(iprot)
-            self.success.append(_elem1140)
+            self.success.append(_elem1147)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getHomeShopOrder_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter1141 in self.success:
+      for iter1148 in self.success:
-        iter1141.write(oprot)
+        iter1148.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getCreditorInfo_args:
+  """
+  Attributes:
+   - id
+   - name
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'id', None, None, ), # 1
+    (2, TType.STRING, 'name', None, None, ), # 2
+  )
+  def __init__(self, id=None, name=None,):
+    self.id = id
+    self.name = name
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getCreditorInfo_args')
+    if self.id is not None:
+      oprot.writeFieldBegin('id', TType.I64, 1)
+      oprot.writeI64(self.id)
+      oprot.writeFieldEnd()
+    if self.name is not None:
+      oprot.writeFieldBegin('name', TType.STRING, 2)
+      oprot.writeString(self.name)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getCreditorInfo_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (Creditor, Creditor.thrift_spec), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.STRUCT:
+          self.success = Creditor()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getCreditorInfo_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateCreditorInfo_args:
+  """
+  Attributes:
+   - creditor
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'creditor', (Creditor, Creditor.thrift_spec), None, ), # 1
+  )
+  def __init__(self, creditor=None,):
+    self.creditor = creditor
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.creditor = Creditor()
+          self.creditor.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateCreditorInfo_args')
+    if self.creditor is not None:
+      oprot.writeFieldBegin('creditor', TType.STRUCT, 1)
+      self.creditor.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateCreditorInfo_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateCreditorInfo_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getUserSanctionDetails_args:
+  """
+  Attributes:
+   - userId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'userId', None, None, ), # 1
+  )
+  def __init__(self, userId=None,):
+    self.userId = userId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.userId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getUserSanctionDetails_args')
+    if self.userId is not None:
+      oprot.writeFieldBegin('userId', TType.I64, 1)
+      oprot.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getUserSanctionDetails_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(UserSanction, UserSanction.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype1152, _size1149) = iprot.readListBegin()
+          for _i1153 in xrange(_size1149):
+            _elem1154 = UserSanction()
+            _elem1154.read(iprot)
+            self.success.append(_elem1154)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getUserSanctionDetails_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter1155 in self.success:
+        iter1155.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getUserSanctionDetailsForCreditor_args:
+  """
+  Attributes:
+   - userId
+   - creditorId
+  """
+  thrift_spec = None
+  def __init__(self, userId=None, creditorId=None,):
+    self.userId = userId
+    self.creditorId = creditorId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.userId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == -1:
+        if ftype == TType.I64:
+          self.creditorId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getUserSanctionDetailsForCreditor_args')
+    if self.creditorId is not None:
+      oprot.writeFieldBegin('creditorId', TType.I64, -1)
+      oprot.writeI64(self.creditorId)
+      oprot.writeFieldEnd()
+    if self.userId is not None:
+      oprot.writeFieldBegin('userId', TType.I64, 1)
+      oprot.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getUserSanctionDetailsForCreditor_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (UserSanction, UserSanction.thrift_spec), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.STRUCT:
+          self.success = UserSanction()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getUserSanctionDetailsForCreditor_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateUserSanction_args:
+  """
+  Attributes:
+   - userSanaction
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'userSanaction', (UserSanction, UserSanction.thrift_spec), None, ), # 1
+  )
+  def __init__(self, userSanaction=None,):
+    self.userSanaction = userSanaction
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.userSanaction = UserSanction()
+          self.userSanaction.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateUserSanction_args')
+    if self.userSanaction is not None:
+      oprot.writeFieldBegin('userSanaction', TType.STRUCT, 1)
+      self.userSanaction.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateUserSanction_result:
+  """
+  Attributes:
+   - success
+   - pe
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'pe', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, pe=None,):
+    self.success = success
+    self.pe = pe
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.pe = TransactionServiceException()
+          self.pe.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateUserSanction_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.pe is not None:
+      oprot.writeFieldBegin('pe', TType.STRUCT, 1)
+      self.pe.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getCreditHistoryRecordsForTransaction_args:
+  """
+  Attributes:
+   - paymentId
+   - creditorId
+   - creditTxnType
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'paymentId', None, None, ), # 1
+    (2, TType.I64, 'creditorId', None, None, ), # 2
+    (3, TType.STRING, 'creditTxnType', None, None, ), # 3
+  )
+  def __init__(self, paymentId=None, creditorId=None, creditTxnType=None,):
+    self.paymentId = paymentId
+    self.creditorId = creditorId
+    self.creditTxnType = creditTxnType
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.paymentId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.creditorId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.creditTxnType = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getCreditHistoryRecordsForTransaction_args')
+    if self.paymentId is not None:
+      oprot.writeFieldBegin('paymentId', TType.I64, 1)
+      oprot.writeI64(self.paymentId)
+      oprot.writeFieldEnd()
+    if self.creditorId is not None:
+      oprot.writeFieldBegin('creditorId', TType.I64, 2)
+      oprot.writeI64(self.creditorId)
+      oprot.writeFieldEnd()
+    if self.creditTxnType is not None:
+      oprot.writeFieldBegin('creditTxnType', TType.STRING, 3)
+      oprot.writeString(self.creditTxnType)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getCreditHistoryRecordsForTransaction_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(CreditHistory, CreditHistory.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype1159, _size1156) = iprot.readListBegin()
+          for _i1160 in xrange(_size1156):
+            _elem1161 = CreditHistory()
+            _elem1161.read(iprot)
+            self.success.append(_elem1161)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getCreditHistoryRecordsForTransaction_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter1162 in self.success:
+        iter1162.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getCreditHistoryRecordsForUserAndCreditor_args:
+  """
+  Attributes:
+   - userId
+   - creditTxnType
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'userId', None, None, ), # 1
+    (2, TType.STRING, 'creditTxnType', None, None, ), # 2
+  )
+  def __init__(self, userId=None, creditTxnType=None,):
+    self.userId = userId
+    self.creditTxnType = creditTxnType
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.userId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.creditTxnType = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getCreditHistoryRecordsForUserAndCreditor_args')
+    if self.userId is not None:
+      oprot.writeFieldBegin('userId', TType.I64, 1)
+      oprot.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    if self.creditTxnType is not None:
+      oprot.writeFieldBegin('creditTxnType', TType.STRING, 2)
+      oprot.writeString(self.creditTxnType)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getCreditHistoryRecordsForUserAndCreditor_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(CreditHistory, CreditHistory.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype1166, _size1163) = iprot.readListBegin()
+          for _i1167 in xrange(_size1163):
+            _elem1168 = CreditHistory()
+            _elem1168.read(iprot)
+            self.success.append(_elem1168)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getCreditHistoryRecordsForUserAndCreditor_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter1169 in self.success:
+        iter1169.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class processCreditTransaction_args:
+  """
+  Attributes:
+   - paymentId
+   - creditTxns
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'paymentId', None, None, ), # 1
+    (2, TType.LIST, 'creditTxns', (TType.STRUCT,(CreditHistory, CreditHistory.thrift_spec)), None, ), # 2
+  )
+  def __init__(self, paymentId=None, creditTxns=None,):
+    self.paymentId = paymentId
+    self.creditTxns = creditTxns
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.paymentId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.LIST:
+          self.creditTxns = []
+          (_etype1173, _size1170) = iprot.readListBegin()
+          for _i1174 in xrange(_size1170):
+            _elem1175 = CreditHistory()
+            _elem1175.read(iprot)
+            self.creditTxns.append(_elem1175)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('processCreditTransaction_args')
+    if self.paymentId is not None:
+      oprot.writeFieldBegin('paymentId', TType.I64, 1)
+      oprot.writeI64(self.paymentId)
+      oprot.writeFieldEnd()
+    if self.creditTxns is not None:
+      oprot.writeFieldBegin('creditTxns', TType.LIST, 2)
+      oprot.writeListBegin(TType.STRUCT, len(self.creditTxns))
+      for iter1176 in self.creditTxns:
+        iter1176.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class processCreditTransaction_result:
+  """
+  Attributes:
+   - success
+   - pe
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'pe', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, pe=None,):
+    self.success = success
+    self.pe = pe
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.pe = TransactionServiceException()
+          self.pe.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('processCreditTransaction_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.pe is not None:
+      oprot.writeFieldBegin('pe', TType.STRUCT, 1)
+      self.pe.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getLoanPayableForUserToCreditor_args:
+  """
+  Attributes:
+   - userId
+   - creditorId
+   - dueDate
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'userId', None, None, ), # 1
+    (2, TType.I64, 'creditorId', None, None, ), # 2
+    (3, TType.I64, 'dueDate', None, None, ), # 3
+  )
+  def __init__(self, userId=None, creditorId=None, dueDate=None,):
+    self.userId = userId
+    self.creditorId = creditorId
+    self.dueDate = dueDate
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.userId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.creditorId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
+          self.dueDate = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getLoanPayableForUserToCreditor_args')
+    if self.userId is not None:
+      oprot.writeFieldBegin('userId', TType.I64, 1)
+      oprot.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    if self.creditorId is not None:
+      oprot.writeFieldBegin('creditorId', TType.I64, 2)
+      oprot.writeI64(self.creditorId)
+      oprot.writeFieldEnd()
+    if self.dueDate is not None:
+      oprot.writeFieldBegin('dueDate', TType.I64, 3)
+      oprot.writeI64(self.dueDate)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getLoanPayableForUserToCreditor_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(CreditHistory, CreditHistory.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype1180, _size1177) = iprot.readListBegin()
+          for _i1181 in xrange(_size1177):
+            _elem1182 = CreditHistory()
+            _elem1182.read(iprot)
+            self.success.append(_elem1182)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getLoanPayableForUserToCreditor_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter1183 in self.success:
+        iter1183.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrderInfo_args:
+  """
+  Attributes:
+   - id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'id', None, None, ), # 1
+  )
+  def __init__(self, id=None,):
+    self.id = id
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnOrderInfo_args')
+    if self.id is not None:
+      oprot.writeFieldBegin('id', TType.I64, 1)
+      oprot.writeI64(self.id)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrderInfo_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (ReturnOrderInfo, ReturnOrderInfo.thrift_spec), None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.STRUCT:
+          self.success = ReturnOrderInfo()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnOrderInfo_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrderInfoList_args:
+  """
+  Attributes:
+   - order_ids
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
+  )
+  def __init__(self, order_ids=None,):
+    self.order_ids = order_ids
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.LIST:
+          self.order_ids = []
+          (_etype1187, _size1184) = iprot.readListBegin()
+          for _i1188 in xrange(_size1184):
+            _elem1189 = iprot.readI64();
+            self.order_ids.append(_elem1189)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnOrderInfoList_args')
+    if self.order_ids is not None:
+      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
+      oprot.writeListBegin(TType.I64, len(self.order_ids))
+      for iter1190 in self.order_ids:
+        oprot.writeI64(iter1190)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrderInfoList_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(ReturnOrderInfo, ReturnOrderInfo.thrift_spec))), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.MAP:
+          self.success = {}
+          (_ktype1192, _vtype1193, _size1191 ) = iprot.readMapBegin()
+          for _i1195 in xrange(_size1191):
+            _key1196 = iprot.readI64();
+            _val1197 = []
+            (_etype1201, _size1198) = iprot.readListBegin()
+            for _i1202 in xrange(_size1198):
+              _elem1203 = ReturnOrderInfo()
+              _elem1203.read(iprot)
+              _val1197.append(_elem1203)
+            iprot.readListEnd()
+            self.success[_key1196] = _val1197
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnOrderInfoList_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.MAP, 0)
+      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
+      for kiter1204,viter1205 in self.success.items():
+        oprot.writeI64(kiter1204)
+        oprot.writeListBegin(TType.STRUCT, len(viter1205))
+        for iter1206 in viter1205:
+          iter1206.write(oprot)
+        oprot.writeListEnd()
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrderInfoListAsByStatus_args:
+  """
+  Attributes:
+   - order_ids
+   - statuses
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
+    (2, TType.LIST, 'statuses', (TType.STRING,None), None, ), # 2
+  )
+  def __init__(self, order_ids=None, statuses=None,):
+    self.order_ids = order_ids
+    self.statuses = statuses
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.LIST:
+          self.order_ids = []
+          (_etype1210, _size1207) = iprot.readListBegin()
+          for _i1211 in xrange(_size1207):
+            _elem1212 = iprot.readI64();
+            self.order_ids.append(_elem1212)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.LIST:
+          self.statuses = []
+          (_etype1216, _size1213) = iprot.readListBegin()
+          for _i1217 in xrange(_size1213):
+            _elem1218 = iprot.readString();
+            self.statuses.append(_elem1218)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnOrderInfoListAsByStatus_args')
+    if self.order_ids is not None:
+      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
+      oprot.writeListBegin(TType.I64, len(self.order_ids))
+      for iter1219 in self.order_ids:
+        oprot.writeI64(iter1219)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.statuses is not None:
+      oprot.writeFieldBegin('statuses', TType.LIST, 2)
+      oprot.writeListBegin(TType.STRING, len(self.statuses))
+      for iter1220 in self.statuses:
+        oprot.writeString(iter1220)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrderInfoListAsByStatus_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(ReturnOrderInfo, ReturnOrderInfo.thrift_spec))), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.MAP:
+          self.success = {}
+          (_ktype1222, _vtype1223, _size1221 ) = iprot.readMapBegin()
+          for _i1225 in xrange(_size1221):
+            _key1226 = iprot.readI64();
+            _val1227 = []
+            (_etype1231, _size1228) = iprot.readListBegin()
+            for _i1232 in xrange(_size1228):
+              _elem1233 = ReturnOrderInfo()
+              _elem1233.read(iprot)
+              _val1227.append(_elem1233)
+            iprot.readListEnd()
+            self.success[_key1226] = _val1227
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnOrderInfoListAsByStatus_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.MAP, 0)
+      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
+      for kiter1234,viter1235 in self.success.items():
+        oprot.writeI64(kiter1234)
+        oprot.writeListBegin(TType.STRUCT, len(viter1235))
+        for iter1236 in viter1235:
+          iter1236.write(oprot)
+        oprot.writeListEnd()
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateReturnOrderInfo_args:
+  """
+  Attributes:
+   - returnInfo
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'returnInfo', (ReturnOrderInfo, ReturnOrderInfo.thrift_spec), None, ), # 1
+  )
+  def __init__(self, returnInfo=None,):
+    self.returnInfo = returnInfo
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.returnInfo = ReturnOrderInfo()
+          self.returnInfo.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateReturnOrderInfo_args')
+    if self.returnInfo is not None:
+      oprot.writeFieldBegin('returnInfo', TType.STRUCT, 1)
+      self.returnInfo.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateReturnOrderInfo_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateReturnOrderInfo_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class bulkUpdateReturnOrderInfo_args:
+  """
+  Attributes:
+   - orderReturnInfosMap
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.MAP, 'orderReturnInfosMap', (TType.I64,None,TType.LIST,(TType.STRUCT,(ReturnOrderInfo, ReturnOrderInfo.thrift_spec))), None, ), # 1
+  )
+  def __init__(self, orderReturnInfosMap=None,):
+    self.orderReturnInfosMap = orderReturnInfosMap
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.MAP:
+          self.orderReturnInfosMap = {}
+          (_ktype1238, _vtype1239, _size1237 ) = iprot.readMapBegin()
+          for _i1241 in xrange(_size1237):
+            _key1242 = iprot.readI64();
+            _val1243 = []
+            (_etype1247, _size1244) = iprot.readListBegin()
+            for _i1248 in xrange(_size1244):
+              _elem1249 = ReturnOrderInfo()
+              _elem1249.read(iprot)
+              _val1243.append(_elem1249)
+            iprot.readListEnd()
+            self.orderReturnInfosMap[_key1242] = _val1243
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('bulkUpdateReturnOrderInfo_args')
+    if self.orderReturnInfosMap is not None:
+      oprot.writeFieldBegin('orderReturnInfosMap', TType.MAP, 1)
+      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.orderReturnInfosMap))
+      for kiter1250,viter1251 in self.orderReturnInfosMap.items():
+        oprot.writeI64(kiter1250)
+        oprot.writeListBegin(TType.STRUCT, len(viter1251))
+        for iter1252 in viter1251:
+          iter1252.write(oprot)
+        oprot.writeListEnd()
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class bulkUpdateReturnOrderInfo_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.MAP:
+          self.success = {}
+          (_ktype1254, _vtype1255, _size1253 ) = iprot.readMapBegin()
+          for _i1257 in xrange(_size1253):
+            _key1258 = iprot.readI64();
+            _val1259 = iprot.readBool();
+            self.success[_key1258] = _val1259
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('bulkUpdateReturnOrderInfo_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.MAP, 0)
+      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
+      for kiter1260,viter1261 in self.success.items():
+        oprot.writeI64(kiter1260)
+        oprot.writeBool(viter1261)
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrdersAsPerWarehouseId_args:
+  """
+  Attributes:
+   - warehouseId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'warehouseId', None, None, ), # 1
+  )
+  def __init__(self, warehouseId=None,):
+    self.warehouseId = warehouseId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.warehouseId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnOrdersAsPerWarehouseId_args')
+    if self.warehouseId is not None:
+      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
+      oprot.writeI64(self.warehouseId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrdersAsPerWarehouseId_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrderInfo, ReturnOrderInfo.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype1265, _size1262) = iprot.readListBegin()
+          for _i1266 in xrange(_size1262):
+            _elem1267 = ReturnOrderInfo()
+            _elem1267.read(iprot)
+            self.success.append(_elem1267)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnOrdersAsPerWarehouseId_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter1268 in self.success:
+        iter1268.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class createReturnTransaction_args:
+  """
+  Attributes:
+   - returnTransaction
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'returnTransaction', (ReturnTransaction, ReturnTransaction.thrift_spec), None, ), # 1
+  )
+  def __init__(self, returnTransaction=None,):
+    self.returnTransaction = returnTransaction
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.returnTransaction = ReturnTransaction()
+          self.returnTransaction.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('createReturnTransaction_args')
+    if self.returnTransaction is not None:
+      oprot.writeFieldBegin('returnTransaction', TType.STRUCT, 1)
+      self.returnTransaction.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class createReturnTransaction_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.I64, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.I64:
+          self.success = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('createReturnTransaction_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.I64, 0)
+      oprot.writeI64(self.success)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnTransaction_args:
+  """
+  Attributes:
+   - id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'id', None, None, ), # 1
+  )
+  def __init__(self, id=None,):
+    self.id = id
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnTransaction_args')
+    if self.id is not None:
+      oprot.writeFieldBegin('id', TType.I64, 1)
+      oprot.writeI64(self.id)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnTransaction_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (ReturnTransaction, ReturnTransaction.thrift_spec), None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.STRUCT:
+          self.success = ReturnTransaction()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnTransaction_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrdersForReturnTransaction_args:
+  """
+  Attributes:
+   - returnTransactionId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'returnTransactionId', None, None, ), # 1
+  )
+  def __init__(self, returnTransactionId=None,):
+    self.returnTransactionId = returnTransactionId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.returnTransactionId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnOrdersForReturnTransaction_args')
+    if self.returnTransactionId is not None:
+      oprot.writeFieldBegin('returnTransactionId', TType.I64, 1)
+      oprot.writeI64(self.returnTransactionId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrdersForReturnTransaction_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrderInfo, ReturnOrderInfo.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype1272, _size1269) = iprot.readListBegin()
+          for _i1273 in xrange(_size1269):
+            _elem1274 = ReturnOrderInfo()
+            _elem1274.read(iprot)
+            self.success.append(_elem1274)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnOrdersForReturnTransaction_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter1275 in self.success:
+        iter1275.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class changeReturnTransactionStatus_args:
+  """
+  Attributes:
+   - returnTransactionId
+   - status
+   - returnOrderIds
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'returnTransactionId', None, None, ), # 1
+    (2, TType.I32, 'status', None, None, ), # 2
+    (3, TType.LIST, 'returnOrderIds', (TType.I64,None), None, ), # 3
+  )
+  def __init__(self, returnTransactionId=None, status=None, returnOrderIds=None,):
+    self.returnTransactionId = returnTransactionId
+    self.status = status
+    self.returnOrderIds = returnOrderIds
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.returnTransactionId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I32:
+          self.status = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.LIST:
+          self.returnOrderIds = []
+          (_etype1279, _size1276) = iprot.readListBegin()
+          for _i1280 in xrange(_size1276):
+            _elem1281 = iprot.readI64();
+            self.returnOrderIds.append(_elem1281)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('changeReturnTransactionStatus_args')
+    if self.returnTransactionId is not None:
+      oprot.writeFieldBegin('returnTransactionId', TType.I64, 1)
+      oprot.writeI64(self.returnTransactionId)
+      oprot.writeFieldEnd()
+    if self.status is not None:
+      oprot.writeFieldBegin('status', TType.I32, 2)
+      oprot.writeI32(self.status)
+      oprot.writeFieldEnd()
+    if self.returnOrderIds is not None:
+      oprot.writeFieldBegin('returnOrderIds', TType.LIST, 3)
+      oprot.writeListBegin(TType.I64, len(self.returnOrderIds))
+      for iter1282 in self.returnOrderIds:
+        oprot.writeI64(iter1282)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class changeReturnTransactionStatus_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('changeReturnTransactionStatus_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class createReturnPickupRequest_args:
+  """
+  Attributes:
+   - returnOrderIds
+   - providerId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'returnOrderIds', (TType.I64,None), None, ), # 1
+    (2, TType.I64, 'providerId', None, None, ), # 2
+  )
+  def __init__(self, returnOrderIds=None, providerId=None,):
+    self.returnOrderIds = returnOrderIds
+    self.providerId = providerId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.LIST:
+          self.returnOrderIds = []
+          (_etype1286, _size1283) = iprot.readListBegin()
+          for _i1287 in xrange(_size1283):
+            _elem1288 = iprot.readI64();
+            self.returnOrderIds.append(_elem1288)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('createReturnPickupRequest_args')
+    if self.returnOrderIds is not None:
+      oprot.writeFieldBegin('returnOrderIds', TType.LIST, 1)
+      oprot.writeListBegin(TType.I64, len(self.returnOrderIds))
+      for iter1289 in self.returnOrderIds:
+        oprot.writeI64(iter1289)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.providerId is not None:
+      oprot.writeFieldBegin('providerId', TType.I64, 2)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class createReturnPickupRequest_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('createReturnPickupRequest_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateReturnPickupRequest_args:
+  """
+  Attributes:
+   - returnPickupRequest
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'returnPickupRequest', (ReturnPickupRequest, ReturnPickupRequest.thrift_spec), None, ), # 1
+  )
+  def __init__(self, returnPickupRequest=None,):
+    self.returnPickupRequest = returnPickupRequest
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.returnPickupRequest = ReturnPickupRequest()
+          self.returnPickupRequest.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateReturnPickupRequest_args')
+    if self.returnPickupRequest is not None:
+      oprot.writeFieldBegin('returnPickupRequest', TType.STRUCT, 1)
+      self.returnPickupRequest.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateReturnPickupRequest_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateReturnPickupRequest_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getAllReturnOrdersForReturnPickupRequest_args:
+  """
+  Attributes:
+   - logisticsRequestId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'logisticsRequestId', None, None, ), # 1
+  )
+  def __init__(self, logisticsRequestId=None,):
+    self.logisticsRequestId = logisticsRequestId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.logisticsRequestId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getAllReturnOrdersForReturnPickupRequest_args')
+    if self.logisticsRequestId is not None:
+      oprot.writeFieldBegin('logisticsRequestId', TType.I64, 1)
+      oprot.writeI64(self.logisticsRequestId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getAllReturnOrdersForReturnPickupRequest_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrderInfo, ReturnOrderInfo.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype1293, _size1290) = iprot.readListBegin()
+          for _i1294 in xrange(_size1290):
+            _elem1295 = ReturnOrderInfo()
+            _elem1295.read(iprot)
+            self.success.append(_elem1295)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getAllReturnOrdersForReturnPickupRequest_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter1296 in self.success:
+        iter1296.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class receiveReturnPickup_args:
+  """
+  Attributes:
+   - returnOrdersMap
+   - id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.MAP, 'returnOrdersMap', (TType.I64,None,TType.MAP,(TType.STRING,None,TType.STRING,None)), None, ), # 1
+    (2, TType.I64, 'id', None, None, ), # 2
+  )
+  def __init__(self, returnOrdersMap=None, id=None,):
+    self.returnOrdersMap = returnOrdersMap
+    self.id = id
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.MAP:
+          self.returnOrdersMap = {}
+          (_ktype1298, _vtype1299, _size1297 ) = iprot.readMapBegin()
+          for _i1301 in xrange(_size1297):
+            _key1302 = iprot.readI64();
+            _val1303 = {}
+            (_ktype1305, _vtype1306, _size1304 ) = iprot.readMapBegin()
+            for _i1308 in xrange(_size1304):
+              _key1309 = iprot.readString();
+              _val1310 = iprot.readString();
+              _val1303[_key1309] = _val1310
+            iprot.readMapEnd()
+            self.returnOrdersMap[_key1302] = _val1303
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('receiveReturnPickup_args')
+    if self.returnOrdersMap is not None:
+      oprot.writeFieldBegin('returnOrdersMap', TType.MAP, 1)
+      oprot.writeMapBegin(TType.I64, TType.MAP, len(self.returnOrdersMap))
+      for kiter1311,viter1312 in self.returnOrdersMap.items():
+        oprot.writeI64(kiter1311)
+        oprot.writeMapBegin(TType.STRING, TType.STRING, len(viter1312))
+        for kiter1313,viter1314 in viter1312.items():
+          oprot.writeString(kiter1313)
+          oprot.writeString(viter1314)
+        oprot.writeMapEnd()
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    if self.id is not None:
+      oprot.writeFieldBegin('id', TType.I64, 2)
+      oprot.writeI64(self.id)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class receiveReturnPickup_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('receiveReturnPickup_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class validateReturnPickup_args:
+  """
+  Attributes:
+   - returnPickupId
+   - returnOrdersMap
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'returnPickupId', None, None, ), # 1
+    (2, TType.MAP, 'returnOrdersMap', (TType.I64,None,TType.BOOL,None), None, ), # 2
+  )
+  def __init__(self, returnPickupId=None, returnOrdersMap=None,):
+    self.returnPickupId = returnPickupId
+    self.returnOrdersMap = returnOrdersMap
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.returnPickupId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.MAP:
+          self.returnOrdersMap = {}
+          (_ktype1316, _vtype1317, _size1315 ) = iprot.readMapBegin()
+          for _i1319 in xrange(_size1315):
+            _key1320 = iprot.readI64();
+            _val1321 = iprot.readBool();
+            self.returnOrdersMap[_key1320] = _val1321
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('validateReturnPickup_args')
+    if self.returnPickupId is not None:
+      oprot.writeFieldBegin('returnPickupId', TType.I64, 1)
+      oprot.writeI64(self.returnPickupId)
+      oprot.writeFieldEnd()
+    if self.returnOrdersMap is not None:
+      oprot.writeFieldBegin('returnOrdersMap', TType.MAP, 2)
+      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.returnOrdersMap))
+      for kiter1322,viter1323 in self.returnOrdersMap.items():
+        oprot.writeI64(kiter1322)
+        oprot.writeBool(viter1323)
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class validateReturnPickup_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('validateReturnPickup_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class processReturnPickup_args:
+  """
+  Attributes:
+   - returnPickupId
+   - returnOrdersMap
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'returnPickupId', None, None, ), # 1
+    (2, TType.MAP, 'returnOrdersMap', (TType.I64,None,TType.MAP,(TType.STRING,None,TType.STRING,None)), None, ), # 2
+  )
+  def __init__(self, returnPickupId=None, returnOrdersMap=None,):
+    self.returnPickupId = returnPickupId
+    self.returnOrdersMap = returnOrdersMap
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.returnPickupId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.MAP:
+          self.returnOrdersMap = {}
+          (_ktype1325, _vtype1326, _size1324 ) = iprot.readMapBegin()
+          for _i1328 in xrange(_size1324):
+            _key1329 = iprot.readI64();
+            _val1330 = {}
+            (_ktype1332, _vtype1333, _size1331 ) = iprot.readMapBegin()
+            for _i1335 in xrange(_size1331):
+              _key1336 = iprot.readString();
+              _val1337 = iprot.readString();
+              _val1330[_key1336] = _val1337
+            iprot.readMapEnd()
+            self.returnOrdersMap[_key1329] = _val1330
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('processReturnPickup_args')
+    if self.returnPickupId is not None:
+      oprot.writeFieldBegin('returnPickupId', TType.I64, 1)
+      oprot.writeI64(self.returnPickupId)
+      oprot.writeFieldEnd()
+    if self.returnOrdersMap is not None:
+      oprot.writeFieldBegin('returnOrdersMap', TType.MAP, 2)
+      oprot.writeMapBegin(TType.I64, TType.MAP, len(self.returnOrdersMap))
+      for kiter1338,viter1339 in self.returnOrdersMap.items():
+        oprot.writeI64(kiter1338)
+        oprot.writeMapBegin(TType.STRING, TType.STRING, len(viter1339))
+        for kiter1340,viter1341 in viter1339.items():
+          oprot.writeString(kiter1340)
+          oprot.writeString(viter1341)
+        oprot.writeMapEnd()
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class processReturnPickup_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('processReturnPickup_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class markReturnTransactionComplete_args:
+  """
+  Attributes:
+   - returnTransactionId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'returnTransactionId', None, None, ), # 1
+  )
+  def __init__(self, returnTransactionId=None,):
+    self.returnTransactionId = returnTransactionId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.returnTransactionId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('markReturnTransactionComplete_args')
+    if self.returnTransactionId is not None:
+      oprot.writeFieldBegin('returnTransactionId', TType.I64, 1)
+      oprot.writeI64(self.returnTransactionId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class markReturnTransactionComplete_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('markReturnTransactionComplete_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class refundReturnTransactionPayment_args:
+  """
+  Attributes:
+   - refundOrdersMap
+   - returntransactionId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.MAP, 'refundOrdersMap', (TType.I64,None,TType.MAP,(TType.STRING,None,TType.STRING,None)), None, ), # 1
+    (2, TType.I64, 'returntransactionId', None, None, ), # 2
+  )
+  def __init__(self, refundOrdersMap=None, returntransactionId=None,):
+    self.refundOrdersMap = refundOrdersMap
+    self.returntransactionId = returntransactionId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.MAP:
+          self.refundOrdersMap = {}
+          (_ktype1343, _vtype1344, _size1342 ) = iprot.readMapBegin()
+          for _i1346 in xrange(_size1342):
+            _key1347 = iprot.readI64();
+            _val1348 = {}
+            (_ktype1350, _vtype1351, _size1349 ) = iprot.readMapBegin()
+            for _i1353 in xrange(_size1349):
+              _key1354 = iprot.readString();
+              _val1355 = iprot.readString();
+              _val1348[_key1354] = _val1355
+            iprot.readMapEnd()
+            self.refundOrdersMap[_key1347] = _val1348
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.returntransactionId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('refundReturnTransactionPayment_args')
+    if self.refundOrdersMap is not None:
+      oprot.writeFieldBegin('refundOrdersMap', TType.MAP, 1)
+      oprot.writeMapBegin(TType.I64, TType.MAP, len(self.refundOrdersMap))
+      for kiter1356,viter1357 in self.refundOrdersMap.items():
+        oprot.writeI64(kiter1356)
+        oprot.writeMapBegin(TType.STRING, TType.STRING, len(viter1357))
+        for kiter1358,viter1359 in viter1357.items():
+          oprot.writeString(kiter1358)
+          oprot.writeString(viter1359)
+        oprot.writeMapEnd()
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    if self.returntransactionId is not None:
+      oprot.writeFieldBegin('returntransactionId', TType.I64, 2)
+      oprot.writeI64(self.returntransactionId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class refundReturnTransactionPayment_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('refundReturnTransactionPayment_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnTransactionsForCustomer_args:
+  """
+  Attributes:
+   - statusList
+   - customerMobile
+   - customerEmail
+   - returnTransactionId
+   - customerId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'statusList', (TType.I32,None), None, ), # 1
+    (2, TType.STRING, 'customerMobile', None, None, ), # 2
+    (3, TType.STRING, 'customerEmail', None, None, ), # 3
+    (4, TType.I64, 'returnTransactionId', None, None, ), # 4
+    (5, TType.I64, 'customerId', None, None, ), # 5
+  )
+  def __init__(self, statusList=None, customerMobile=None, customerEmail=None, returnTransactionId=None, customerId=None,):
+    self.statusList = statusList
+    self.customerMobile = customerMobile
+    self.customerEmail = customerEmail
+    self.returnTransactionId = returnTransactionId
+    self.customerId = customerId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.LIST:
+          self.statusList = []
+          (_etype1363, _size1360) = iprot.readListBegin()
+          for _i1364 in xrange(_size1360):
+            _elem1365 = iprot.readI32();
+            self.statusList.append(_elem1365)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.customerMobile = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.customerEmail = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.I64:
+          self.returnTransactionId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.I64:
+          self.customerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnTransactionsForCustomer_args')
+    if self.statusList is not None:
+      oprot.writeFieldBegin('statusList', TType.LIST, 1)
+      oprot.writeListBegin(TType.I32, len(self.statusList))
+      for iter1366 in self.statusList:
+        oprot.writeI32(iter1366)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.customerMobile is not None:
+      oprot.writeFieldBegin('customerMobile', TType.STRING, 2)
+      oprot.writeString(self.customerMobile)
+      oprot.writeFieldEnd()
+    if self.customerEmail is not None:
+      oprot.writeFieldBegin('customerEmail', TType.STRING, 3)
+      oprot.writeString(self.customerEmail)
+      oprot.writeFieldEnd()
+    if self.returnTransactionId is not None:
+      oprot.writeFieldBegin('returnTransactionId', TType.I64, 4)
+      oprot.writeI64(self.returnTransactionId)
+      oprot.writeFieldEnd()
+    if self.customerId is not None:
+      oprot.writeFieldBegin('customerId', TType.I64, 5)
+      oprot.writeI64(self.customerId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnTransactionsForCustomer_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnTransaction, ReturnTransaction.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype1370, _size1367) = iprot.readListBegin()
+          for _i1371 in xrange(_size1367):
+            _elem1372 = ReturnTransaction()
+            _elem1372.read(iprot)
+            self.success.append(_elem1372)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnTransactionsForCustomer_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter1373 in self.success:
+        iter1373.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class verifyOrderForTransaction_args:
+  """
+  Attributes:
+   - transactionId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'transactionId', None, None, ), # 1
+  )
+  def __init__(self, transactionId=None,):
+    self.transactionId = transactionId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.transactionId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('verifyOrderForTransaction_args')
+    if self.transactionId is not None:
+      oprot.writeFieldBegin('transactionId', TType.I64, 1)
+      oprot.writeI64(self.transactionId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class verifyOrderForTransaction_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('verifyOrderForTransaction_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
     return
   def __repr__(self):
     L = ['%s=%r' % (key, value)

Subversion Repositories SmartDukaan

(root)/trunk/PyProj/src/shop2020/thriftpy/model/v1/order/TransactionService.py – Rev 18041 → 18578