Subversion Repositories SmartDukaan

#
# Autogenerated by Thrift Compiler (0.7.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#

from thrift.Thrift import *
import shop2020.thriftpy.generic.GenericService
from ttypes import *
from thrift.Thrift import TProcessor
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol, TProtocol
try:
  from thrift.protocol import fastbinary
except:
  fastbinary = None


class Iface(shop2020.thriftpy.generic.GenericService.Iface):
  def getInventoryItem(self, serialNumber):
    """
    Retrieves serialized inventory item given a serial number

    Parameters:
     - serialNumber
    """
    pass

  def getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId, billingWarehouseId):
    """
    Retrieves non-serialized inventory item from a given supplier

    Parameters:
     - itemNumber
     - itemId
     - fulfilmentWarehouseId
     - billingWarehouseId
    """
    pass

  def scan(self, inventoryItem, type, quantity, billingWarehouseId, transferLotId):
    """
    Scan non-serialized items.

    Parameters:
     - inventoryItem
     - type
     - quantity
     - billingWarehouseId
     - transferLotId
    """
    pass

  def genericScan(self, inventoryItem, scan):
    """
    Scan non-serialized items.

    Parameters:
     - inventoryItem
     - scan
    """
    pass

  def scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
    """
    Scan serialized items linked with an order. Returns its price.

    Parameters:
     - serialNumber
     - type
     - orderId
     - fulfilmentWarehouseId
     - quantity
     - billingWarehouseId
    """
    pass

  def scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
    """
    Scan non-serialized items linked with an order.

    Parameters:
     - inventoryItem
     - type
     - quantity
     - orderId
     - fulfilmentWarehouseId
     - billingWarehouseId
    """
    pass

  def createItemNumberMapping(self, itemNumber, itemId):
    """
    Created item number to item id mapping

    Parameters:
     - itemNumber
     - itemId
    """
    pass

  def getItemNumbers(self, itemId):
    """
    Get itemNumber mappings for itemId

    Parameters:
     - itemId
    """
    pass

  def getItemIds(self, itemNumber):
    """
    Gets item ids for a given item number

    Parameters:
     - itemNumber
    """
    pass

  def getInventoryItemsFromLastScanType(self, lastScanType):
    """
    Retrieves all inventory items given a last scan type

    Parameters:
     - lastScanType
    """
    pass

  def getInventoryItemFromId(self, inventoryItemId):
    """
    Retrieves inventory item given a inventoryItem id

    Parameters:
     - inventoryItemId
    """
    pass

  def getPurchaseScans(self, startDate, endDate):
    """
    Returns the purchase scans grouped by items for Purchase register reconciliation

    Parameters:
     - startDate
     - endDate
    """
    pass

  def getPurchaseScansByGrnDate(self, startDate, endDate):
    """
    Returns the purchase scans between grn dates grouped by items for Purchase register reconciliation

    Parameters:
     - startDate
     - endDate
    """
    pass

  def getEmptyGrnsByDate(self, startDate, endDate):
    """
    Returns the empty grn-ids between grn dates

    Parameters:
     - startDate
     - endDate
    """
    pass

  def fetchScansPerInvoiceNumber(self, date):
    """
    Returns the invoices and the count of scans against on a given day.

    Parameters:
     - date
    """
    pass

  def getInventoryItemFromOrder(self, orderId):
    """
    Returns inventory item for a given order

    Parameters:
     - orderId
    """
    pass

  def getInventoryAge(self, ):
    """
    Fetches the stock inventory age week-wise
    """
    pass

  def getInventoryScansForItem(self, itemId, fromDate, toDate):
    """
    Fetches the scanRecords for a given item for a given time interval

    Parameters:
     - itemId
     - fromDate
     - toDate
    """
    pass

  def getScanRecordsForSerialNumber(self, serialNumber):
    """
    Fetches the scanRecords for a given serialNumber for a given time interval

    Parameters:
     - serialNumber
    """
    pass

  def scanForPurchaseReturn(self, saleReturnItems, vendorId, billingWarehouseId):
    """
    Inserts outgoing scans for Returned Items and updates returnId in InventoryItems

    Parameters:
     - saleReturnItems
     - vendorId
     - billingWarehouseId
    """
    pass

  def scanForLostItem(self, lostItems, vendorId, billingWarehouseId):
    """
    Inserts scans for lost Items and updates lastScanType in InventoryItems

    Parameters:
     - lostItems
     - vendorId
     - billingWarehouseId
    """
    pass

  def getCurrentSerializedInventoryByScans(self, physicalWarehouseId):
    """
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table

    Parameters:
     - physicalWarehouseId
    """
    pass

  def getCurrentNonSerializedInventoryByScans(self, physicalWarehouseId):
    """
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table

    Parameters:
     - physicalWarehouseId
    """
    pass

  def getHistoricSerializedInventoryByScans(self, date):
    """
    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table

    Parameters:
     - date
    """
    pass

  def getHistoricNonSerializedInventoryByScans(self, date):
    """
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table

    Parameters:
     - date
    """
    pass

  def getOurHistoricSerializedInventoryByScans(self, date):
    """
    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table

    Parameters:
     - date
    """
    pass

  def getOurHistoricNonSerializedInventoryByScans(self, date):
    """
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table

    Parameters:
     - date
    """
    pass

  def scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, nlc, orderId):
    """
    Insert Purchase/Sale Entries for product billed by Hotspot using OURS_EXTERNAL Billing

    Parameters:
     - itemId
     - serialNumber
     - itemNumber
     - invoiceNumber
     - warehouseId
     - unitPrice
     - nlc
     - orderId
    """
    pass

  def scanForOursExternalSaleReturn(self, orderId, unitPrice):
    """
    Insert Purchase_Ret/Sale_Ret Entries for product billed by Hotspot using OURS_EXTERNAL Billing

    Parameters:
     - orderId
     - unitPrice
    """
    pass

  def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
    """
    This returns movement for each non serialized item in the specified window.(Doesn't include Hotspot and Amazon w/h)

    Parameters:
     - startDate
     - endDate
    """
    pass

  def getMovementSerializedInventoryByScans(self, startDate, endDate):
    """
    This returns movement for each serialized item in the specified window.(Doesn't include Hotspot and Amazon w/h)

    Parameters:
     - startDate
     - endDate
    """
    pass

  def getCompleteMovementSerializedInventoryByScans(self, startDate, endDate):
    """
    This returns movement for each serialized item in the specified window.(Doesn't include Amazon w/h)

    Parameters:
     - startDate
     - endDate
    """
    pass

  def getCompleteMovementNonSerializedInventoryByScans(self, startDate, endDate):
    """
    This returns movement for each non serialized item in the specified window.(Doesn't include Amazon w/h)

    Parameters:
     - startDate
     - endDate
    """
    pass

  def scanfreebie(self, orderId, freebieItemId, freebieWarehouseId, scanType):
    """
    Parameters:
     - orderId
     - freebieItemId
     - freebieWarehouseId
     - scanType
    """
    pass

  def reshipfreebie(self, oldOrderId, newOrderId, freebieItemId, scanType):
    """
    Parameters:
     - oldOrderId
     - newOrderId
     - freebieItemId
     - scanType
    """
    pass

  def isItemTransferAllowed(self, warehouseId, transferWarehouseId):
    """
    Parameters:
     - warehouseId
     - transferWarehouseId
    """
    pass

  def createTransferLot(self, originWarehouseId, destWarehouseId):
    """
    Parameters:
     - originWarehouseId
     - destWarehouseId
    """
    pass

  def getTransferLot(self, transferLotId):
    """
    Parameters:
     - transferLotId
    """
    pass

  def markTransferLotAsReceived(self, id, remoteTransferRefNumber):
    """
    Parameters:
     - id
     - remoteTransferRefNumber
    """
    pass

  def getTransferLotsByDate(self, fromDate, toDate):
    """
    Parameters:
     - fromDate
     - toDate
    """
    pass

  def getAllowedDestinationWarehousesForTransfer(self, warehouseId):
    """
    Parameters:
     - warehouseId
    """
    pass

  def getItemsInTransferLot(self, transferLotId):
    """
    Parameters:
     - transferLotId
    """
    pass

  def markItemsAsReceivedForTransferLot(self, id):
    """
    Parameters:
     - id
    """
    pass

  def updateTransferLotAfterItemReceive(self, id):
    """
    Parameters:
     - id
    """
    pass

  def scanForTransferOut(self, inventoryItems, type, transferLotId):
    """
    Parameters:
     - inventoryItems
     - type
     - transferLotId
    """
    pass

  def scanForTransferIn(self, inventoryItems, type, transferLotId):
    """
    Parameters:
     - inventoryItems
     - type
     - transferLotId
    """
    pass

  def scanForOursThirdPartyReceive(self, inventoryItems, id):
    """
    Parameters:
     - inventoryItems
     - id
    """
    pass

  def getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(self, itemId, physicalWarehouseId):
    """
    Parameters:
     - itemId
     - physicalWarehouseId
    """
    pass

  def getInTransitInventory(self, originWarehouseId):
    """
    Parameters:
     - originWarehouseId
    """
    pass

  def isItemAvailableForSale(self, itemId, serialNumber, warehouseId):
    """
    Parameters:
     - itemId
     - serialNumber
     - warehouseId
    """
    pass

  def getHistoricBadInventoryByScans(self, date):
    """
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table

    Parameters:
     - date
    """
    pass

  def scanForBadSale(self, serialNumber, itemNumber, itemId, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
    """
    Parameters:
     - serialNumber
     - itemNumber
     - itemId
     - orderId
     - fulfilmentWarehouseId
     - quantity
     - billingWarehouseId
    """
    pass

  def getTransferLotItemsForMarkReceive(self, transferLotId, scanType):
    """
    Parameters:
     - transferLotId
     - scanType
    """
    pass

  def markItemsAsReceivedForTransferLotPartial(self, inventoryItems, transferLotId):
    """
    Parameters:
     - inventoryItems
     - transferLotId
    """
    pass

  def markTransferLotAsReceivedPartial(self, id, remoteTransferRefNumber):
    """
    Parameters:
     - id
     - remoteTransferRefNumber
    """
    pass

  def getInventoryItemScannedInForPO(self, itemId, purchaseIds):
    """
    Parameters:
     - itemId
     - purchaseIds
    """
    pass

  def getAmazonTransferredSkuDetails(self, itemIds):
    """
    Parameters:
     - itemIds
    """
    pass

  def getScansforPurchase(self, purchaseId, scanType):
    """
    Parameters:
     - purchaseId
     - scanType
    """
    pass

  def getCurrentBadQuantityForItem(self, itemId, currentWarehouseId, physicalWarehouseId):
    """
    Parameters:
     - itemId
     - currentWarehouseId
     - physicalWarehouseId
    """
    pass

  def scanForBadPurchaseReturn(self, saleReturnItems, vendorId, billingWarehouseId):
    """
    Parameters:
     - saleReturnItems
     - vendorId
     - billingWarehouseId
    """
    pass

  def getItemsInPurchaseReturn(self, purchaseReturnId, type, returnTime):
    """
    Parameters:
     - purchaseReturnId
     - type
     - returnTime
    """
    pass

  def getScansForInventoryItem(self, inventoryItemId, type):
    """
    Parameters:
     - inventoryItemId
     - type
    """
    pass

  def checkGrnImeiStatus(self, imeiNos):
    """
    Parameters:
     - imeiNos
    """
    pass

  def getInventoryAgeConsideredItems(self, itemId):
    """
    Parameters:
     - itemId
    """
    pass

  def getCompleteMovementForThirdPartyWarehouse(self, startDate, endDate):
    """
    Parameters:
     - startDate
     - endDate
    """
    pass

  def getAllDoaOutInventoryItems(self, ):
    pass

  def getAllUnCompletedStockShipments(self, source):
    """
    Parameters:
     - source
    """
    pass

  def getRemovalStockShipmentReferenceById(self, id):
    """
    Parameters:
     - id
    """
    pass

  def createRemovalStockShipmentReference(self, removalStockShipmentReference):
    """
    Parameters:
     - removalStockShipmentReference
    """
    pass

  def updateShipmentReferenceTransferLot(self, transferLotId, shipmentReferenceId):
    """
    Parameters:
     - transferLotId
     - shipmentReferenceId
    """
    pass

  def fetchScansPerTransferInvoiceNumber(self, date):
    """
    Returns the shipment references and the count of scans against on a given day.

    Parameters:
     - date
    """
    pass

  def getInventoryItems(self, serialNumbers):
    """
    Parameters:
     - serialNumbers
    """
    pass

  def getInventoryItemsBySerailNumbers(self, serialNumbers):
    """
    Parameters:
     - serialNumbers
    """
    pass

  def scanPurchaseBulk(self, inventoryItems):
    """
    Parameters:
     - inventoryItems
    """
    pass


class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
  def __init__(self, iprot, oprot=None):
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)

  def getInventoryItem(self, serialNumber):
    """
    Retrieves serialized inventory item given a serial number

    Parameters:
     - serialNumber
    """
    self.send_getInventoryItem(serialNumber)
    return self.recv_getInventoryItem()

  def send_getInventoryItem(self, serialNumber):
    self._oprot.writeMessageBegin('getInventoryItem', TMessageType.CALL, self._seqid)
    args = getInventoryItem_args()
    args.serialNumber = serialNumber
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInventoryItem(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInventoryItem_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItem failed: unknown result");

  def getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId, billingWarehouseId):
    """
    Retrieves non-serialized inventory item from a given supplier

    Parameters:
     - itemNumber
     - itemId
     - fulfilmentWarehouseId
     - billingWarehouseId
    """
    self.send_getNonSeralizedInventoryItem(itemNumber, itemId, fulfilmentWarehouseId, billingWarehouseId)
    return self.recv_getNonSeralizedInventoryItem()

  def send_getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId, billingWarehouseId):
    self._oprot.writeMessageBegin('getNonSeralizedInventoryItem', TMessageType.CALL, self._seqid)
    args = getNonSeralizedInventoryItem_args()
    args.itemNumber = itemNumber
    args.itemId = itemId
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
    args.billingWarehouseId = billingWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getNonSeralizedInventoryItem(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getNonSeralizedInventoryItem_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonSeralizedInventoryItem failed: unknown result");

  def scan(self, inventoryItem, type, quantity, billingWarehouseId, transferLotId):
    """
    Scan non-serialized items.

    Parameters:
     - inventoryItem
     - type
     - quantity
     - billingWarehouseId
     - transferLotId
    """
    self.send_scan(inventoryItem, type, quantity, billingWarehouseId, transferLotId)
    self.recv_scan()

  def send_scan(self, inventoryItem, type, quantity, billingWarehouseId, transferLotId):
    self._oprot.writeMessageBegin('scan', TMessageType.CALL, self._seqid)
    args = scan_args()
    args.inventoryItem = inventoryItem
    args.type = type
    args.quantity = quantity
    args.billingWarehouseId = billingWarehouseId
    args.transferLotId = transferLotId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scan(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scan_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.wex is not None:
      raise result.wex
    return

  def genericScan(self, inventoryItem, scan):
    """
    Scan non-serialized items.

    Parameters:
     - inventoryItem
     - scan
    """
    self.send_genericScan(inventoryItem, scan)
    self.recv_genericScan()

  def send_genericScan(self, inventoryItem, scan):
    self._oprot.writeMessageBegin('genericScan', TMessageType.CALL, self._seqid)
    args = genericScan_args()
    args.inventoryItem = inventoryItem
    args.scan = scan
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_genericScan(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = genericScan_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.wex is not None:
      raise result.wex
    return

  def scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
    """
    Scan serialized items linked with an order. Returns its price.

    Parameters:
     - serialNumber
     - type
     - orderId
     - fulfilmentWarehouseId
     - quantity
     - billingWarehouseId
    """
    self.send_scanSerializedItemForOrder(serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId)
    return self.recv_scanSerializedItemForOrder()

  def send_scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
    self._oprot.writeMessageBegin('scanSerializedItemForOrder', TMessageType.CALL, self._seqid)
    args = scanSerializedItemForOrder_args()
    args.serialNumber = serialNumber
    args.type = type
    args.orderId = orderId
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
    args.quantity = quantity
    args.billingWarehouseId = billingWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanSerializedItemForOrder(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanSerializedItemForOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanSerializedItemForOrder failed: unknown result");

  def scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
    """
    Scan non-serialized items linked with an order.

    Parameters:
     - inventoryItem
     - type
     - quantity
     - orderId
     - fulfilmentWarehouseId
     - billingWarehouseId
    """
    self.send_scanForOrder(inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId)
    return self.recv_scanForOrder()

  def send_scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
    self._oprot.writeMessageBegin('scanForOrder', TMessageType.CALL, self._seqid)
    args = scanForOrder_args()
    args.inventoryItem = inventoryItem
    args.type = type
    args.quantity = quantity
    args.orderId = orderId
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
    args.billingWarehouseId = billingWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanForOrder(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanForOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForOrder failed: unknown result");

  def createItemNumberMapping(self, itemNumber, itemId):
    """
    Created item number to item id mapping

    Parameters:
     - itemNumber
     - itemId
    """
    self.send_createItemNumberMapping(itemNumber, itemId)
    self.recv_createItemNumberMapping()

  def send_createItemNumberMapping(self, itemNumber, itemId):
    self._oprot.writeMessageBegin('createItemNumberMapping', TMessageType.CALL, self._seqid)
    args = createItemNumberMapping_args()
    args.itemNumber = itemNumber
    args.itemId = itemId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_createItemNumberMapping(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = createItemNumberMapping_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    return

  def getItemNumbers(self, itemId):
    """
    Get itemNumber mappings for itemId

    Parameters:
     - itemId
    """
    self.send_getItemNumbers(itemId)
    return self.recv_getItemNumbers()

  def send_getItemNumbers(self, itemId):
    self._oprot.writeMessageBegin('getItemNumbers', TMessageType.CALL, self._seqid)
    args = getItemNumbers_args()
    args.itemId = itemId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getItemNumbers(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getItemNumbers_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemNumbers failed: unknown result");

  def getItemIds(self, itemNumber):
    """
    Gets item ids for a given item number

    Parameters:
     - itemNumber
    """
    self.send_getItemIds(itemNumber)
    return self.recv_getItemIds()

  def send_getItemIds(self, itemNumber):
    self._oprot.writeMessageBegin('getItemIds', TMessageType.CALL, self._seqid)
    args = getItemIds_args()
    args.itemNumber = itemNumber
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getItemIds(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getItemIds_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemIds failed: unknown result");

  def getInventoryItemsFromLastScanType(self, lastScanType):
    """
    Retrieves all inventory items given a last scan type

    Parameters:
     - lastScanType
    """
    self.send_getInventoryItemsFromLastScanType(lastScanType)
    return self.recv_getInventoryItemsFromLastScanType()

  def send_getInventoryItemsFromLastScanType(self, lastScanType):
    self._oprot.writeMessageBegin('getInventoryItemsFromLastScanType', TMessageType.CALL, self._seqid)
    args = getInventoryItemsFromLastScanType_args()
    args.lastScanType = lastScanType
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInventoryItemsFromLastScanType(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInventoryItemsFromLastScanType_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemsFromLastScanType failed: unknown result");

  def getInventoryItemFromId(self, inventoryItemId):
    """
    Retrieves inventory item given a inventoryItem id

    Parameters:
     - inventoryItemId
    """
    self.send_getInventoryItemFromId(inventoryItemId)
    return self.recv_getInventoryItemFromId()

  def send_getInventoryItemFromId(self, inventoryItemId):
    self._oprot.writeMessageBegin('getInventoryItemFromId', TMessageType.CALL, self._seqid)
    args = getInventoryItemFromId_args()
    args.inventoryItemId = inventoryItemId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInventoryItemFromId(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInventoryItemFromId_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemFromId failed: unknown result");

  def getPurchaseScans(self, startDate, endDate):
    """
    Returns the purchase scans grouped by items for Purchase register reconciliation

    Parameters:
     - startDate
     - endDate
    """
    self.send_getPurchaseScans(startDate, endDate)
    return self.recv_getPurchaseScans()

  def send_getPurchaseScans(self, startDate, endDate):
    self._oprot.writeMessageBegin('getPurchaseScans', TMessageType.CALL, self._seqid)
    args = getPurchaseScans_args()
    args.startDate = startDate
    args.endDate = endDate
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getPurchaseScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getPurchaseScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPurchaseScans failed: unknown result");

  def getPurchaseScansByGrnDate(self, startDate, endDate):
    """
    Returns the purchase scans between grn dates grouped by items for Purchase register reconciliation

    Parameters:
     - startDate
     - endDate
    """
    self.send_getPurchaseScansByGrnDate(startDate, endDate)
    return self.recv_getPurchaseScansByGrnDate()

  def send_getPurchaseScansByGrnDate(self, startDate, endDate):
    self._oprot.writeMessageBegin('getPurchaseScansByGrnDate', TMessageType.CALL, self._seqid)
    args = getPurchaseScansByGrnDate_args()
    args.startDate = startDate
    args.endDate = endDate
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getPurchaseScansByGrnDate(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getPurchaseScansByGrnDate_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPurchaseScansByGrnDate failed: unknown result");

  def getEmptyGrnsByDate(self, startDate, endDate):
    """
    Returns the empty grn-ids between grn dates

    Parameters:
     - startDate
     - endDate
    """
    self.send_getEmptyGrnsByDate(startDate, endDate)
    return self.recv_getEmptyGrnsByDate()

  def send_getEmptyGrnsByDate(self, startDate, endDate):
    self._oprot.writeMessageBegin('getEmptyGrnsByDate', TMessageType.CALL, self._seqid)
    args = getEmptyGrnsByDate_args()
    args.startDate = startDate
    args.endDate = endDate
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getEmptyGrnsByDate(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getEmptyGrnsByDate_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEmptyGrnsByDate failed: unknown result");

  def fetchScansPerInvoiceNumber(self, date):
    """
    Returns the invoices and the count of scans against on a given day.

    Parameters:
     - date
    """
    self.send_fetchScansPerInvoiceNumber(date)
    return self.recv_fetchScansPerInvoiceNumber()

  def send_fetchScansPerInvoiceNumber(self, date):
    self._oprot.writeMessageBegin('fetchScansPerInvoiceNumber', TMessageType.CALL, self._seqid)
    args = fetchScansPerInvoiceNumber_args()
    args.date = date
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_fetchScansPerInvoiceNumber(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = fetchScansPerInvoiceNumber_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "fetchScansPerInvoiceNumber failed: unknown result");

  def getInventoryItemFromOrder(self, orderId):
    """
    Returns inventory item for a given order

    Parameters:
     - orderId
    """
    self.send_getInventoryItemFromOrder(orderId)
    return self.recv_getInventoryItemFromOrder()

  def send_getInventoryItemFromOrder(self, orderId):
    self._oprot.writeMessageBegin('getInventoryItemFromOrder', TMessageType.CALL, self._seqid)
    args = getInventoryItemFromOrder_args()
    args.orderId = orderId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInventoryItemFromOrder(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInventoryItemFromOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.we is not None:
      raise result.we
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemFromOrder failed: unknown result");

  def getInventoryAge(self, ):
    """
    Fetches the stock inventory age week-wise
    """
    self.send_getInventoryAge()
    return self.recv_getInventoryAge()

  def send_getInventoryAge(self, ):
    self._oprot.writeMessageBegin('getInventoryAge', TMessageType.CALL, self._seqid)
    args = getInventoryAge_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInventoryAge(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInventoryAge_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryAge failed: unknown result");

  def getInventoryScansForItem(self, itemId, fromDate, toDate):
    """
    Fetches the scanRecords for a given item for a given time interval

    Parameters:
     - itemId
     - fromDate
     - toDate
    """
    self.send_getInventoryScansForItem(itemId, fromDate, toDate)
    return self.recv_getInventoryScansForItem()

  def send_getInventoryScansForItem(self, itemId, fromDate, toDate):
    self._oprot.writeMessageBegin('getInventoryScansForItem', TMessageType.CALL, self._seqid)
    args = getInventoryScansForItem_args()
    args.itemId = itemId
    args.fromDate = fromDate
    args.toDate = toDate
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInventoryScansForItem(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInventoryScansForItem_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryScansForItem failed: unknown result");

  def getScanRecordsForSerialNumber(self, serialNumber):
    """
    Fetches the scanRecords for a given serialNumber for a given time interval

    Parameters:
     - serialNumber
    """
    self.send_getScanRecordsForSerialNumber(serialNumber)
    return self.recv_getScanRecordsForSerialNumber()

  def send_getScanRecordsForSerialNumber(self, serialNumber):
    self._oprot.writeMessageBegin('getScanRecordsForSerialNumber', TMessageType.CALL, self._seqid)
    args = getScanRecordsForSerialNumber_args()
    args.serialNumber = serialNumber
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getScanRecordsForSerialNumber(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getScanRecordsForSerialNumber_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getScanRecordsForSerialNumber failed: unknown result");

  def scanForPurchaseReturn(self, saleReturnItems, vendorId, billingWarehouseId):
    """
    Inserts outgoing scans for Returned Items and updates returnId in InventoryItems

    Parameters:
     - saleReturnItems
     - vendorId
     - billingWarehouseId
    """
    self.send_scanForPurchaseReturn(saleReturnItems, vendorId, billingWarehouseId)
    return self.recv_scanForPurchaseReturn()

  def send_scanForPurchaseReturn(self, saleReturnItems, vendorId, billingWarehouseId):
    self._oprot.writeMessageBegin('scanForPurchaseReturn', TMessageType.CALL, self._seqid)
    args = scanForPurchaseReturn_args()
    args.saleReturnItems = saleReturnItems
    args.vendorId = vendorId
    args.billingWarehouseId = billingWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanForPurchaseReturn(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanForPurchaseReturn_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, "scanForPurchaseReturn failed: unknown result");

  def scanForLostItem(self, lostItems, vendorId, billingWarehouseId):
    """
    Inserts scans for lost Items and updates lastScanType in InventoryItems

    Parameters:
     - lostItems
     - vendorId
     - billingWarehouseId
    """
    self.send_scanForLostItem(lostItems, vendorId, billingWarehouseId)
    self.recv_scanForLostItem()

  def send_scanForLostItem(self, lostItems, vendorId, billingWarehouseId):
    self._oprot.writeMessageBegin('scanForLostItem', TMessageType.CALL, self._seqid)
    args = scanForLostItem_args()
    args.lostItems = lostItems
    args.vendorId = vendorId
    args.billingWarehouseId = billingWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanForLostItem(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanForLostItem_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ex is not None:
      raise result.ex
    return

  def getCurrentSerializedInventoryByScans(self, physicalWarehouseId):
    """
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table

    Parameters:
     - physicalWarehouseId
    """
    self.send_getCurrentSerializedInventoryByScans(physicalWarehouseId)
    return self.recv_getCurrentSerializedInventoryByScans()

  def send_getCurrentSerializedInventoryByScans(self, physicalWarehouseId):
    self._oprot.writeMessageBegin('getCurrentSerializedInventoryByScans', TMessageType.CALL, self._seqid)
    args = getCurrentSerializedInventoryByScans_args()
    args.physicalWarehouseId = physicalWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getCurrentSerializedInventoryByScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getCurrentSerializedInventoryByScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentSerializedInventoryByScans failed: unknown result");

  def getCurrentNonSerializedInventoryByScans(self, physicalWarehouseId):
    """
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table

    Parameters:
     - physicalWarehouseId
    """
    self.send_getCurrentNonSerializedInventoryByScans(physicalWarehouseId)
    return self.recv_getCurrentNonSerializedInventoryByScans()

  def send_getCurrentNonSerializedInventoryByScans(self, physicalWarehouseId):
    self._oprot.writeMessageBegin('getCurrentNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
    args = getCurrentNonSerializedInventoryByScans_args()
    args.physicalWarehouseId = physicalWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getCurrentNonSerializedInventoryByScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getCurrentNonSerializedInventoryByScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentNonSerializedInventoryByScans failed: unknown result");

  def getHistoricSerializedInventoryByScans(self, date):
    """
    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table

    Parameters:
     - date
    """
    self.send_getHistoricSerializedInventoryByScans(date)
    return self.recv_getHistoricSerializedInventoryByScans()

  def send_getHistoricSerializedInventoryByScans(self, date):
    self._oprot.writeMessageBegin('getHistoricSerializedInventoryByScans', TMessageType.CALL, self._seqid)
    args = getHistoricSerializedInventoryByScans_args()
    args.date = date
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getHistoricSerializedInventoryByScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getHistoricSerializedInventoryByScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHistoricSerializedInventoryByScans failed: unknown result");

  def getHistoricNonSerializedInventoryByScans(self, date):
    """
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table

    Parameters:
     - date
    """
    self.send_getHistoricNonSerializedInventoryByScans(date)
    return self.recv_getHistoricNonSerializedInventoryByScans()

  def send_getHistoricNonSerializedInventoryByScans(self, date):
    self._oprot.writeMessageBegin('getHistoricNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
    args = getHistoricNonSerializedInventoryByScans_args()
    args.date = date
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getHistoricNonSerializedInventoryByScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getHistoricNonSerializedInventoryByScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHistoricNonSerializedInventoryByScans failed: unknown result");

  def getOurHistoricSerializedInventoryByScans(self, date):
    """
    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table

    Parameters:
     - date
    """
    self.send_getOurHistoricSerializedInventoryByScans(date)
    return self.recv_getOurHistoricSerializedInventoryByScans()

  def send_getOurHistoricSerializedInventoryByScans(self, date):
    self._oprot.writeMessageBegin('getOurHistoricSerializedInventoryByScans', TMessageType.CALL, self._seqid)
    args = getOurHistoricSerializedInventoryByScans_args()
    args.date = date
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getOurHistoricSerializedInventoryByScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getOurHistoricSerializedInventoryByScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOurHistoricSerializedInventoryByScans failed: unknown result");

  def getOurHistoricNonSerializedInventoryByScans(self, date):
    """
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table

    Parameters:
     - date
    """
    self.send_getOurHistoricNonSerializedInventoryByScans(date)
    return self.recv_getOurHistoricNonSerializedInventoryByScans()

  def send_getOurHistoricNonSerializedInventoryByScans(self, date):
    self._oprot.writeMessageBegin('getOurHistoricNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
    args = getOurHistoricNonSerializedInventoryByScans_args()
    args.date = date
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getOurHistoricNonSerializedInventoryByScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getOurHistoricNonSerializedInventoryByScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOurHistoricNonSerializedInventoryByScans failed: unknown result");

  def scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, nlc, orderId):
    """
    Insert Purchase/Sale Entries for product billed by Hotspot using OURS_EXTERNAL Billing

    Parameters:
     - itemId
     - serialNumber
     - itemNumber
     - invoiceNumber
     - warehouseId
     - unitPrice
     - nlc
     - orderId
    """
    self.send_scanForOursExternalSale(itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, nlc, orderId)
    return self.recv_scanForOursExternalSale()

  def send_scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, nlc, orderId):
    self._oprot.writeMessageBegin('scanForOursExternalSale', TMessageType.CALL, self._seqid)
    args = scanForOursExternalSale_args()
    args.itemId = itemId
    args.serialNumber = serialNumber
    args.itemNumber = itemNumber
    args.invoiceNumber = invoiceNumber
    args.warehouseId = warehouseId
    args.unitPrice = unitPrice
    args.nlc = nlc
    args.orderId = orderId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanForOursExternalSale(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanForOursExternalSale_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, "scanForOursExternalSale failed: unknown result");

  def scanForOursExternalSaleReturn(self, orderId, unitPrice):
    """
    Insert Purchase_Ret/Sale_Ret Entries for product billed by Hotspot using OURS_EXTERNAL Billing

    Parameters:
     - orderId
     - unitPrice
    """
    self.send_scanForOursExternalSaleReturn(orderId, unitPrice)
    self.recv_scanForOursExternalSaleReturn()

  def send_scanForOursExternalSaleReturn(self, orderId, unitPrice):
    self._oprot.writeMessageBegin('scanForOursExternalSaleReturn', TMessageType.CALL, self._seqid)
    args = scanForOursExternalSaleReturn_args()
    args.orderId = orderId
    args.unitPrice = unitPrice
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanForOursExternalSaleReturn(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanForOursExternalSaleReturn_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ex is not None:
      raise result.ex
    return

  def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
    """
    This returns movement for each non serialized item in the specified window.(Doesn't include Hotspot and Amazon w/h)

    Parameters:
     - startDate
     - endDate
    """
    self.send_getMovementNonSerializedInventoryByScans(startDate, endDate)
    return self.recv_getMovementNonSerializedInventoryByScans()

  def send_getMovementNonSerializedInventoryByScans(self, startDate, endDate):
    self._oprot.writeMessageBegin('getMovementNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
    args = getMovementNonSerializedInventoryByScans_args()
    args.startDate = startDate
    args.endDate = endDate
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getMovementNonSerializedInventoryByScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getMovementNonSerializedInventoryByScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementNonSerializedInventoryByScans failed: unknown result");

  def getMovementSerializedInventoryByScans(self, startDate, endDate):
    """
    This returns movement for each serialized item in the specified window.(Doesn't include Hotspot and Amazon w/h)

    Parameters:
     - startDate
     - endDate
    """
    self.send_getMovementSerializedInventoryByScans(startDate, endDate)
    return self.recv_getMovementSerializedInventoryByScans()

  def send_getMovementSerializedInventoryByScans(self, startDate, endDate):
    self._oprot.writeMessageBegin('getMovementSerializedInventoryByScans', TMessageType.CALL, self._seqid)
    args = getMovementSerializedInventoryByScans_args()
    args.startDate = startDate
    args.endDate = endDate
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getMovementSerializedInventoryByScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getMovementSerializedInventoryByScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementSerializedInventoryByScans failed: unknown result");

  def getCompleteMovementSerializedInventoryByScans(self, startDate, endDate):
    """
    This returns movement for each serialized item in the specified window.(Doesn't include Amazon w/h)

    Parameters:
     - startDate
     - endDate
    """
    self.send_getCompleteMovementSerializedInventoryByScans(startDate, endDate)
    return self.recv_getCompleteMovementSerializedInventoryByScans()

  def send_getCompleteMovementSerializedInventoryByScans(self, startDate, endDate):
    self._oprot.writeMessageBegin('getCompleteMovementSerializedInventoryByScans', TMessageType.CALL, self._seqid)
    args = getCompleteMovementSerializedInventoryByScans_args()
    args.startDate = startDate
    args.endDate = endDate
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getCompleteMovementSerializedInventoryByScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getCompleteMovementSerializedInventoryByScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCompleteMovementSerializedInventoryByScans failed: unknown result");

  def getCompleteMovementNonSerializedInventoryByScans(self, startDate, endDate):
    """
    This returns movement for each non serialized item in the specified window.(Doesn't include Amazon w/h)

    Parameters:
     - startDate
     - endDate
    """
    self.send_getCompleteMovementNonSerializedInventoryByScans(startDate, endDate)
    return self.recv_getCompleteMovementNonSerializedInventoryByScans()

  def send_getCompleteMovementNonSerializedInventoryByScans(self, startDate, endDate):
    self._oprot.writeMessageBegin('getCompleteMovementNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
    args = getCompleteMovementNonSerializedInventoryByScans_args()
    args.startDate = startDate
    args.endDate = endDate
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getCompleteMovementNonSerializedInventoryByScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getCompleteMovementNonSerializedInventoryByScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCompleteMovementNonSerializedInventoryByScans failed: unknown result");

  def scanfreebie(self, orderId, freebieItemId, freebieWarehouseId, scanType):
    """
    Parameters:
     - orderId
     - freebieItemId
     - freebieWarehouseId
     - scanType
    """
    self.send_scanfreebie(orderId, freebieItemId, freebieWarehouseId, scanType)
    return self.recv_scanfreebie()

  def send_scanfreebie(self, orderId, freebieItemId, freebieWarehouseId, scanType):
    self._oprot.writeMessageBegin('scanfreebie', TMessageType.CALL, self._seqid)
    args = scanfreebie_args()
    args.orderId = orderId
    args.freebieItemId = freebieItemId
    args.freebieWarehouseId = freebieWarehouseId
    args.scanType = scanType
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanfreebie(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanfreebie_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanfreebie failed: unknown result");

  def reshipfreebie(self, oldOrderId, newOrderId, freebieItemId, scanType):
    """
    Parameters:
     - oldOrderId
     - newOrderId
     - freebieItemId
     - scanType
    """
    self.send_reshipfreebie(oldOrderId, newOrderId, freebieItemId, scanType)
    self.recv_reshipfreebie()

  def send_reshipfreebie(self, oldOrderId, newOrderId, freebieItemId, scanType):
    self._oprot.writeMessageBegin('reshipfreebie', TMessageType.CALL, self._seqid)
    args = reshipfreebie_args()
    args.oldOrderId = oldOrderId
    args.newOrderId = newOrderId
    args.freebieItemId = freebieItemId
    args.scanType = scanType
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_reshipfreebie(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = reshipfreebie_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.wex is not None:
      raise result.wex
    return

  def isItemTransferAllowed(self, warehouseId, transferWarehouseId):
    """
    Parameters:
     - warehouseId
     - transferWarehouseId
    """
    self.send_isItemTransferAllowed(warehouseId, transferWarehouseId)
    return self.recv_isItemTransferAllowed()

  def send_isItemTransferAllowed(self, warehouseId, transferWarehouseId):
    self._oprot.writeMessageBegin('isItemTransferAllowed', TMessageType.CALL, self._seqid)
    args = isItemTransferAllowed_args()
    args.warehouseId = warehouseId
    args.transferWarehouseId = transferWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_isItemTransferAllowed(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = isItemTransferAllowed_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isItemTransferAllowed failed: unknown result");

  def createTransferLot(self, originWarehouseId, destWarehouseId):
    """
    Parameters:
     - originWarehouseId
     - destWarehouseId
    """
    self.send_createTransferLot(originWarehouseId, destWarehouseId)
    return self.recv_createTransferLot()

  def send_createTransferLot(self, originWarehouseId, destWarehouseId):
    self._oprot.writeMessageBegin('createTransferLot', TMessageType.CALL, self._seqid)
    args = createTransferLot_args()
    args.originWarehouseId = originWarehouseId
    args.destWarehouseId = destWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_createTransferLot(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = createTransferLot_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransferLot failed: unknown result");

  def getTransferLot(self, transferLotId):
    """
    Parameters:
     - transferLotId
    """
    self.send_getTransferLot(transferLotId)
    return self.recv_getTransferLot()

  def send_getTransferLot(self, transferLotId):
    self._oprot.writeMessageBegin('getTransferLot', TMessageType.CALL, self._seqid)
    args = getTransferLot_args()
    args.transferLotId = transferLotId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getTransferLot(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getTransferLot_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransferLot failed: unknown result");

  def markTransferLotAsReceived(self, id, remoteTransferRefNumber):
    """
    Parameters:
     - id
     - remoteTransferRefNumber
    """
    self.send_markTransferLotAsReceived(id, remoteTransferRefNumber)
    self.recv_markTransferLotAsReceived()

  def send_markTransferLotAsReceived(self, id, remoteTransferRefNumber):
    self._oprot.writeMessageBegin('markTransferLotAsReceived', TMessageType.CALL, self._seqid)
    args = markTransferLotAsReceived_args()
    args.id = id
    args.remoteTransferRefNumber = remoteTransferRefNumber
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_markTransferLotAsReceived(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = markTransferLotAsReceived_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.wex is not None:
      raise result.wex
    return

  def getTransferLotsByDate(self, fromDate, toDate):
    """
    Parameters:
     - fromDate
     - toDate
    """
    self.send_getTransferLotsByDate(fromDate, toDate)
    return self.recv_getTransferLotsByDate()

  def send_getTransferLotsByDate(self, fromDate, toDate):
    self._oprot.writeMessageBegin('getTransferLotsByDate', TMessageType.CALL, self._seqid)
    args = getTransferLotsByDate_args()
    args.fromDate = fromDate
    args.toDate = toDate
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getTransferLotsByDate(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getTransferLotsByDate_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransferLotsByDate failed: unknown result");

  def getAllowedDestinationWarehousesForTransfer(self, warehouseId):
    """
    Parameters:
     - warehouseId
    """
    self.send_getAllowedDestinationWarehousesForTransfer(warehouseId)
    return self.recv_getAllowedDestinationWarehousesForTransfer()

  def send_getAllowedDestinationWarehousesForTransfer(self, warehouseId):
    self._oprot.writeMessageBegin('getAllowedDestinationWarehousesForTransfer', TMessageType.CALL, self._seqid)
    args = getAllowedDestinationWarehousesForTransfer_args()
    args.warehouseId = warehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getAllowedDestinationWarehousesForTransfer(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getAllowedDestinationWarehousesForTransfer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllowedDestinationWarehousesForTransfer failed: unknown result");

  def getItemsInTransferLot(self, transferLotId):
    """
    Parameters:
     - transferLotId
    """
    self.send_getItemsInTransferLot(transferLotId)
    return self.recv_getItemsInTransferLot()

  def send_getItemsInTransferLot(self, transferLotId):
    self._oprot.writeMessageBegin('getItemsInTransferLot', TMessageType.CALL, self._seqid)
    args = getItemsInTransferLot_args()
    args.transferLotId = transferLotId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getItemsInTransferLot(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getItemsInTransferLot_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsInTransferLot failed: unknown result");

  def markItemsAsReceivedForTransferLot(self, id):
    """
    Parameters:
     - id
    """
    self.send_markItemsAsReceivedForTransferLot(id)
    self.recv_markItemsAsReceivedForTransferLot()

  def send_markItemsAsReceivedForTransferLot(self, id):
    self._oprot.writeMessageBegin('markItemsAsReceivedForTransferLot', TMessageType.CALL, self._seqid)
    args = markItemsAsReceivedForTransferLot_args()
    args.id = id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_markItemsAsReceivedForTransferLot(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = markItemsAsReceivedForTransferLot_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.wex is not None:
      raise result.wex
    return

  def updateTransferLotAfterItemReceive(self, id):
    """
    Parameters:
     - id
    """
    self.send_updateTransferLotAfterItemReceive(id)
    return self.recv_updateTransferLotAfterItemReceive()

  def send_updateTransferLotAfterItemReceive(self, id):
    self._oprot.writeMessageBegin('updateTransferLotAfterItemReceive', TMessageType.CALL, self._seqid)
    args = updateTransferLotAfterItemReceive_args()
    args.id = id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_updateTransferLotAfterItemReceive(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = updateTransferLotAfterItemReceive_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTransferLotAfterItemReceive failed: unknown result");

  def scanForTransferOut(self, inventoryItems, type, transferLotId):
    """
    Parameters:
     - inventoryItems
     - type
     - transferLotId
    """
    self.send_scanForTransferOut(inventoryItems, type, transferLotId)
    self.recv_scanForTransferOut()

  def send_scanForTransferOut(self, inventoryItems, type, transferLotId):
    self._oprot.writeMessageBegin('scanForTransferOut', TMessageType.CALL, self._seqid)
    args = scanForTransferOut_args()
    args.inventoryItems = inventoryItems
    args.type = type
    args.transferLotId = transferLotId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanForTransferOut(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanForTransferOut_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.wex is not None:
      raise result.wex
    return

  def scanForTransferIn(self, inventoryItems, type, transferLotId):
    """
    Parameters:
     - inventoryItems
     - type
     - transferLotId
    """
    self.send_scanForTransferIn(inventoryItems, type, transferLotId)
    self.recv_scanForTransferIn()

  def send_scanForTransferIn(self, inventoryItems, type, transferLotId):
    self._oprot.writeMessageBegin('scanForTransferIn', TMessageType.CALL, self._seqid)
    args = scanForTransferIn_args()
    args.inventoryItems = inventoryItems
    args.type = type
    args.transferLotId = transferLotId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanForTransferIn(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanForTransferIn_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.wex is not None:
      raise result.wex
    return

  def scanForOursThirdPartyReceive(self, inventoryItems, id):
    """
    Parameters:
     - inventoryItems
     - id
    """
    self.send_scanForOursThirdPartyReceive(inventoryItems, id)
    self.recv_scanForOursThirdPartyReceive()

  def send_scanForOursThirdPartyReceive(self, inventoryItems, id):
    self._oprot.writeMessageBegin('scanForOursThirdPartyReceive', TMessageType.CALL, self._seqid)
    args = scanForOursThirdPartyReceive_args()
    args.inventoryItems = inventoryItems
    args.id = id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanForOursThirdPartyReceive(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanForOursThirdPartyReceive_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.wex is not None:
      raise result.wex
    return

  def getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(self, itemId, physicalWarehouseId):
    """
    Parameters:
     - itemId
     - physicalWarehouseId
    """
    self.send_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(itemId, physicalWarehouseId)
    return self.recv_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse()

  def send_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(self, itemId, physicalWarehouseId):
    self._oprot.writeMessageBegin('getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse', TMessageType.CALL, self._seqid)
    args = getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_args()
    args.itemId = itemId
    args.physicalWarehouseId = physicalWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse failed: unknown result");

  def getInTransitInventory(self, originWarehouseId):
    """
    Parameters:
     - originWarehouseId
    """
    self.send_getInTransitInventory(originWarehouseId)
    return self.recv_getInTransitInventory()

  def send_getInTransitInventory(self, originWarehouseId):
    self._oprot.writeMessageBegin('getInTransitInventory', TMessageType.CALL, self._seqid)
    args = getInTransitInventory_args()
    args.originWarehouseId = originWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInTransitInventory(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInTransitInventory_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInTransitInventory failed: unknown result");

  def isItemAvailableForSale(self, itemId, serialNumber, warehouseId):
    """
    Parameters:
     - itemId
     - serialNumber
     - warehouseId
    """
    self.send_isItemAvailableForSale(itemId, serialNumber, warehouseId)
    return self.recv_isItemAvailableForSale()

  def send_isItemAvailableForSale(self, itemId, serialNumber, warehouseId):
    self._oprot.writeMessageBegin('isItemAvailableForSale', TMessageType.CALL, self._seqid)
    args = isItemAvailableForSale_args()
    args.itemId = itemId
    args.serialNumber = serialNumber
    args.warehouseId = warehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_isItemAvailableForSale(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = isItemAvailableForSale_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isItemAvailableForSale failed: unknown result");

  def getHistoricBadInventoryByScans(self, date):
    """
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table

    Parameters:
     - date
    """
    self.send_getHistoricBadInventoryByScans(date)
    return self.recv_getHistoricBadInventoryByScans()

  def send_getHistoricBadInventoryByScans(self, date):
    self._oprot.writeMessageBegin('getHistoricBadInventoryByScans', TMessageType.CALL, self._seqid)
    args = getHistoricBadInventoryByScans_args()
    args.date = date
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getHistoricBadInventoryByScans(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getHistoricBadInventoryByScans_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHistoricBadInventoryByScans failed: unknown result");

  def scanForBadSale(self, serialNumber, itemNumber, itemId, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
    """
    Parameters:
     - serialNumber
     - itemNumber
     - itemId
     - orderId
     - fulfilmentWarehouseId
     - quantity
     - billingWarehouseId
    """
    self.send_scanForBadSale(serialNumber, itemNumber, itemId, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId)
    return self.recv_scanForBadSale()

  def send_scanForBadSale(self, serialNumber, itemNumber, itemId, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
    self._oprot.writeMessageBegin('scanForBadSale', TMessageType.CALL, self._seqid)
    args = scanForBadSale_args()
    args.serialNumber = serialNumber
    args.itemNumber = itemNumber
    args.itemId = itemId
    args.orderId = orderId
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
    args.quantity = quantity
    args.billingWarehouseId = billingWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanForBadSale(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanForBadSale_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForBadSale failed: unknown result");

  def getTransferLotItemsForMarkReceive(self, transferLotId, scanType):
    """
    Parameters:
     - transferLotId
     - scanType
    """
    self.send_getTransferLotItemsForMarkReceive(transferLotId, scanType)
    return self.recv_getTransferLotItemsForMarkReceive()

  def send_getTransferLotItemsForMarkReceive(self, transferLotId, scanType):
    self._oprot.writeMessageBegin('getTransferLotItemsForMarkReceive', TMessageType.CALL, self._seqid)
    args = getTransferLotItemsForMarkReceive_args()
    args.transferLotId = transferLotId
    args.scanType = scanType
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getTransferLotItemsForMarkReceive(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getTransferLotItemsForMarkReceive_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransferLotItemsForMarkReceive failed: unknown result");

  def markItemsAsReceivedForTransferLotPartial(self, inventoryItems, transferLotId):
    """
    Parameters:
     - inventoryItems
     - transferLotId
    """
    self.send_markItemsAsReceivedForTransferLotPartial(inventoryItems, transferLotId)
    self.recv_markItemsAsReceivedForTransferLotPartial()

  def send_markItemsAsReceivedForTransferLotPartial(self, inventoryItems, transferLotId):
    self._oprot.writeMessageBegin('markItemsAsReceivedForTransferLotPartial', TMessageType.CALL, self._seqid)
    args = markItemsAsReceivedForTransferLotPartial_args()
    args.inventoryItems = inventoryItems
    args.transferLotId = transferLotId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_markItemsAsReceivedForTransferLotPartial(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = markItemsAsReceivedForTransferLotPartial_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.wex is not None:
      raise result.wex
    return

  def markTransferLotAsReceivedPartial(self, id, remoteTransferRefNumber):
    """
    Parameters:
     - id
     - remoteTransferRefNumber
    """
    self.send_markTransferLotAsReceivedPartial(id, remoteTransferRefNumber)
    self.recv_markTransferLotAsReceivedPartial()

  def send_markTransferLotAsReceivedPartial(self, id, remoteTransferRefNumber):
    self._oprot.writeMessageBegin('markTransferLotAsReceivedPartial', TMessageType.CALL, self._seqid)
    args = markTransferLotAsReceivedPartial_args()
    args.id = id
    args.remoteTransferRefNumber = remoteTransferRefNumber
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_markTransferLotAsReceivedPartial(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = markTransferLotAsReceivedPartial_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.wex is not None:
      raise result.wex
    return

  def getInventoryItemScannedInForPO(self, itemId, purchaseIds):
    """
    Parameters:
     - itemId
     - purchaseIds
    """
    self.send_getInventoryItemScannedInForPO(itemId, purchaseIds)
    return self.recv_getInventoryItemScannedInForPO()

  def send_getInventoryItemScannedInForPO(self, itemId, purchaseIds):
    self._oprot.writeMessageBegin('getInventoryItemScannedInForPO', TMessageType.CALL, self._seqid)
    args = getInventoryItemScannedInForPO_args()
    args.itemId = itemId
    args.purchaseIds = purchaseIds
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInventoryItemScannedInForPO(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInventoryItemScannedInForPO_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemScannedInForPO failed: unknown result");

  def getAmazonTransferredSkuDetails(self, itemIds):
    """
    Parameters:
     - itemIds
    """
    self.send_getAmazonTransferredSkuDetails(itemIds)
    return self.recv_getAmazonTransferredSkuDetails()

  def send_getAmazonTransferredSkuDetails(self, itemIds):
    self._oprot.writeMessageBegin('getAmazonTransferredSkuDetails', TMessageType.CALL, self._seqid)
    args = getAmazonTransferredSkuDetails_args()
    args.itemIds = itemIds
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getAmazonTransferredSkuDetails(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getAmazonTransferredSkuDetails_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonTransferredSkuDetails failed: unknown result");

  def getScansforPurchase(self, purchaseId, scanType):
    """
    Parameters:
     - purchaseId
     - scanType
    """
    self.send_getScansforPurchase(purchaseId, scanType)
    return self.recv_getScansforPurchase()

  def send_getScansforPurchase(self, purchaseId, scanType):
    self._oprot.writeMessageBegin('getScansforPurchase', TMessageType.CALL, self._seqid)
    args = getScansforPurchase_args()
    args.purchaseId = purchaseId
    args.scanType = scanType
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getScansforPurchase(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getScansforPurchase_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getScansforPurchase failed: unknown result");

  def getCurrentBadQuantityForItem(self, itemId, currentWarehouseId, physicalWarehouseId):
    """
    Parameters:
     - itemId
     - currentWarehouseId
     - physicalWarehouseId
    """
    self.send_getCurrentBadQuantityForItem(itemId, currentWarehouseId, physicalWarehouseId)
    return self.recv_getCurrentBadQuantityForItem()

  def send_getCurrentBadQuantityForItem(self, itemId, currentWarehouseId, physicalWarehouseId):
    self._oprot.writeMessageBegin('getCurrentBadQuantityForItem', TMessageType.CALL, self._seqid)
    args = getCurrentBadQuantityForItem_args()
    args.itemId = itemId
    args.currentWarehouseId = currentWarehouseId
    args.physicalWarehouseId = physicalWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getCurrentBadQuantityForItem(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getCurrentBadQuantityForItem_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentBadQuantityForItem failed: unknown result");

  def scanForBadPurchaseReturn(self, saleReturnItems, vendorId, billingWarehouseId):
    """
    Parameters:
     - saleReturnItems
     - vendorId
     - billingWarehouseId
    """
    self.send_scanForBadPurchaseReturn(saleReturnItems, vendorId, billingWarehouseId)
    return self.recv_scanForBadPurchaseReturn()

  def send_scanForBadPurchaseReturn(self, saleReturnItems, vendorId, billingWarehouseId):
    self._oprot.writeMessageBegin('scanForBadPurchaseReturn', TMessageType.CALL, self._seqid)
    args = scanForBadPurchaseReturn_args()
    args.saleReturnItems = saleReturnItems
    args.vendorId = vendorId
    args.billingWarehouseId = billingWarehouseId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanForBadPurchaseReturn(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanForBadPurchaseReturn_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, "scanForBadPurchaseReturn failed: unknown result");

  def getItemsInPurchaseReturn(self, purchaseReturnId, type, returnTime):
    """
    Parameters:
     - purchaseReturnId
     - type
     - returnTime
    """
    self.send_getItemsInPurchaseReturn(purchaseReturnId, type, returnTime)
    return self.recv_getItemsInPurchaseReturn()

  def send_getItemsInPurchaseReturn(self, purchaseReturnId, type, returnTime):
    self._oprot.writeMessageBegin('getItemsInPurchaseReturn', TMessageType.CALL, self._seqid)
    args = getItemsInPurchaseReturn_args()
    args.purchaseReturnId = purchaseReturnId
    args.type = type
    args.returnTime = returnTime
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getItemsInPurchaseReturn(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getItemsInPurchaseReturn_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, "getItemsInPurchaseReturn failed: unknown result");

  def getScansForInventoryItem(self, inventoryItemId, type):
    """
    Parameters:
     - inventoryItemId
     - type
    """
    self.send_getScansForInventoryItem(inventoryItemId, type)
    return self.recv_getScansForInventoryItem()

  def send_getScansForInventoryItem(self, inventoryItemId, type):
    self._oprot.writeMessageBegin('getScansForInventoryItem', TMessageType.CALL, self._seqid)
    args = getScansForInventoryItem_args()
    args.inventoryItemId = inventoryItemId
    args.type = type
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getScansForInventoryItem(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getScansForInventoryItem_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, "getScansForInventoryItem failed: unknown result");

  def checkGrnImeiStatus(self, imeiNos):
    """
    Parameters:
     - imeiNos
    """
    self.send_checkGrnImeiStatus(imeiNos)
    return self.recv_checkGrnImeiStatus()

  def send_checkGrnImeiStatus(self, imeiNos):
    self._oprot.writeMessageBegin('checkGrnImeiStatus', TMessageType.CALL, self._seqid)
    args = checkGrnImeiStatus_args()
    args.imeiNos = imeiNos
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_checkGrnImeiStatus(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = checkGrnImeiStatus_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, "checkGrnImeiStatus failed: unknown result");

  def getInventoryAgeConsideredItems(self, itemId):
    """
    Parameters:
     - itemId
    """
    self.send_getInventoryAgeConsideredItems(itemId)
    return self.recv_getInventoryAgeConsideredItems()

  def send_getInventoryAgeConsideredItems(self, itemId):
    self._oprot.writeMessageBegin('getInventoryAgeConsideredItems', TMessageType.CALL, self._seqid)
    args = getInventoryAgeConsideredItems_args()
    args.itemId = itemId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInventoryAgeConsideredItems(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInventoryAgeConsideredItems_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, "getInventoryAgeConsideredItems failed: unknown result");

  def getCompleteMovementForThirdPartyWarehouse(self, startDate, endDate):
    """
    Parameters:
     - startDate
     - endDate
    """
    self.send_getCompleteMovementForThirdPartyWarehouse(startDate, endDate)
    return self.recv_getCompleteMovementForThirdPartyWarehouse()

  def send_getCompleteMovementForThirdPartyWarehouse(self, startDate, endDate):
    self._oprot.writeMessageBegin('getCompleteMovementForThirdPartyWarehouse', TMessageType.CALL, self._seqid)
    args = getCompleteMovementForThirdPartyWarehouse_args()
    args.startDate = startDate
    args.endDate = endDate
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getCompleteMovementForThirdPartyWarehouse(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getCompleteMovementForThirdPartyWarehouse_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCompleteMovementForThirdPartyWarehouse failed: unknown result");

  def getAllDoaOutInventoryItems(self, ):
    self.send_getAllDoaOutInventoryItems()
    return self.recv_getAllDoaOutInventoryItems()

  def send_getAllDoaOutInventoryItems(self, ):
    self._oprot.writeMessageBegin('getAllDoaOutInventoryItems', TMessageType.CALL, self._seqid)
    args = getAllDoaOutInventoryItems_args()
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getAllDoaOutInventoryItems(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getAllDoaOutInventoryItems_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, "getAllDoaOutInventoryItems failed: unknown result");

  def getAllUnCompletedStockShipments(self, source):
    """
    Parameters:
     - source
    """
    self.send_getAllUnCompletedStockShipments(source)
    return self.recv_getAllUnCompletedStockShipments()

  def send_getAllUnCompletedStockShipments(self, source):
    self._oprot.writeMessageBegin('getAllUnCompletedStockShipments', TMessageType.CALL, self._seqid)
    args = getAllUnCompletedStockShipments_args()
    args.source = source
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getAllUnCompletedStockShipments(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getAllUnCompletedStockShipments_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, "getAllUnCompletedStockShipments failed: unknown result");

  def getRemovalStockShipmentReferenceById(self, id):
    """
    Parameters:
     - id
    """
    self.send_getRemovalStockShipmentReferenceById(id)
    return self.recv_getRemovalStockShipmentReferenceById()

  def send_getRemovalStockShipmentReferenceById(self, id):
    self._oprot.writeMessageBegin('getRemovalStockShipmentReferenceById', TMessageType.CALL, self._seqid)
    args = getRemovalStockShipmentReferenceById_args()
    args.id = id
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getRemovalStockShipmentReferenceById(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getRemovalStockShipmentReferenceById_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, "getRemovalStockShipmentReferenceById failed: unknown result");

  def createRemovalStockShipmentReference(self, removalStockShipmentReference):
    """
    Parameters:
     - removalStockShipmentReference
    """
    self.send_createRemovalStockShipmentReference(removalStockShipmentReference)
    return self.recv_createRemovalStockShipmentReference()

  def send_createRemovalStockShipmentReference(self, removalStockShipmentReference):
    self._oprot.writeMessageBegin('createRemovalStockShipmentReference', TMessageType.CALL, self._seqid)
    args = createRemovalStockShipmentReference_args()
    args.removalStockShipmentReference = removalStockShipmentReference
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_createRemovalStockShipmentReference(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = createRemovalStockShipmentReference_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, "createRemovalStockShipmentReference failed: unknown result");

  def updateShipmentReferenceTransferLot(self, transferLotId, shipmentReferenceId):
    """
    Parameters:
     - transferLotId
     - shipmentReferenceId
    """
    self.send_updateShipmentReferenceTransferLot(transferLotId, shipmentReferenceId)
    self.recv_updateShipmentReferenceTransferLot()

  def send_updateShipmentReferenceTransferLot(self, transferLotId, shipmentReferenceId):
    self._oprot.writeMessageBegin('updateShipmentReferenceTransferLot', TMessageType.CALL, self._seqid)
    args = updateShipmentReferenceTransferLot_args()
    args.transferLotId = transferLotId
    args.shipmentReferenceId = shipmentReferenceId
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_updateShipmentReferenceTransferLot(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = updateShipmentReferenceTransferLot_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ex is not None:
      raise result.ex
    return

  def fetchScansPerTransferInvoiceNumber(self, date):
    """
    Returns the shipment references and the count of scans against on a given day.

    Parameters:
     - date
    """
    self.send_fetchScansPerTransferInvoiceNumber(date)
    return self.recv_fetchScansPerTransferInvoiceNumber()

  def send_fetchScansPerTransferInvoiceNumber(self, date):
    self._oprot.writeMessageBegin('fetchScansPerTransferInvoiceNumber', TMessageType.CALL, self._seqid)
    args = fetchScansPerTransferInvoiceNumber_args()
    args.date = date
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_fetchScansPerTransferInvoiceNumber(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = fetchScansPerTransferInvoiceNumber_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "fetchScansPerTransferInvoiceNumber failed: unknown result");

  def getInventoryItems(self, serialNumbers):
    """
    Parameters:
     - serialNumbers
    """
    self.send_getInventoryItems(serialNumbers)
    return self.recv_getInventoryItems()

  def send_getInventoryItems(self, serialNumbers):
    self._oprot.writeMessageBegin('getInventoryItems', TMessageType.CALL, self._seqid)
    args = getInventoryItems_args()
    args.serialNumbers = serialNumbers
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInventoryItems(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInventoryItems_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItems failed: unknown result");

  def getInventoryItemsBySerailNumbers(self, serialNumbers):
    """
    Parameters:
     - serialNumbers
    """
    self.send_getInventoryItemsBySerailNumbers(serialNumbers)
    return self.recv_getInventoryItemsBySerailNumbers()

  def send_getInventoryItemsBySerailNumbers(self, serialNumbers):
    self._oprot.writeMessageBegin('getInventoryItemsBySerailNumbers', TMessageType.CALL, self._seqid)
    args = getInventoryItemsBySerailNumbers_args()
    args.serialNumbers = serialNumbers
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_getInventoryItemsBySerailNumbers(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = getInventoryItemsBySerailNumbers_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.wex is not None:
      raise result.wex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemsBySerailNumbers failed: unknown result");

  def scanPurchaseBulk(self, inventoryItems):
    """
    Parameters:
     - inventoryItems
    """
    self.send_scanPurchaseBulk(inventoryItems)
    self.recv_scanPurchaseBulk()

  def send_scanPurchaseBulk(self, inventoryItems):
    self._oprot.writeMessageBegin('scanPurchaseBulk', TMessageType.CALL, self._seqid)
    args = scanPurchaseBulk_args()
    args.inventoryItems = inventoryItems
    args.write(self._oprot)
    self._oprot.writeMessageEnd()
    self._oprot.trans.flush()

  def recv_scanPurchaseBulk(self, ):
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
    if mtype == TMessageType.EXCEPTION:
      x = TApplicationException()
      x.read(self._iprot)
      self._iprot.readMessageEnd()
      raise x
    result = scanPurchaseBulk_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.wex is not None:
      raise result.wex
    return


class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
  def __init__(self, handler):
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
    self._processMap["getInventoryItem"] = Processor.process_getInventoryItem
    self._processMap["getNonSeralizedInventoryItem"] = Processor.process_getNonSeralizedInventoryItem
    self._processMap["scan"] = Processor.process_scan
    self._processMap["genericScan"] = Processor.process_genericScan
    self._processMap["scanSerializedItemForOrder"] = Processor.process_scanSerializedItemForOrder
    self._processMap["scanForOrder"] = Processor.process_scanForOrder
    self._processMap["createItemNumberMapping"] = Processor.process_createItemNumberMapping
    self._processMap["getItemNumbers"] = Processor.process_getItemNumbers
    self._processMap["getItemIds"] = Processor.process_getItemIds
    self._processMap["getInventoryItemsFromLastScanType"] = Processor.process_getInventoryItemsFromLastScanType
    self._processMap["getInventoryItemFromId"] = Processor.process_getInventoryItemFromId
    self._processMap["getPurchaseScans"] = Processor.process_getPurchaseScans
    self._processMap["getPurchaseScansByGrnDate"] = Processor.process_getPurchaseScansByGrnDate
    self._processMap["getEmptyGrnsByDate"] = Processor.process_getEmptyGrnsByDate
    self._processMap["fetchScansPerInvoiceNumber"] = Processor.process_fetchScansPerInvoiceNumber
    self._processMap["getInventoryItemFromOrder"] = Processor.process_getInventoryItemFromOrder
    self._processMap["getInventoryAge"] = Processor.process_getInventoryAge
    self._processMap["getInventoryScansForItem"] = Processor.process_getInventoryScansForItem
    self._processMap["getScanRecordsForSerialNumber"] = Processor.process_getScanRecordsForSerialNumber
    self._processMap["scanForPurchaseReturn"] = Processor.process_scanForPurchaseReturn
    self._processMap["scanForLostItem"] = Processor.process_scanForLostItem
    self._processMap["getCurrentSerializedInventoryByScans"] = Processor.process_getCurrentSerializedInventoryByScans
    self._processMap["getCurrentNonSerializedInventoryByScans"] = Processor.process_getCurrentNonSerializedInventoryByScans
    self._processMap["getHistoricSerializedInventoryByScans"] = Processor.process_getHistoricSerializedInventoryByScans
    self._processMap["getHistoricNonSerializedInventoryByScans"] = Processor.process_getHistoricNonSerializedInventoryByScans
    self._processMap["getOurHistoricSerializedInventoryByScans"] = Processor.process_getOurHistoricSerializedInventoryByScans
    self._processMap["getOurHistoricNonSerializedInventoryByScans"] = Processor.process_getOurHistoricNonSerializedInventoryByScans
    self._processMap["scanForOursExternalSale"] = Processor.process_scanForOursExternalSale
    self._processMap["scanForOursExternalSaleReturn"] = Processor.process_scanForOursExternalSaleReturn
    self._processMap["getMovementNonSerializedInventoryByScans"] = Processor.process_getMovementNonSerializedInventoryByScans
    self._processMap["getMovementSerializedInventoryByScans"] = Processor.process_getMovementSerializedInventoryByScans
    self._processMap["getCompleteMovementSerializedInventoryByScans"] = Processor.process_getCompleteMovementSerializedInventoryByScans
    self._processMap["getCompleteMovementNonSerializedInventoryByScans"] = Processor.process_getCompleteMovementNonSerializedInventoryByScans
    self._processMap["scanfreebie"] = Processor.process_scanfreebie
    self._processMap["reshipfreebie"] = Processor.process_reshipfreebie
    self._processMap["isItemTransferAllowed"] = Processor.process_isItemTransferAllowed
    self._processMap["createTransferLot"] = Processor.process_createTransferLot
    self._processMap["getTransferLot"] = Processor.process_getTransferLot
    self._processMap["markTransferLotAsReceived"] = Processor.process_markTransferLotAsReceived
    self._processMap["getTransferLotsByDate"] = Processor.process_getTransferLotsByDate
    self._processMap["getAllowedDestinationWarehousesForTransfer"] = Processor.process_getAllowedDestinationWarehousesForTransfer
    self._processMap["getItemsInTransferLot"] = Processor.process_getItemsInTransferLot
    self._processMap["markItemsAsReceivedForTransferLot"] = Processor.process_markItemsAsReceivedForTransferLot
    self._processMap["updateTransferLotAfterItemReceive"] = Processor.process_updateTransferLotAfterItemReceive
    self._processMap["scanForTransferOut"] = Processor.process_scanForTransferOut
    self._processMap["scanForTransferIn"] = Processor.process_scanForTransferIn
    self._processMap["scanForOursThirdPartyReceive"] = Processor.process_scanForOursThirdPartyReceive
    self._processMap["getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse"] = Processor.process_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse
    self._processMap["getInTransitInventory"] = Processor.process_getInTransitInventory
    self._processMap["isItemAvailableForSale"] = Processor.process_isItemAvailableForSale
    self._processMap["getHistoricBadInventoryByScans"] = Processor.process_getHistoricBadInventoryByScans
    self._processMap["scanForBadSale"] = Processor.process_scanForBadSale
    self._processMap["getTransferLotItemsForMarkReceive"] = Processor.process_getTransferLotItemsForMarkReceive
    self._processMap["markItemsAsReceivedForTransferLotPartial"] = Processor.process_markItemsAsReceivedForTransferLotPartial
    self._processMap["markTransferLotAsReceivedPartial"] = Processor.process_markTransferLotAsReceivedPartial
    self._processMap["getInventoryItemScannedInForPO"] = Processor.process_getInventoryItemScannedInForPO
    self._processMap["getAmazonTransferredSkuDetails"] = Processor.process_getAmazonTransferredSkuDetails
    self._processMap["getScansforPurchase"] = Processor.process_getScansforPurchase
    self._processMap["getCurrentBadQuantityForItem"] = Processor.process_getCurrentBadQuantityForItem
    self._processMap["scanForBadPurchaseReturn"] = Processor.process_scanForBadPurchaseReturn
    self._processMap["getItemsInPurchaseReturn"] = Processor.process_getItemsInPurchaseReturn
    self._processMap["getScansForInventoryItem"] = Processor.process_getScansForInventoryItem
    self._processMap["checkGrnImeiStatus"] = Processor.process_checkGrnImeiStatus
    self._processMap["getInventoryAgeConsideredItems"] = Processor.process_getInventoryAgeConsideredItems
    self._processMap["getCompleteMovementForThirdPartyWarehouse"] = Processor.process_getCompleteMovementForThirdPartyWarehouse
    self._processMap["getAllDoaOutInventoryItems"] = Processor.process_getAllDoaOutInventoryItems
    self._processMap["getAllUnCompletedStockShipments"] = Processor.process_getAllUnCompletedStockShipments
    self._processMap["getRemovalStockShipmentReferenceById"] = Processor.process_getRemovalStockShipmentReferenceById
    self._processMap["createRemovalStockShipmentReference"] = Processor.process_createRemovalStockShipmentReference
    self._processMap["updateShipmentReferenceTransferLot"] = Processor.process_updateShipmentReferenceTransferLot
    self._processMap["fetchScansPerTransferInvoiceNumber"] = Processor.process_fetchScansPerTransferInvoiceNumber
    self._processMap["getInventoryItems"] = Processor.process_getInventoryItems
    self._processMap["getInventoryItemsBySerailNumbers"] = Processor.process_getInventoryItemsBySerailNumbers
    self._processMap["scanPurchaseBulk"] = Processor.process_scanPurchaseBulk

  def process(self, iprot, oprot):
    (name, type, seqid) = iprot.readMessageBegin()
    if name not in self._processMap:
      iprot.skip(TType.STRUCT)
      iprot.readMessageEnd()
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
      x.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
      return
    else:
      self._processMap[name](self, seqid, iprot, oprot)
    return True

  def process_getInventoryItem(self, seqid, iprot, oprot):
    args = getInventoryItem_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInventoryItem_result()
    try:
      result.success = self._handler.getInventoryItem(args.serialNumber)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getInventoryItem", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getNonSeralizedInventoryItem(self, seqid, iprot, oprot):
    args = getNonSeralizedInventoryItem_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getNonSeralizedInventoryItem_result()
    try:
      result.success = self._handler.getNonSeralizedInventoryItem(args.itemNumber, args.itemId, args.fulfilmentWarehouseId, args.billingWarehouseId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getNonSeralizedInventoryItem", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scan(self, seqid, iprot, oprot):
    args = scan_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scan_result()
    try:
      self._handler.scan(args.inventoryItem, args.type, args.quantity, args.billingWarehouseId, args.transferLotId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("scan", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_genericScan(self, seqid, iprot, oprot):
    args = genericScan_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = genericScan_result()
    try:
      self._handler.genericScan(args.inventoryItem, args.scan)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("genericScan", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanSerializedItemForOrder(self, seqid, iprot, oprot):
    args = scanSerializedItemForOrder_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanSerializedItemForOrder_result()
    try:
      result.success = self._handler.scanSerializedItemForOrder(args.serialNumber, args.type, args.orderId, args.fulfilmentWarehouseId, args.quantity, args.billingWarehouseId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("scanSerializedItemForOrder", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanForOrder(self, seqid, iprot, oprot):
    args = scanForOrder_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanForOrder_result()
    try:
      result.success = self._handler.scanForOrder(args.inventoryItem, args.type, args.quantity, args.orderId, args.fulfilmentWarehouseId, args.billingWarehouseId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("scanForOrder", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_createItemNumberMapping(self, seqid, iprot, oprot):
    args = createItemNumberMapping_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = createItemNumberMapping_result()
    self._handler.createItemNumberMapping(args.itemNumber, args.itemId)
    oprot.writeMessageBegin("createItemNumberMapping", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getItemNumbers(self, seqid, iprot, oprot):
    args = getItemNumbers_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getItemNumbers_result()
    result.success = self._handler.getItemNumbers(args.itemId)
    oprot.writeMessageBegin("getItemNumbers", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getItemIds(self, seqid, iprot, oprot):
    args = getItemIds_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getItemIds_result()
    result.success = self._handler.getItemIds(args.itemNumber)
    oprot.writeMessageBegin("getItemIds", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getInventoryItemsFromLastScanType(self, seqid, iprot, oprot):
    args = getInventoryItemsFromLastScanType_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInventoryItemsFromLastScanType_result()
    try:
      result.success = self._handler.getInventoryItemsFromLastScanType(args.lastScanType)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getInventoryItemsFromLastScanType", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getInventoryItemFromId(self, seqid, iprot, oprot):
    args = getInventoryItemFromId_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInventoryItemFromId_result()
    try:
      result.success = self._handler.getInventoryItemFromId(args.inventoryItemId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getInventoryItemFromId", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getPurchaseScans(self, seqid, iprot, oprot):
    args = getPurchaseScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getPurchaseScans_result()
    result.success = self._handler.getPurchaseScans(args.startDate, args.endDate)
    oprot.writeMessageBegin("getPurchaseScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getPurchaseScansByGrnDate(self, seqid, iprot, oprot):
    args = getPurchaseScansByGrnDate_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getPurchaseScansByGrnDate_result()
    result.success = self._handler.getPurchaseScansByGrnDate(args.startDate, args.endDate)
    oprot.writeMessageBegin("getPurchaseScansByGrnDate", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getEmptyGrnsByDate(self, seqid, iprot, oprot):
    args = getEmptyGrnsByDate_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getEmptyGrnsByDate_result()
    result.success = self._handler.getEmptyGrnsByDate(args.startDate, args.endDate)
    oprot.writeMessageBegin("getEmptyGrnsByDate", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_fetchScansPerInvoiceNumber(self, seqid, iprot, oprot):
    args = fetchScansPerInvoiceNumber_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = fetchScansPerInvoiceNumber_result()
    result.success = self._handler.fetchScansPerInvoiceNumber(args.date)
    oprot.writeMessageBegin("fetchScansPerInvoiceNumber", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getInventoryItemFromOrder(self, seqid, iprot, oprot):
    args = getInventoryItemFromOrder_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInventoryItemFromOrder_result()
    try:
      result.success = self._handler.getInventoryItemFromOrder(args.orderId)
    except WarehouseServiceException, we:
      result.we = we
    oprot.writeMessageBegin("getInventoryItemFromOrder", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getInventoryAge(self, seqid, iprot, oprot):
    args = getInventoryAge_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInventoryAge_result()
    result.success = self._handler.getInventoryAge()
    oprot.writeMessageBegin("getInventoryAge", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getInventoryScansForItem(self, seqid, iprot, oprot):
    args = getInventoryScansForItem_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInventoryScansForItem_result()
    result.success = self._handler.getInventoryScansForItem(args.itemId, args.fromDate, args.toDate)
    oprot.writeMessageBegin("getInventoryScansForItem", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getScanRecordsForSerialNumber(self, seqid, iprot, oprot):
    args = getScanRecordsForSerialNumber_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getScanRecordsForSerialNumber_result()
    result.success = self._handler.getScanRecordsForSerialNumber(args.serialNumber)
    oprot.writeMessageBegin("getScanRecordsForSerialNumber", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanForPurchaseReturn(self, seqid, iprot, oprot):
    args = scanForPurchaseReturn_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanForPurchaseReturn_result()
    try:
      result.success = self._handler.scanForPurchaseReturn(args.saleReturnItems, args.vendorId, args.billingWarehouseId)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("scanForPurchaseReturn", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanForLostItem(self, seqid, iprot, oprot):
    args = scanForLostItem_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanForLostItem_result()
    try:
      self._handler.scanForLostItem(args.lostItems, args.vendorId, args.billingWarehouseId)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("scanForLostItem", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getCurrentSerializedInventoryByScans(self, seqid, iprot, oprot):
    args = getCurrentSerializedInventoryByScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getCurrentSerializedInventoryByScans_result()
    result.success = self._handler.getCurrentSerializedInventoryByScans(args.physicalWarehouseId)
    oprot.writeMessageBegin("getCurrentSerializedInventoryByScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getCurrentNonSerializedInventoryByScans(self, seqid, iprot, oprot):
    args = getCurrentNonSerializedInventoryByScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getCurrentNonSerializedInventoryByScans_result()
    result.success = self._handler.getCurrentNonSerializedInventoryByScans(args.physicalWarehouseId)
    oprot.writeMessageBegin("getCurrentNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getHistoricSerializedInventoryByScans(self, seqid, iprot, oprot):
    args = getHistoricSerializedInventoryByScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getHistoricSerializedInventoryByScans_result()
    result.success = self._handler.getHistoricSerializedInventoryByScans(args.date)
    oprot.writeMessageBegin("getHistoricSerializedInventoryByScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getHistoricNonSerializedInventoryByScans(self, seqid, iprot, oprot):
    args = getHistoricNonSerializedInventoryByScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getHistoricNonSerializedInventoryByScans_result()
    result.success = self._handler.getHistoricNonSerializedInventoryByScans(args.date)
    oprot.writeMessageBegin("getHistoricNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getOurHistoricSerializedInventoryByScans(self, seqid, iprot, oprot):
    args = getOurHistoricSerializedInventoryByScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getOurHistoricSerializedInventoryByScans_result()
    result.success = self._handler.getOurHistoricSerializedInventoryByScans(args.date)
    oprot.writeMessageBegin("getOurHistoricSerializedInventoryByScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getOurHistoricNonSerializedInventoryByScans(self, seqid, iprot, oprot):
    args = getOurHistoricNonSerializedInventoryByScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getOurHistoricNonSerializedInventoryByScans_result()
    result.success = self._handler.getOurHistoricNonSerializedInventoryByScans(args.date)
    oprot.writeMessageBegin("getOurHistoricNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanForOursExternalSale(self, seqid, iprot, oprot):
    args = scanForOursExternalSale_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanForOursExternalSale_result()
    try:
      result.success = self._handler.scanForOursExternalSale(args.itemId, args.serialNumber, args.itemNumber, args.invoiceNumber, args.warehouseId, args.unitPrice, args.nlc, args.orderId)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("scanForOursExternalSale", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanForOursExternalSaleReturn(self, seqid, iprot, oprot):
    args = scanForOursExternalSaleReturn_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanForOursExternalSaleReturn_result()
    try:
      self._handler.scanForOursExternalSaleReturn(args.orderId, args.unitPrice)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("scanForOursExternalSaleReturn", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getMovementNonSerializedInventoryByScans(self, seqid, iprot, oprot):
    args = getMovementNonSerializedInventoryByScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getMovementNonSerializedInventoryByScans_result()
    result.success = self._handler.getMovementNonSerializedInventoryByScans(args.startDate, args.endDate)
    oprot.writeMessageBegin("getMovementNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getMovementSerializedInventoryByScans(self, seqid, iprot, oprot):
    args = getMovementSerializedInventoryByScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getMovementSerializedInventoryByScans_result()
    result.success = self._handler.getMovementSerializedInventoryByScans(args.startDate, args.endDate)
    oprot.writeMessageBegin("getMovementSerializedInventoryByScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getCompleteMovementSerializedInventoryByScans(self, seqid, iprot, oprot):
    args = getCompleteMovementSerializedInventoryByScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getCompleteMovementSerializedInventoryByScans_result()
    result.success = self._handler.getCompleteMovementSerializedInventoryByScans(args.startDate, args.endDate)
    oprot.writeMessageBegin("getCompleteMovementSerializedInventoryByScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getCompleteMovementNonSerializedInventoryByScans(self, seqid, iprot, oprot):
    args = getCompleteMovementNonSerializedInventoryByScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getCompleteMovementNonSerializedInventoryByScans_result()
    result.success = self._handler.getCompleteMovementNonSerializedInventoryByScans(args.startDate, args.endDate)
    oprot.writeMessageBegin("getCompleteMovementNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanfreebie(self, seqid, iprot, oprot):
    args = scanfreebie_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanfreebie_result()
    try:
      result.success = self._handler.scanfreebie(args.orderId, args.freebieItemId, args.freebieWarehouseId, args.scanType)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("scanfreebie", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_reshipfreebie(self, seqid, iprot, oprot):
    args = reshipfreebie_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = reshipfreebie_result()
    try:
      self._handler.reshipfreebie(args.oldOrderId, args.newOrderId, args.freebieItemId, args.scanType)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("reshipfreebie", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_isItemTransferAllowed(self, seqid, iprot, oprot):
    args = isItemTransferAllowed_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = isItemTransferAllowed_result()
    result.success = self._handler.isItemTransferAllowed(args.warehouseId, args.transferWarehouseId)
    oprot.writeMessageBegin("isItemTransferAllowed", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_createTransferLot(self, seqid, iprot, oprot):
    args = createTransferLot_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = createTransferLot_result()
    try:
      result.success = self._handler.createTransferLot(args.originWarehouseId, args.destWarehouseId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("createTransferLot", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getTransferLot(self, seqid, iprot, oprot):
    args = getTransferLot_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getTransferLot_result()
    try:
      result.success = self._handler.getTransferLot(args.transferLotId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getTransferLot", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_markTransferLotAsReceived(self, seqid, iprot, oprot):
    args = markTransferLotAsReceived_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = markTransferLotAsReceived_result()
    try:
      self._handler.markTransferLotAsReceived(args.id, args.remoteTransferRefNumber)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("markTransferLotAsReceived", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getTransferLotsByDate(self, seqid, iprot, oprot):
    args = getTransferLotsByDate_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getTransferLotsByDate_result()
    try:
      result.success = self._handler.getTransferLotsByDate(args.fromDate, args.toDate)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getTransferLotsByDate", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getAllowedDestinationWarehousesForTransfer(self, seqid, iprot, oprot):
    args = getAllowedDestinationWarehousesForTransfer_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getAllowedDestinationWarehousesForTransfer_result()
    result.success = self._handler.getAllowedDestinationWarehousesForTransfer(args.warehouseId)
    oprot.writeMessageBegin("getAllowedDestinationWarehousesForTransfer", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getItemsInTransferLot(self, seqid, iprot, oprot):
    args = getItemsInTransferLot_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getItemsInTransferLot_result()
    result.success = self._handler.getItemsInTransferLot(args.transferLotId)
    oprot.writeMessageBegin("getItemsInTransferLot", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_markItemsAsReceivedForTransferLot(self, seqid, iprot, oprot):
    args = markItemsAsReceivedForTransferLot_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = markItemsAsReceivedForTransferLot_result()
    try:
      self._handler.markItemsAsReceivedForTransferLot(args.id)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("markItemsAsReceivedForTransferLot", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_updateTransferLotAfterItemReceive(self, seqid, iprot, oprot):
    args = updateTransferLotAfterItemReceive_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = updateTransferLotAfterItemReceive_result()
    try:
      result.success = self._handler.updateTransferLotAfterItemReceive(args.id)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("updateTransferLotAfterItemReceive", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanForTransferOut(self, seqid, iprot, oprot):
    args = scanForTransferOut_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanForTransferOut_result()
    try:
      self._handler.scanForTransferOut(args.inventoryItems, args.type, args.transferLotId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("scanForTransferOut", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanForTransferIn(self, seqid, iprot, oprot):
    args = scanForTransferIn_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanForTransferIn_result()
    try:
      self._handler.scanForTransferIn(args.inventoryItems, args.type, args.transferLotId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("scanForTransferIn", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanForOursThirdPartyReceive(self, seqid, iprot, oprot):
    args = scanForOursThirdPartyReceive_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanForOursThirdPartyReceive_result()
    try:
      self._handler.scanForOursThirdPartyReceive(args.inventoryItems, args.id)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("scanForOursThirdPartyReceive", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(self, seqid, iprot, oprot):
    args = getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_result()
    try:
      result.success = self._handler.getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(args.itemId, args.physicalWarehouseId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getInTransitInventory(self, seqid, iprot, oprot):
    args = getInTransitInventory_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInTransitInventory_result()
    result.success = self._handler.getInTransitInventory(args.originWarehouseId)
    oprot.writeMessageBegin("getInTransitInventory", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_isItemAvailableForSale(self, seqid, iprot, oprot):
    args = isItemAvailableForSale_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = isItemAvailableForSale_result()
    try:
      result.success = self._handler.isItemAvailableForSale(args.itemId, args.serialNumber, args.warehouseId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("isItemAvailableForSale", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getHistoricBadInventoryByScans(self, seqid, iprot, oprot):
    args = getHistoricBadInventoryByScans_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getHistoricBadInventoryByScans_result()
    try:
      result.success = self._handler.getHistoricBadInventoryByScans(args.date)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getHistoricBadInventoryByScans", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanForBadSale(self, seqid, iprot, oprot):
    args = scanForBadSale_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanForBadSale_result()
    try:
      result.success = self._handler.scanForBadSale(args.serialNumber, args.itemNumber, args.itemId, args.orderId, args.fulfilmentWarehouseId, args.quantity, args.billingWarehouseId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("scanForBadSale", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getTransferLotItemsForMarkReceive(self, seqid, iprot, oprot):
    args = getTransferLotItemsForMarkReceive_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getTransferLotItemsForMarkReceive_result()
    try:
      result.success = self._handler.getTransferLotItemsForMarkReceive(args.transferLotId, args.scanType)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getTransferLotItemsForMarkReceive", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_markItemsAsReceivedForTransferLotPartial(self, seqid, iprot, oprot):
    args = markItemsAsReceivedForTransferLotPartial_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = markItemsAsReceivedForTransferLotPartial_result()
    try:
      self._handler.markItemsAsReceivedForTransferLotPartial(args.inventoryItems, args.transferLotId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("markItemsAsReceivedForTransferLotPartial", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_markTransferLotAsReceivedPartial(self, seqid, iprot, oprot):
    args = markTransferLotAsReceivedPartial_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = markTransferLotAsReceivedPartial_result()
    try:
      self._handler.markTransferLotAsReceivedPartial(args.id, args.remoteTransferRefNumber)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("markTransferLotAsReceivedPartial", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getInventoryItemScannedInForPO(self, seqid, iprot, oprot):
    args = getInventoryItemScannedInForPO_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInventoryItemScannedInForPO_result()
    try:
      result.success = self._handler.getInventoryItemScannedInForPO(args.itemId, args.purchaseIds)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getInventoryItemScannedInForPO", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getAmazonTransferredSkuDetails(self, seqid, iprot, oprot):
    args = getAmazonTransferredSkuDetails_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getAmazonTransferredSkuDetails_result()
    try:
      result.success = self._handler.getAmazonTransferredSkuDetails(args.itemIds)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getAmazonTransferredSkuDetails", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getScansforPurchase(self, seqid, iprot, oprot):
    args = getScansforPurchase_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getScansforPurchase_result()
    try:
      result.success = self._handler.getScansforPurchase(args.purchaseId, args.scanType)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getScansforPurchase", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getCurrentBadQuantityForItem(self, seqid, iprot, oprot):
    args = getCurrentBadQuantityForItem_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getCurrentBadQuantityForItem_result()
    try:
      result.success = self._handler.getCurrentBadQuantityForItem(args.itemId, args.currentWarehouseId, args.physicalWarehouseId)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getCurrentBadQuantityForItem", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanForBadPurchaseReturn(self, seqid, iprot, oprot):
    args = scanForBadPurchaseReturn_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanForBadPurchaseReturn_result()
    try:
      result.success = self._handler.scanForBadPurchaseReturn(args.saleReturnItems, args.vendorId, args.billingWarehouseId)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("scanForBadPurchaseReturn", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getItemsInPurchaseReturn(self, seqid, iprot, oprot):
    args = getItemsInPurchaseReturn_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getItemsInPurchaseReturn_result()
    try:
      result.success = self._handler.getItemsInPurchaseReturn(args.purchaseReturnId, args.type, args.returnTime)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("getItemsInPurchaseReturn", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getScansForInventoryItem(self, seqid, iprot, oprot):
    args = getScansForInventoryItem_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getScansForInventoryItem_result()
    try:
      result.success = self._handler.getScansForInventoryItem(args.inventoryItemId, args.type)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("getScansForInventoryItem", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_checkGrnImeiStatus(self, seqid, iprot, oprot):
    args = checkGrnImeiStatus_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = checkGrnImeiStatus_result()
    try:
      result.success = self._handler.checkGrnImeiStatus(args.imeiNos)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("checkGrnImeiStatus", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getInventoryAgeConsideredItems(self, seqid, iprot, oprot):
    args = getInventoryAgeConsideredItems_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInventoryAgeConsideredItems_result()
    try:
      result.success = self._handler.getInventoryAgeConsideredItems(args.itemId)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("getInventoryAgeConsideredItems", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getCompleteMovementForThirdPartyWarehouse(self, seqid, iprot, oprot):
    args = getCompleteMovementForThirdPartyWarehouse_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getCompleteMovementForThirdPartyWarehouse_result()
    result.success = self._handler.getCompleteMovementForThirdPartyWarehouse(args.startDate, args.endDate)
    oprot.writeMessageBegin("getCompleteMovementForThirdPartyWarehouse", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getAllDoaOutInventoryItems(self, seqid, iprot, oprot):
    args = getAllDoaOutInventoryItems_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getAllDoaOutInventoryItems_result()
    try:
      result.success = self._handler.getAllDoaOutInventoryItems()
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("getAllDoaOutInventoryItems", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getAllUnCompletedStockShipments(self, seqid, iprot, oprot):
    args = getAllUnCompletedStockShipments_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getAllUnCompletedStockShipments_result()
    try:
      result.success = self._handler.getAllUnCompletedStockShipments(args.source)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("getAllUnCompletedStockShipments", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getRemovalStockShipmentReferenceById(self, seqid, iprot, oprot):
    args = getRemovalStockShipmentReferenceById_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getRemovalStockShipmentReferenceById_result()
    try:
      result.success = self._handler.getRemovalStockShipmentReferenceById(args.id)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("getRemovalStockShipmentReferenceById", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_createRemovalStockShipmentReference(self, seqid, iprot, oprot):
    args = createRemovalStockShipmentReference_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = createRemovalStockShipmentReference_result()
    try:
      result.success = self._handler.createRemovalStockShipmentReference(args.removalStockShipmentReference)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("createRemovalStockShipmentReference", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_updateShipmentReferenceTransferLot(self, seqid, iprot, oprot):
    args = updateShipmentReferenceTransferLot_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = updateShipmentReferenceTransferLot_result()
    try:
      self._handler.updateShipmentReferenceTransferLot(args.transferLotId, args.shipmentReferenceId)
    except WarehouseServiceException, ex:
      result.ex = ex
    oprot.writeMessageBegin("updateShipmentReferenceTransferLot", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_fetchScansPerTransferInvoiceNumber(self, seqid, iprot, oprot):
    args = fetchScansPerTransferInvoiceNumber_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = fetchScansPerTransferInvoiceNumber_result()
    result.success = self._handler.fetchScansPerTransferInvoiceNumber(args.date)
    oprot.writeMessageBegin("fetchScansPerTransferInvoiceNumber", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getInventoryItems(self, seqid, iprot, oprot):
    args = getInventoryItems_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInventoryItems_result()
    try:
      result.success = self._handler.getInventoryItems(args.serialNumbers)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getInventoryItems", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_getInventoryItemsBySerailNumbers(self, seqid, iprot, oprot):
    args = getInventoryItemsBySerailNumbers_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = getInventoryItemsBySerailNumbers_result()
    try:
      result.success = self._handler.getInventoryItemsBySerailNumbers(args.serialNumbers)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("getInventoryItemsBySerailNumbers", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()

  def process_scanPurchaseBulk(self, seqid, iprot, oprot):
    args = scanPurchaseBulk_args()
    args.read(iprot)
    iprot.readMessageEnd()
    result = scanPurchaseBulk_result()
    try:
      self._handler.scanPurchaseBulk(args.inventoryItems)
    except WarehouseServiceException, wex:
      result.wex = wex
    oprot.writeMessageBegin("scanPurchaseBulk", TMessageType.REPLY, seqid)
    result.write(oprot)
    oprot.writeMessageEnd()
    oprot.trans.flush()


# HELPER FUNCTIONS AND STRUCTURES

class getInventoryItem_args:
  """
  Attributes:
   - serialNumber
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
  )

  def __init__(self, serialNumber=None,):
    self.serialNumber = serialNumber

  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.STRING:
          self.serialNumber = 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('getInventoryItem_args')
    if self.serialNumber is not None:
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
      oprot.writeString(self.serialNumber)
      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 getInventoryItem_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = InventoryItem()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getInventoryItem_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getNonSeralizedInventoryItem_args:
  """
  Attributes:
   - itemNumber
   - itemId
   - fulfilmentWarehouseId
   - billingWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
    (2, TType.I64, 'itemId', None, None, ), # 2
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
  )

  def __init__(self, itemNumber=None, itemId=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
    self.itemNumber = itemNumber
    self.itemId = itemId
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
    self.billingWarehouseId = billingWarehouseId

  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.STRING:
          self.itemNumber = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.itemId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.fulfilmentWarehouseId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.billingWarehouseId = 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('getNonSeralizedInventoryItem_args')
    if self.itemNumber is not None:
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
      oprot.writeString(self.itemNumber)
      oprot.writeFieldEnd()
    if self.itemId is not None:
      oprot.writeFieldBegin('itemId', TType.I64, 2)
      oprot.writeI64(self.itemId)
      oprot.writeFieldEnd()
    if self.fulfilmentWarehouseId is not None:
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
      oprot.writeI64(self.fulfilmentWarehouseId)
      oprot.writeFieldEnd()
    if self.billingWarehouseId is not None:
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
      oprot.writeI64(self.billingWarehouseId)
      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 getNonSeralizedInventoryItem_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = InventoryItem()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getNonSeralizedInventoryItem_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 scan_args:
  """
  Attributes:
   - inventoryItem
   - type
   - quantity
   - billingWarehouseId
   - transferLotId
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
    (2, TType.I32, 'type', None, None, ), # 2
    (3, TType.I64, 'quantity', None, None, ), # 3
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
    (5, TType.I64, 'transferLotId', None, None, ), # 5
  )

  def __init__(self, inventoryItem=None, type=None, quantity=None, billingWarehouseId=None, transferLotId=None,):
    self.inventoryItem = inventoryItem
    self.type = type
    self.quantity = quantity
    self.billingWarehouseId = billingWarehouseId
    self.transferLotId = transferLotId

  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.inventoryItem = InventoryItem()
          self.inventoryItem.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.type = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.quantity = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.billingWarehouseId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I64:
          self.transferLotId = 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('scan_args')
    if self.inventoryItem is not None:
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
      self.inventoryItem.write(oprot)
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.I32, 2)
      oprot.writeI32(self.type)
      oprot.writeFieldEnd()
    if self.quantity is not None:
      oprot.writeFieldBegin('quantity', TType.I64, 3)
      oprot.writeI64(self.quantity)
      oprot.writeFieldEnd()
    if self.billingWarehouseId is not None:
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
      oprot.writeI64(self.billingWarehouseId)
      oprot.writeFieldEnd()
    if self.transferLotId is not None:
      oprot.writeFieldBegin('transferLotId', TType.I64, 5)
      oprot.writeI64(self.transferLotId)
      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 scan_result:
  """
  Attributes:
   - wex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, wex=None,):
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('scan_result')
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 genericScan_args:
  """
  Attributes:
   - inventoryItem
   - scan
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'scan', (Scan, Scan.thrift_spec), None, ), # 2
  )

  def __init__(self, inventoryItem=None, scan=None,):
    self.inventoryItem = inventoryItem
    self.scan = scan

  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.inventoryItem = InventoryItem()
          self.inventoryItem.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.scan = Scan()
          self.scan.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('genericScan_args')
    if self.inventoryItem is not None:
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
      self.inventoryItem.write(oprot)
      oprot.writeFieldEnd()
    if self.scan is not None:
      oprot.writeFieldBegin('scan', TType.STRUCT, 2)
      self.scan.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 genericScan_result:
  """
  Attributes:
   - wex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, wex=None,):
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('genericScan_result')
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 scanSerializedItemForOrder_args:
  """
  Attributes:
   - serialNumber
   - type
   - orderId
   - fulfilmentWarehouseId
   - quantity
   - billingWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
    (2, TType.I32, 'type', None, None, ), # 2
    (3, TType.I64, 'orderId', None, None, ), # 3
    (4, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 4
    (5, TType.DOUBLE, 'quantity', None, None, ), # 5
    (6, TType.I64, 'billingWarehouseId', None, None, ), # 6
  )

  def __init__(self, serialNumber=None, type=None, orderId=None, fulfilmentWarehouseId=None, quantity=None, billingWarehouseId=None,):
    self.serialNumber = serialNumber
    self.type = type
    self.orderId = orderId
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
    self.quantity = quantity
    self.billingWarehouseId = billingWarehouseId

  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.STRING:
          self.serialNumber = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.type = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.orderId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.fulfilmentWarehouseId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.DOUBLE:
          self.quantity = iprot.readDouble();
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.I64:
          self.billingWarehouseId = 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('scanSerializedItemForOrder_args')
    if self.serialNumber is not None:
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
      oprot.writeString(self.serialNumber)
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.I32, 2)
      oprot.writeI32(self.type)
      oprot.writeFieldEnd()
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 3)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.fulfilmentWarehouseId is not None:
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 4)
      oprot.writeI64(self.fulfilmentWarehouseId)
      oprot.writeFieldEnd()
    if self.quantity is not None:
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 5)
      oprot.writeDouble(self.quantity)
      oprot.writeFieldEnd()
    if self.billingWarehouseId is not None:
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 6)
      oprot.writeI64(self.billingWarehouseId)
      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 scanSerializedItemForOrder_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = InventoryItem()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('scanSerializedItemForOrder_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 scanForOrder_args:
  """
  Attributes:
   - inventoryItem
   - type
   - quantity
   - orderId
   - fulfilmentWarehouseId
   - billingWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
    (2, TType.I32, 'type', None, None, ), # 2
    (3, TType.I64, 'quantity', None, None, ), # 3
    (4, TType.I64, 'orderId', None, None, ), # 4
    (5, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 5
    (6, TType.I64, 'billingWarehouseId', None, None, ), # 6
  )

  def __init__(self, inventoryItem=None, type=None, quantity=None, orderId=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
    self.inventoryItem = inventoryItem
    self.type = type
    self.quantity = quantity
    self.orderId = orderId
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
    self.billingWarehouseId = billingWarehouseId

  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.inventoryItem = InventoryItem()
          self.inventoryItem.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.type = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.quantity = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.orderId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I64:
          self.fulfilmentWarehouseId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.I64:
          self.billingWarehouseId = 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('scanForOrder_args')
    if self.inventoryItem is not None:
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
      self.inventoryItem.write(oprot)
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.I32, 2)
      oprot.writeI32(self.type)
      oprot.writeFieldEnd()
    if self.quantity is not None:
      oprot.writeFieldBegin('quantity', TType.I64, 3)
      oprot.writeI64(self.quantity)
      oprot.writeFieldEnd()
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 4)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.fulfilmentWarehouseId is not None:
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 5)
      oprot.writeI64(self.fulfilmentWarehouseId)
      oprot.writeFieldEnd()
    if self.billingWarehouseId is not None:
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 6)
      oprot.writeI64(self.billingWarehouseId)
      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 scanForOrder_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = InventoryItem()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('scanForOrder_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 createItemNumberMapping_args:
  """
  Attributes:
   - itemNumber
   - itemId
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
    (2, TType.I64, 'itemId', None, None, ), # 2
  )

  def __init__(self, itemNumber=None, itemId=None,):
    self.itemNumber = itemNumber
    self.itemId = itemId

  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.STRING:
          self.itemNumber = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.itemId = 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('createItemNumberMapping_args')
    if self.itemNumber is not None:
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
      oprot.writeString(self.itemNumber)
      oprot.writeFieldEnd()
    if self.itemId is not None:
      oprot.writeFieldBegin('itemId', TType.I64, 2)
      oprot.writeI64(self.itemId)
      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 createItemNumberMapping_result:

  thrift_spec = (
  )

  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
      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('createItemNumberMapping_result')
    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 getItemNumbers_args:
  """
  Attributes:
   - itemId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'itemId', None, None, ), # 1
  )

  def __init__(self, itemId=None,):
    self.itemId = itemId

  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.itemId = 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('getItemNumbers_args')
    if self.itemId is not None:
      oprot.writeFieldBegin('itemId', TType.I64, 1)
      oprot.writeI64(self.itemId)
      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 getItemNumbers_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRING,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.LIST:
          self.success = []
          (_etype3, _size0) = iprot.readListBegin()
          for _i4 in xrange(_size0):
            _elem5 = iprot.readString();
            self.success.append(_elem5)
          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('getItemNumbers_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRING, len(self.success))
      for iter6 in self.success:
        oprot.writeString(iter6)
      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 getItemIds_args:
  """
  Attributes:
   - itemNumber
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
  )

  def __init__(self, itemNumber=None,):
    self.itemNumber = itemNumber

  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.STRING:
          self.itemNumber = 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('getItemIds_args')
    if self.itemNumber is not None:
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
      oprot.writeString(self.itemNumber)
      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 getItemIds_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.I64,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.LIST:
          self.success = []
          (_etype10, _size7) = iprot.readListBegin()
          for _i11 in xrange(_size7):
            _elem12 = iprot.readI64();
            self.success.append(_elem12)
          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('getItemIds_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.I64, len(self.success))
      for iter13 in self.success:
        oprot.writeI64(iter13)
      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 getInventoryItemsFromLastScanType_args:
  """
  Attributes:
   - lastScanType
  """

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'lastScanType', None, None, ), # 1
  )

  def __init__(self, lastScanType=None,):
    self.lastScanType = lastScanType

  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.I32:
          self.lastScanType = iprot.readI32();
        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('getInventoryItemsFromLastScanType_args')
    if self.lastScanType is not None:
      oprot.writeFieldBegin('lastScanType', TType.I32, 1)
      oprot.writeI32(self.lastScanType)
      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 getInventoryItemsFromLastScanType_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = []
          (_etype17, _size14) = iprot.readListBegin()
          for _i18 in xrange(_size14):
            _elem19 = InventoryItem()
            _elem19.read(iprot)
            self.success.append(_elem19)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getInventoryItemsFromLastScanType_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter20 in self.success:
        iter20.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getInventoryItemFromId_args:
  """
  Attributes:
   - inventoryItemId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'inventoryItemId', None, None, ), # 1
  )

  def __init__(self, inventoryItemId=None,):
    self.inventoryItemId = inventoryItemId

  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.inventoryItemId = 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('getInventoryItemFromId_args')
    if self.inventoryItemId is not None:
      oprot.writeFieldBegin('inventoryItemId', TType.I64, 1)
      oprot.writeI64(self.inventoryItemId)
      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 getInventoryItemFromId_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = InventoryItem()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getInventoryItemFromId_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getPurchaseScans_args:
  """
  Attributes:
   - startDate
   - endDate
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'startDate', None, None, ), # 1
    (2, TType.I64, 'endDate', None, None, ), # 2
  )

  def __init__(self, startDate=None, endDate=None,):
    self.startDate = startDate
    self.endDate = endDate

  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.startDate = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.endDate = 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('getPurchaseScans_args')
    if self.startDate is not None:
      oprot.writeFieldBegin('startDate', TType.I64, 1)
      oprot.writeI64(self.startDate)
      oprot.writeFieldEnd()
    if self.endDate is not None:
      oprot.writeFieldBegin('endDate', TType.I64, 2)
      oprot.writeI64(self.endDate)
      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 getPurchaseScans_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(DetailedPurchaseScan, DetailedPurchaseScan.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 = []
          (_etype24, _size21) = iprot.readListBegin()
          for _i25 in xrange(_size21):
            _elem26 = DetailedPurchaseScan()
            _elem26.read(iprot)
            self.success.append(_elem26)
          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('getPurchaseScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter27 in self.success:
        iter27.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 getPurchaseScansByGrnDate_args:
  """
  Attributes:
   - startDate
   - endDate
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'startDate', None, None, ), # 1
    (2, TType.I64, 'endDate', None, None, ), # 2
  )

  def __init__(self, startDate=None, endDate=None,):
    self.startDate = startDate
    self.endDate = endDate

  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.startDate = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.endDate = 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('getPurchaseScansByGrnDate_args')
    if self.startDate is not None:
      oprot.writeFieldBegin('startDate', TType.I64, 1)
      oprot.writeI64(self.startDate)
      oprot.writeFieldEnd()
    if self.endDate is not None:
      oprot.writeFieldBegin('endDate', TType.I64, 2)
      oprot.writeI64(self.endDate)
      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 getPurchaseScansByGrnDate_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(DetailedPurchaseScan, DetailedPurchaseScan.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 = []
          (_etype31, _size28) = iprot.readListBegin()
          for _i32 in xrange(_size28):
            _elem33 = DetailedPurchaseScan()
            _elem33.read(iprot)
            self.success.append(_elem33)
          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('getPurchaseScansByGrnDate_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter34 in self.success:
        iter34.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 getEmptyGrnsByDate_args:
  """
  Attributes:
   - startDate
   - endDate
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'startDate', None, None, ), # 1
    (2, TType.I64, 'endDate', None, None, ), # 2
  )

  def __init__(self, startDate=None, endDate=None,):
    self.startDate = startDate
    self.endDate = endDate

  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.startDate = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.endDate = 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('getEmptyGrnsByDate_args')
    if self.startDate is not None:
      oprot.writeFieldBegin('startDate', TType.I64, 1)
      oprot.writeI64(self.startDate)
      oprot.writeFieldEnd()
    if self.endDate is not None:
      oprot.writeFieldBegin('endDate', TType.I64, 2)
      oprot.writeI64(self.endDate)
      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 getEmptyGrnsByDate_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.I64,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.LIST:
          self.success = []
          (_etype38, _size35) = iprot.readListBegin()
          for _i39 in xrange(_size35):
            _elem40 = iprot.readI64();
            self.success.append(_elem40)
          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('getEmptyGrnsByDate_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.I64, len(self.success))
      for iter41 in self.success:
        oprot.writeI64(iter41)
      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 fetchScansPerInvoiceNumber_args:
  """
  Attributes:
   - date
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'date', None, None, ), # 1
  )

  def __init__(self, date=None,):
    self.date = date

  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.date = 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('fetchScansPerInvoiceNumber_args')
    if self.date is not None:
      oprot.writeFieldBegin('date', TType.I64, 1)
      oprot.writeI64(self.date)
      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 fetchScansPerInvoiceNumber_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InvoiceScan, InvoiceScan.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 = []
          (_etype45, _size42) = iprot.readListBegin()
          for _i46 in xrange(_size42):
            _elem47 = InvoiceScan()
            _elem47.read(iprot)
            self.success.append(_elem47)
          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('fetchScansPerInvoiceNumber_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter48 in self.success:
        iter48.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 getInventoryItemFromOrder_args:
  """
  Attributes:
   - orderId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'orderId', None, None, ), # 1
  )

  def __init__(self, orderId=None,):
    self.orderId = orderId

  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.orderId = 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('getInventoryItemFromOrder_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      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 getInventoryItemFromOrder_result:
  """
  Attributes:
   - success
   - we
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'we', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, we=None,):
    self.success = success
    self.we = we

  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 = InventoryItem()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.we = WarehouseServiceException()
          self.we.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('getInventoryItemFromOrder_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.we is not None:
      oprot.writeFieldBegin('we', TType.STRUCT, 1)
      self.we.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 getInventoryAge_args:

  thrift_spec = (
  )

  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
      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('getInventoryAge_args')
    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 getInventoryAge_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAge, InventoryAge.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 = []
          (_etype52, _size49) = iprot.readListBegin()
          for _i53 in xrange(_size49):
            _elem54 = InventoryAge()
            _elem54.read(iprot)
            self.success.append(_elem54)
          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('getInventoryAge_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter55 in self.success:
        iter55.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 getInventoryScansForItem_args:
  """
  Attributes:
   - itemId
   - fromDate
   - toDate
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'itemId', None, None, ), # 1
    (2, TType.I64, 'fromDate', None, None, ), # 2
    (3, TType.I64, 'toDate', None, None, ), # 3
  )

  def __init__(self, itemId=None, fromDate=None, toDate=None,):
    self.itemId = itemId
    self.fromDate = fromDate
    self.toDate = toDate

  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.itemId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.fromDate = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.toDate = 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('getInventoryScansForItem_args')
    if self.itemId is not None:
      oprot.writeFieldBegin('itemId', TType.I64, 1)
      oprot.writeI64(self.itemId)
      oprot.writeFieldEnd()
    if self.fromDate is not None:
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
      oprot.writeI64(self.fromDate)
      oprot.writeFieldEnd()
    if self.toDate is not None:
      oprot.writeFieldBegin('toDate', TType.I64, 3)
      oprot.writeI64(self.toDate)
      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 getInventoryScansForItem_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.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 = []
          (_etype59, _size56) = iprot.readListBegin()
          for _i60 in xrange(_size56):
            _elem61 = Scan()
            _elem61.read(iprot)
            self.success.append(_elem61)
          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('getInventoryScansForItem_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter62 in self.success:
        iter62.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 getScanRecordsForSerialNumber_args:
  """
  Attributes:
   - serialNumber
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
  )

  def __init__(self, serialNumber=None,):
    self.serialNumber = serialNumber

  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.STRING:
          self.serialNumber = 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('getScanRecordsForSerialNumber_args')
    if self.serialNumber is not None:
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
      oprot.writeString(self.serialNumber)
      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 getScanRecordsForSerialNumber_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.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 = []
          (_etype66, _size63) = iprot.readListBegin()
          for _i67 in xrange(_size63):
            _elem68 = Scan()
            _elem68.read(iprot)
            self.success.append(_elem68)
          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('getScanRecordsForSerialNumber_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter69 in self.success:
        iter69.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 scanForPurchaseReturn_args:
  """
  Attributes:
   - saleReturnItems
   - vendorId
   - billingWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'saleReturnItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
    (2, TType.I64, 'vendorId', None, None, ), # 2
    (3, TType.I64, 'billingWarehouseId', None, None, ), # 3
  )

  def __init__(self, saleReturnItems=None, vendorId=None, billingWarehouseId=None,):
    self.saleReturnItems = saleReturnItems
    self.vendorId = vendorId
    self.billingWarehouseId = billingWarehouseId

  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.saleReturnItems = []
          (_etype73, _size70) = iprot.readListBegin()
          for _i74 in xrange(_size70):
            _elem75 = InventoryItem()
            _elem75.read(iprot)
            self.saleReturnItems.append(_elem75)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.vendorId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.billingWarehouseId = 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('scanForPurchaseReturn_args')
    if self.saleReturnItems is not None:
      oprot.writeFieldBegin('saleReturnItems', TType.LIST, 1)
      oprot.writeListBegin(TType.STRUCT, len(self.saleReturnItems))
      for iter76 in self.saleReturnItems:
        iter76.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.vendorId is not None:
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
      oprot.writeI64(self.vendorId)
      oprot.writeFieldEnd()
    if self.billingWarehouseId is not None:
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 3)
      oprot.writeI64(self.billingWarehouseId)
      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 scanForPurchaseReturn_result:
  """
  Attributes:
   - success
   - ex
  """

  thrift_spec = (
    (0, TType.I64, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.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 = WarehouseServiceException()
          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('scanForPurchaseReturn_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 scanForLostItem_args:
  """
  Attributes:
   - lostItems
   - vendorId
   - billingWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'lostItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
    (2, TType.I64, 'vendorId', None, None, ), # 2
    (3, TType.I64, 'billingWarehouseId', None, None, ), # 3
  )

  def __init__(self, lostItems=None, vendorId=None, billingWarehouseId=None,):
    self.lostItems = lostItems
    self.vendorId = vendorId
    self.billingWarehouseId = billingWarehouseId

  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.lostItems = []
          (_etype80, _size77) = iprot.readListBegin()
          for _i81 in xrange(_size77):
            _elem82 = InventoryItem()
            _elem82.read(iprot)
            self.lostItems.append(_elem82)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.vendorId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.billingWarehouseId = 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('scanForLostItem_args')
    if self.lostItems is not None:
      oprot.writeFieldBegin('lostItems', TType.LIST, 1)
      oprot.writeListBegin(TType.STRUCT, len(self.lostItems))
      for iter83 in self.lostItems:
        iter83.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.vendorId is not None:
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
      oprot.writeI64(self.vendorId)
      oprot.writeFieldEnd()
    if self.billingWarehouseId is not None:
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 3)
      oprot.writeI64(self.billingWarehouseId)
      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 scanForLostItem_result:
  """
  Attributes:
   - ex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, ex=None,):
    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 == 1:
        if ftype == TType.STRUCT:
          self.ex = WarehouseServiceException()
          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('scanForLostItem_result')
    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 getCurrentSerializedInventoryByScans_args:
  """
  Attributes:
   - physicalWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'physicalWarehouseId', None, None, ), # 1
  )

  def __init__(self, physicalWarehouseId=None,):
    self.physicalWarehouseId = physicalWarehouseId

  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.physicalWarehouseId = 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('getCurrentSerializedInventoryByScans_args')
    if self.physicalWarehouseId is not None:
      oprot.writeFieldBegin('physicalWarehouseId', TType.I64, 1)
      oprot.writeI64(self.physicalWarehouseId)
      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 getCurrentSerializedInventoryByScans_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.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 = []
          (_etype87, _size84) = iprot.readListBegin()
          for _i88 in xrange(_size84):
            _elem89 = InventoryAvailability()
            _elem89.read(iprot)
            self.success.append(_elem89)
          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('getCurrentSerializedInventoryByScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter90 in self.success:
        iter90.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 getCurrentNonSerializedInventoryByScans_args:
  """
  Attributes:
   - physicalWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'physicalWarehouseId', None, None, ), # 1
  )

  def __init__(self, physicalWarehouseId=None,):
    self.physicalWarehouseId = physicalWarehouseId

  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.physicalWarehouseId = 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('getCurrentNonSerializedInventoryByScans_args')
    if self.physicalWarehouseId is not None:
      oprot.writeFieldBegin('physicalWarehouseId', TType.I64, 1)
      oprot.writeI64(self.physicalWarehouseId)
      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 getCurrentNonSerializedInventoryByScans_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.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 = []
          (_etype94, _size91) = iprot.readListBegin()
          for _i95 in xrange(_size91):
            _elem96 = InventoryAvailability()
            _elem96.read(iprot)
            self.success.append(_elem96)
          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('getCurrentNonSerializedInventoryByScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter97 in self.success:
        iter97.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 getHistoricSerializedInventoryByScans_args:
  """
  Attributes:
   - date
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'date', None, None, ), # 1
  )

  def __init__(self, date=None,):
    self.date = date

  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.date = 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('getHistoricSerializedInventoryByScans_args')
    if self.date is not None:
      oprot.writeFieldBegin('date', TType.I64, 1)
      oprot.writeI64(self.date)
      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 getHistoricSerializedInventoryByScans_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.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 = []
          (_etype101, _size98) = iprot.readListBegin()
          for _i102 in xrange(_size98):
            _elem103 = InventoryAvailability()
            _elem103.read(iprot)
            self.success.append(_elem103)
          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('getHistoricSerializedInventoryByScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter104 in self.success:
        iter104.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 getHistoricNonSerializedInventoryByScans_args:
  """
  Attributes:
   - date
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'date', None, None, ), # 1
  )

  def __init__(self, date=None,):
    self.date = date

  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.date = 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('getHistoricNonSerializedInventoryByScans_args')
    if self.date is not None:
      oprot.writeFieldBegin('date', TType.I64, 1)
      oprot.writeI64(self.date)
      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 getHistoricNonSerializedInventoryByScans_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.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 = []
          (_etype108, _size105) = iprot.readListBegin()
          for _i109 in xrange(_size105):
            _elem110 = InventoryAvailability()
            _elem110.read(iprot)
            self.success.append(_elem110)
          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('getHistoricNonSerializedInventoryByScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter111 in self.success:
        iter111.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 getOurHistoricSerializedInventoryByScans_args:
  """
  Attributes:
   - date
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'date', None, None, ), # 1
  )

  def __init__(self, date=None,):
    self.date = date

  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.date = 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('getOurHistoricSerializedInventoryByScans_args')
    if self.date is not None:
      oprot.writeFieldBegin('date', TType.I64, 1)
      oprot.writeI64(self.date)
      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 getOurHistoricSerializedInventoryByScans_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.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 = []
          (_etype115, _size112) = iprot.readListBegin()
          for _i116 in xrange(_size112):
            _elem117 = InventoryAvailability()
            _elem117.read(iprot)
            self.success.append(_elem117)
          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('getOurHistoricSerializedInventoryByScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter118 in self.success:
        iter118.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 getOurHistoricNonSerializedInventoryByScans_args:
  """
  Attributes:
   - date
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'date', None, None, ), # 1
  )

  def __init__(self, date=None,):
    self.date = date

  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.date = 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('getOurHistoricNonSerializedInventoryByScans_args')
    if self.date is not None:
      oprot.writeFieldBegin('date', TType.I64, 1)
      oprot.writeI64(self.date)
      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 getOurHistoricNonSerializedInventoryByScans_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.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 = []
          (_etype122, _size119) = iprot.readListBegin()
          for _i123 in xrange(_size119):
            _elem124 = InventoryAvailability()
            _elem124.read(iprot)
            self.success.append(_elem124)
          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('getOurHistoricNonSerializedInventoryByScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter125 in self.success:
        iter125.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 scanForOursExternalSale_args:
  """
  Attributes:
   - itemId
   - serialNumber
   - itemNumber
   - invoiceNumber
   - warehouseId
   - unitPrice
   - nlc
   - orderId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'itemId', None, None, ), # 1
    (2, TType.STRING, 'serialNumber', None, None, ), # 2
    (3, TType.STRING, 'itemNumber', None, None, ), # 3
    (4, TType.STRING, 'invoiceNumber', None, None, ), # 4
    (5, TType.I64, 'warehouseId', None, None, ), # 5
    (6, TType.DOUBLE, 'unitPrice', None, None, ), # 6
    (7, TType.DOUBLE, 'nlc', None, None, ), # 7
    (8, TType.I64, 'orderId', None, None, ), # 8
  )

  def __init__(self, itemId=None, serialNumber=None, itemNumber=None, invoiceNumber=None, warehouseId=None, unitPrice=None, nlc=None, orderId=None,):
    self.itemId = itemId
    self.serialNumber = serialNumber
    self.itemNumber = itemNumber
    self.invoiceNumber = invoiceNumber
    self.warehouseId = warehouseId
    self.unitPrice = unitPrice
    self.nlc = nlc
    self.orderId = orderId

  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.itemId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.serialNumber = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.itemNumber = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.invoiceNumber = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I64:
          self.warehouseId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.DOUBLE:
          self.unitPrice = iprot.readDouble();
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.DOUBLE:
          self.nlc = iprot.readDouble();
        else:
          iprot.skip(ftype)
      elif fid == 8:
        if ftype == TType.I64:
          self.orderId = 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('scanForOursExternalSale_args')
    if self.itemId is not None:
      oprot.writeFieldBegin('itemId', TType.I64, 1)
      oprot.writeI64(self.itemId)
      oprot.writeFieldEnd()
    if self.serialNumber is not None:
      oprot.writeFieldBegin('serialNumber', TType.STRING, 2)
      oprot.writeString(self.serialNumber)
      oprot.writeFieldEnd()
    if self.itemNumber is not None:
      oprot.writeFieldBegin('itemNumber', TType.STRING, 3)
      oprot.writeString(self.itemNumber)
      oprot.writeFieldEnd()
    if self.invoiceNumber is not None:
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 4)
      oprot.writeString(self.invoiceNumber)
      oprot.writeFieldEnd()
    if self.warehouseId is not None:
      oprot.writeFieldBegin('warehouseId', TType.I64, 5)
      oprot.writeI64(self.warehouseId)
      oprot.writeFieldEnd()
    if self.unitPrice is not None:
      oprot.writeFieldBegin('unitPrice', TType.DOUBLE, 6)
      oprot.writeDouble(self.unitPrice)
      oprot.writeFieldEnd()
    if self.nlc is not None:
      oprot.writeFieldBegin('nlc', TType.DOUBLE, 7)
      oprot.writeDouble(self.nlc)
      oprot.writeFieldEnd()
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 8)
      oprot.writeI64(self.orderId)
      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 scanForOursExternalSale_result:
  """
  Attributes:
   - success
   - ex
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.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 = InventoryItem()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ex = WarehouseServiceException()
          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('scanForOursExternalSale_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 scanForOursExternalSaleReturn_args:
  """
  Attributes:
   - orderId
   - unitPrice
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'orderId', None, None, ), # 1
    (2, TType.DOUBLE, 'unitPrice', None, None, ), # 2
  )

  def __init__(self, orderId=None, unitPrice=None,):
    self.orderId = orderId
    self.unitPrice = unitPrice

  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.orderId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.DOUBLE:
          self.unitPrice = iprot.readDouble();
        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('scanForOursExternalSaleReturn_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.unitPrice is not None:
      oprot.writeFieldBegin('unitPrice', TType.DOUBLE, 2)
      oprot.writeDouble(self.unitPrice)
      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 scanForOursExternalSaleReturn_result:
  """
  Attributes:
   - ex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, ex=None,):
    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 == 1:
        if ftype == TType.STRUCT:
          self.ex = WarehouseServiceException()
          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('scanForOursExternalSaleReturn_result')
    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 getMovementNonSerializedInventoryByScans_args:
  """
  Attributes:
   - startDate
   - endDate
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'startDate', None, None, ), # 1
    (2, TType.I64, 'endDate', None, None, ), # 2
  )

  def __init__(self, startDate=None, endDate=None,):
    self.startDate = startDate
    self.endDate = endDate

  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.startDate = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.endDate = 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('getMovementNonSerializedInventoryByScans_args')
    if self.startDate is not None:
      oprot.writeFieldBegin('startDate', TType.I64, 1)
      oprot.writeI64(self.startDate)
      oprot.writeFieldEnd()
    if self.endDate is not None:
      oprot.writeFieldBegin('endDate', TType.I64, 2)
      oprot.writeI64(self.endDate)
      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 getMovementNonSerializedInventoryByScans_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.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 = []
          (_etype129, _size126) = iprot.readListBegin()
          for _i130 in xrange(_size126):
            _elem131 = InventoryMovement()
            _elem131.read(iprot)
            self.success.append(_elem131)
          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('getMovementNonSerializedInventoryByScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter132 in self.success:
        iter132.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 getMovementSerializedInventoryByScans_args:
  """
  Attributes:
   - startDate
   - endDate
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'startDate', None, None, ), # 1
    (2, TType.I64, 'endDate', None, None, ), # 2
  )

  def __init__(self, startDate=None, endDate=None,):
    self.startDate = startDate
    self.endDate = endDate

  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.startDate = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.endDate = 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('getMovementSerializedInventoryByScans_args')
    if self.startDate is not None:
      oprot.writeFieldBegin('startDate', TType.I64, 1)
      oprot.writeI64(self.startDate)
      oprot.writeFieldEnd()
    if self.endDate is not None:
      oprot.writeFieldBegin('endDate', TType.I64, 2)
      oprot.writeI64(self.endDate)
      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 getMovementSerializedInventoryByScans_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.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 = []
          (_etype136, _size133) = iprot.readListBegin()
          for _i137 in xrange(_size133):
            _elem138 = InventoryMovement()
            _elem138.read(iprot)
            self.success.append(_elem138)
          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('getMovementSerializedInventoryByScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter139 in self.success:
        iter139.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 getCompleteMovementSerializedInventoryByScans_args:
  """
  Attributes:
   - startDate
   - endDate
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'startDate', None, None, ), # 1
    (2, TType.I64, 'endDate', None, None, ), # 2
  )

  def __init__(self, startDate=None, endDate=None,):
    self.startDate = startDate
    self.endDate = endDate

  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.startDate = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.endDate = 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('getCompleteMovementSerializedInventoryByScans_args')
    if self.startDate is not None:
      oprot.writeFieldBegin('startDate', TType.I64, 1)
      oprot.writeI64(self.startDate)
      oprot.writeFieldEnd()
    if self.endDate is not None:
      oprot.writeFieldBegin('endDate', TType.I64, 2)
      oprot.writeI64(self.endDate)
      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 getCompleteMovementSerializedInventoryByScans_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.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 = []
          (_etype143, _size140) = iprot.readListBegin()
          for _i144 in xrange(_size140):
            _elem145 = InventoryMovement()
            _elem145.read(iprot)
            self.success.append(_elem145)
          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('getCompleteMovementSerializedInventoryByScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter146 in self.success:
        iter146.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 getCompleteMovementNonSerializedInventoryByScans_args:
  """
  Attributes:
   - startDate
   - endDate
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'startDate', None, None, ), # 1
    (2, TType.I64, 'endDate', None, None, ), # 2
  )

  def __init__(self, startDate=None, endDate=None,):
    self.startDate = startDate
    self.endDate = endDate

  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.startDate = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.endDate = 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('getCompleteMovementNonSerializedInventoryByScans_args')
    if self.startDate is not None:
      oprot.writeFieldBegin('startDate', TType.I64, 1)
      oprot.writeI64(self.startDate)
      oprot.writeFieldEnd()
    if self.endDate is not None:
      oprot.writeFieldBegin('endDate', TType.I64, 2)
      oprot.writeI64(self.endDate)
      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 getCompleteMovementNonSerializedInventoryByScans_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.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 = []
          (_etype150, _size147) = iprot.readListBegin()
          for _i151 in xrange(_size147):
            _elem152 = InventoryMovement()
            _elem152.read(iprot)
            self.success.append(_elem152)
          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('getCompleteMovementNonSerializedInventoryByScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter153 in self.success:
        iter153.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 scanfreebie_args:
  """
  Attributes:
   - orderId
   - freebieItemId
   - freebieWarehouseId
   - scanType
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'orderId', None, None, ), # 1
    (2, TType.I64, 'freebieItemId', None, None, ), # 2
    (3, TType.I64, 'freebieWarehouseId', None, None, ), # 3
    (4, TType.I32, 'scanType', None, None, ), # 4
  )

  def __init__(self, orderId=None, freebieItemId=None, freebieWarehouseId=None, scanType=None,):
    self.orderId = orderId
    self.freebieItemId = freebieItemId
    self.freebieWarehouseId = freebieWarehouseId
    self.scanType = scanType

  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.orderId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.freebieItemId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.freebieWarehouseId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.scanType = iprot.readI32();
        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('scanfreebie_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.freebieItemId is not None:
      oprot.writeFieldBegin('freebieItemId', TType.I64, 2)
      oprot.writeI64(self.freebieItemId)
      oprot.writeFieldEnd()
    if self.freebieWarehouseId is not None:
      oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 3)
      oprot.writeI64(self.freebieWarehouseId)
      oprot.writeFieldEnd()
    if self.scanType is not None:
      oprot.writeFieldBegin('scanType', TType.I32, 4)
      oprot.writeI32(self.scanType)
      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 scanfreebie_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = InventoryItem()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('scanfreebie_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 reshipfreebie_args:
  """
  Attributes:
   - oldOrderId
   - newOrderId
   - freebieItemId
   - scanType
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'oldOrderId', None, None, ), # 1
    (2, TType.I64, 'newOrderId', None, None, ), # 2
    (3, TType.I64, 'freebieItemId', None, None, ), # 3
    (4, TType.I32, 'scanType', None, None, ), # 4
  )

  def __init__(self, oldOrderId=None, newOrderId=None, freebieItemId=None, scanType=None,):
    self.oldOrderId = oldOrderId
    self.newOrderId = newOrderId
    self.freebieItemId = freebieItemId
    self.scanType = scanType

  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.oldOrderId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.newOrderId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.freebieItemId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.scanType = iprot.readI32();
        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('reshipfreebie_args')
    if self.oldOrderId is not None:
      oprot.writeFieldBegin('oldOrderId', TType.I64, 1)
      oprot.writeI64(self.oldOrderId)
      oprot.writeFieldEnd()
    if self.newOrderId is not None:
      oprot.writeFieldBegin('newOrderId', TType.I64, 2)
      oprot.writeI64(self.newOrderId)
      oprot.writeFieldEnd()
    if self.freebieItemId is not None:
      oprot.writeFieldBegin('freebieItemId', TType.I64, 3)
      oprot.writeI64(self.freebieItemId)
      oprot.writeFieldEnd()
    if self.scanType is not None:
      oprot.writeFieldBegin('scanType', TType.I32, 4)
      oprot.writeI32(self.scanType)
      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 reshipfreebie_result:
  """
  Attributes:
   - wex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, wex=None,):
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('reshipfreebie_result')
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 isItemTransferAllowed_args:
  """
  Attributes:
   - warehouseId
   - transferWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'warehouseId', None, None, ), # 1
    (2, TType.I64, 'transferWarehouseId', None, None, ), # 2
  )

  def __init__(self, warehouseId=None, transferWarehouseId=None,):
    self.warehouseId = warehouseId
    self.transferWarehouseId = transferWarehouseId

  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)
      elif fid == 2:
        if ftype == TType.I64:
          self.transferWarehouseId = 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('isItemTransferAllowed_args')
    if self.warehouseId is not None:
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
      oprot.writeI64(self.warehouseId)
      oprot.writeFieldEnd()
    if self.transferWarehouseId is not None:
      oprot.writeFieldBegin('transferWarehouseId', TType.I64, 2)
      oprot.writeI64(self.transferWarehouseId)
      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 isItemTransferAllowed_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('isItemTransferAllowed_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 createTransferLot_args:
  """
  Attributes:
   - originWarehouseId
   - destWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'originWarehouseId', None, None, ), # 1
    (2, TType.I64, 'destWarehouseId', None, None, ), # 2
  )

  def __init__(self, originWarehouseId=None, destWarehouseId=None,):
    self.originWarehouseId = originWarehouseId
    self.destWarehouseId = destWarehouseId

  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.originWarehouseId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.destWarehouseId = 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('createTransferLot_args')
    if self.originWarehouseId is not None:
      oprot.writeFieldBegin('originWarehouseId', TType.I64, 1)
      oprot.writeI64(self.originWarehouseId)
      oprot.writeFieldEnd()
    if self.destWarehouseId is not None:
      oprot.writeFieldBegin('destWarehouseId', TType.I64, 2)
      oprot.writeI64(self.destWarehouseId)
      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 createTransferLot_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.I64, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('createTransferLot_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I64, 0)
      oprot.writeI64(self.success)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getTransferLot_args:
  """
  Attributes:
   - transferLotId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'transferLotId', None, None, ), # 1
  )

  def __init__(self, transferLotId=None,):
    self.transferLotId = transferLotId

  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.transferLotId = 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('getTransferLot_args')
    if self.transferLotId is not None:
      oprot.writeFieldBegin('transferLotId', TType.I64, 1)
      oprot.writeI64(self.transferLotId)
      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 getTransferLot_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (TransferLot, TransferLot.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = TransferLot()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getTransferLot_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 markTransferLotAsReceived_args:
  """
  Attributes:
   - id
   - remoteTransferRefNumber
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'id', None, None, ), # 1
    (2, TType.STRING, 'remoteTransferRefNumber', None, None, ), # 2
  )

  def __init__(self, id=None, remoteTransferRefNumber=None,):
    self.id = id
    self.remoteTransferRefNumber = remoteTransferRefNumber

  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.remoteTransferRefNumber = 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('markTransferLotAsReceived_args')
    if self.id is not None:
      oprot.writeFieldBegin('id', TType.I64, 1)
      oprot.writeI64(self.id)
      oprot.writeFieldEnd()
    if self.remoteTransferRefNumber is not None:
      oprot.writeFieldBegin('remoteTransferRefNumber', TType.STRING, 2)
      oprot.writeString(self.remoteTransferRefNumber)
      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 markTransferLotAsReceived_result:
  """
  Attributes:
   - wex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, wex=None,):
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('markTransferLotAsReceived_result')
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getTransferLotsByDate_args:
  """
  Attributes:
   - fromDate
   - toDate
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'fromDate', None, None, ), # 1
    (2, TType.I64, 'toDate', None, None, ), # 2
  )

  def __init__(self, fromDate=None, toDate=None,):
    self.fromDate = fromDate
    self.toDate = toDate

  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.fromDate = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.toDate = 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('getTransferLotsByDate_args')
    if self.fromDate is not None:
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
      oprot.writeI64(self.fromDate)
      oprot.writeFieldEnd()
    if self.toDate is not None:
      oprot.writeFieldBegin('toDate', TType.I64, 2)
      oprot.writeI64(self.toDate)
      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 getTransferLotsByDate_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(TransferLot, TransferLot.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = []
          (_etype157, _size154) = iprot.readListBegin()
          for _i158 in xrange(_size154):
            _elem159 = TransferLot()
            _elem159.read(iprot)
            self.success.append(_elem159)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getTransferLotsByDate_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter160 in self.success:
        iter160.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getAllowedDestinationWarehousesForTransfer_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('getAllowedDestinationWarehousesForTransfer_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 getAllowedDestinationWarehousesForTransfer_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.I64,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.LIST:
          self.success = []
          (_etype164, _size161) = iprot.readListBegin()
          for _i165 in xrange(_size161):
            _elem166 = iprot.readI64();
            self.success.append(_elem166)
          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('getAllowedDestinationWarehousesForTransfer_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.I64, len(self.success))
      for iter167 in self.success:
        oprot.writeI64(iter167)
      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 getItemsInTransferLot_args:
  """
  Attributes:
   - transferLotId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'transferLotId', None, None, ), # 1
  )

  def __init__(self, transferLotId=None,):
    self.transferLotId = transferLotId

  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.transferLotId = 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('getItemsInTransferLot_args')
    if self.transferLotId is not None:
      oprot.writeFieldBegin('transferLotId', TType.I64, 1)
      oprot.writeI64(self.transferLotId)
      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 getItemsInTransferLot_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,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.MAP:
          self.success = {}
          (_ktype169, _vtype170, _size168 ) = iprot.readMapBegin() 
          for _i172 in xrange(_size168):
            _key173 = iprot.readI64();
            _val174 = iprot.readI64();
            self.success[_key173] = _val174
          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('getItemsInTransferLot_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
      for kiter175,viter176 in self.success.items():
        oprot.writeI64(kiter175)
        oprot.writeI64(viter176)
      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 markItemsAsReceivedForTransferLot_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('markItemsAsReceivedForTransferLot_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 markItemsAsReceivedForTransferLot_result:
  """
  Attributes:
   - wex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, wex=None,):
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('markItemsAsReceivedForTransferLot_result')
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 updateTransferLotAfterItemReceive_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('updateTransferLotAfterItemReceive_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 updateTransferLotAfterItemReceive_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.I32, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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.I32:
          self.success = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('updateTransferLotAfterItemReceive_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I32, 0)
      oprot.writeI32(self.success)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 scanForTransferOut_args:
  """
  Attributes:
   - inventoryItems
   - type
   - transferLotId
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'inventoryItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
    (2, TType.I32, 'type', None, None, ), # 2
    (3, TType.I64, 'transferLotId', None, None, ), # 3
  )

  def __init__(self, inventoryItems=None, type=None, transferLotId=None,):
    self.inventoryItems = inventoryItems
    self.type = type
    self.transferLotId = transferLotId

  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.inventoryItems = []
          (_etype180, _size177) = iprot.readListBegin()
          for _i181 in xrange(_size177):
            _elem182 = InventoryItem()
            _elem182.read(iprot)
            self.inventoryItems.append(_elem182)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.type = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.transferLotId = 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('scanForTransferOut_args')
    if self.inventoryItems is not None:
      oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
      oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
      for iter183 in self.inventoryItems:
        iter183.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.I32, 2)
      oprot.writeI32(self.type)
      oprot.writeFieldEnd()
    if self.transferLotId is not None:
      oprot.writeFieldBegin('transferLotId', TType.I64, 3)
      oprot.writeI64(self.transferLotId)
      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 scanForTransferOut_result:
  """
  Attributes:
   - wex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, wex=None,):
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('scanForTransferOut_result')
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 scanForTransferIn_args:
  """
  Attributes:
   - inventoryItems
   - type
   - transferLotId
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'inventoryItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
    (2, TType.I32, 'type', None, None, ), # 2
    (3, TType.I64, 'transferLotId', None, None, ), # 3
  )

  def __init__(self, inventoryItems=None, type=None, transferLotId=None,):
    self.inventoryItems = inventoryItems
    self.type = type
    self.transferLotId = transferLotId

  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.inventoryItems = []
          (_etype187, _size184) = iprot.readListBegin()
          for _i188 in xrange(_size184):
            _elem189 = InventoryItem()
            _elem189.read(iprot)
            self.inventoryItems.append(_elem189)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.type = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.transferLotId = 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('scanForTransferIn_args')
    if self.inventoryItems is not None:
      oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
      oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
      for iter190 in self.inventoryItems:
        iter190.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.I32, 2)
      oprot.writeI32(self.type)
      oprot.writeFieldEnd()
    if self.transferLotId is not None:
      oprot.writeFieldBegin('transferLotId', TType.I64, 3)
      oprot.writeI64(self.transferLotId)
      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 scanForTransferIn_result:
  """
  Attributes:
   - wex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, wex=None,):
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('scanForTransferIn_result')
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 scanForOursThirdPartyReceive_args:
  """
  Attributes:
   - inventoryItems
   - id
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'inventoryItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
    (2, TType.I64, 'id', None, None, ), # 2
  )

  def __init__(self, inventoryItems=None, id=None,):
    self.inventoryItems = inventoryItems
    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.LIST:
          self.inventoryItems = []
          (_etype194, _size191) = iprot.readListBegin()
          for _i195 in xrange(_size191):
            _elem196 = InventoryItem()
            _elem196.read(iprot)
            self.inventoryItems.append(_elem196)
          iprot.readListEnd()
        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('scanForOursThirdPartyReceive_args')
    if self.inventoryItems is not None:
      oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
      oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
      for iter197 in self.inventoryItems:
        iter197.write(oprot)
      oprot.writeListEnd()
      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 scanForOursThirdPartyReceive_result:
  """
  Attributes:
   - wex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, wex=None,):
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('scanForOursThirdPartyReceive_result')
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_args:
  """
  Attributes:
   - itemId
   - physicalWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'itemId', None, None, ), # 1
    (2, TType.I64, 'physicalWarehouseId', None, None, ), # 2
  )

  def __init__(self, itemId=None, physicalWarehouseId=None,):
    self.itemId = itemId
    self.physicalWarehouseId = physicalWarehouseId

  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.itemId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.physicalWarehouseId = 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('getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_args')
    if self.itemId is not None:
      oprot.writeFieldBegin('itemId', TType.I64, 1)
      oprot.writeI64(self.itemId)
      oprot.writeFieldEnd()
    if self.physicalWarehouseId is not None:
      oprot.writeFieldBegin('physicalWarehouseId', TType.I64, 2)
      oprot.writeI64(self.physicalWarehouseId)
      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 getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.I64, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I64, 0)
      oprot.writeI64(self.success)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getInTransitInventory_args:
  """
  Attributes:
   - originWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'originWarehouseId', None, None, ), # 1
  )

  def __init__(self, originWarehouseId=None,):
    self.originWarehouseId = originWarehouseId

  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.originWarehouseId = 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('getInTransitInventory_args')
    if self.originWarehouseId is not None:
      oprot.writeFieldBegin('originWarehouseId', TType.I64, 1)
      oprot.writeI64(self.originWarehouseId)
      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 getInTransitInventory_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InTransitInventory, InTransitInventory.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 = []
          (_etype201, _size198) = iprot.readListBegin()
          for _i202 in xrange(_size198):
            _elem203 = InTransitInventory()
            _elem203.read(iprot)
            self.success.append(_elem203)
          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('getInTransitInventory_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter204 in self.success:
        iter204.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 isItemAvailableForSale_args:
  """
  Attributes:
   - itemId
   - serialNumber
   - warehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'itemId', None, None, ), # 1
    (2, TType.STRING, 'serialNumber', None, None, ), # 2
    (3, TType.I64, 'warehouseId', None, None, ), # 3
  )

  def __init__(self, itemId=None, serialNumber=None, warehouseId=None,):
    self.itemId = itemId
    self.serialNumber = serialNumber
    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.itemId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.serialNumber = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        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('isItemAvailableForSale_args')
    if self.itemId is not None:
      oprot.writeFieldBegin('itemId', TType.I64, 1)
      oprot.writeI64(self.itemId)
      oprot.writeFieldEnd()
    if self.serialNumber is not None:
      oprot.writeFieldBegin('serialNumber', TType.STRING, 2)
      oprot.writeString(self.serialNumber)
      oprot.writeFieldEnd()
    if self.warehouseId is not None:
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
      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 isItemAvailableForSale_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.BOOL, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('isItemAvailableForSale_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getHistoricBadInventoryByScans_args:
  """
  Attributes:
   - date
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'date', None, None, ), # 1
  )

  def __init__(self, date=None,):
    self.date = date

  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.date = 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('getHistoricBadInventoryByScans_args')
    if self.date is not None:
      oprot.writeFieldBegin('date', TType.I64, 1)
      oprot.writeI64(self.date)
      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 getHistoricBadInventoryByScans_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = []
          (_etype208, _size205) = iprot.readListBegin()
          for _i209 in xrange(_size205):
            _elem210 = InventoryAvailability()
            _elem210.read(iprot)
            self.success.append(_elem210)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getHistoricBadInventoryByScans_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter211 in self.success:
        iter211.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 scanForBadSale_args:
  """
  Attributes:
   - serialNumber
   - itemNumber
   - itemId
   - orderId
   - fulfilmentWarehouseId
   - quantity
   - billingWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
    (2, TType.STRING, 'itemNumber', None, None, ), # 2
    (3, TType.I64, 'itemId', None, None, ), # 3
    (4, TType.I64, 'orderId', None, None, ), # 4
    (5, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 5
    (6, TType.I64, 'quantity', None, None, ), # 6
    (7, TType.I64, 'billingWarehouseId', None, None, ), # 7
  )

  def __init__(self, serialNumber=None, itemNumber=None, itemId=None, orderId=None, fulfilmentWarehouseId=None, quantity=None, billingWarehouseId=None,):
    self.serialNumber = serialNumber
    self.itemNumber = itemNumber
    self.itemId = itemId
    self.orderId = orderId
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
    self.quantity = quantity
    self.billingWarehouseId = billingWarehouseId

  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.STRING:
          self.serialNumber = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.itemNumber = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.itemId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.orderId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I64:
          self.fulfilmentWarehouseId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.I64:
          self.quantity = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.I64:
          self.billingWarehouseId = 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('scanForBadSale_args')
    if self.serialNumber is not None:
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
      oprot.writeString(self.serialNumber)
      oprot.writeFieldEnd()
    if self.itemNumber is not None:
      oprot.writeFieldBegin('itemNumber', TType.STRING, 2)
      oprot.writeString(self.itemNumber)
      oprot.writeFieldEnd()
    if self.itemId is not None:
      oprot.writeFieldBegin('itemId', TType.I64, 3)
      oprot.writeI64(self.itemId)
      oprot.writeFieldEnd()
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 4)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.fulfilmentWarehouseId is not None:
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 5)
      oprot.writeI64(self.fulfilmentWarehouseId)
      oprot.writeFieldEnd()
    if self.quantity is not None:
      oprot.writeFieldBegin('quantity', TType.I64, 6)
      oprot.writeI64(self.quantity)
      oprot.writeFieldEnd()
    if self.billingWarehouseId is not None:
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 7)
      oprot.writeI64(self.billingWarehouseId)
      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 scanForBadSale_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = InventoryItem()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('scanForBadSale_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getTransferLotItemsForMarkReceive_args:
  """
  Attributes:
   - transferLotId
   - scanType
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'transferLotId', None, None, ), # 1
    (2, TType.I32, 'scanType', None, None, ), # 2
  )

  def __init__(self, transferLotId=None, scanType=None,):
    self.transferLotId = transferLotId
    self.scanType = scanType

  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.transferLotId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.scanType = iprot.readI32();
        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('getTransferLotItemsForMarkReceive_args')
    if self.transferLotId is not None:
      oprot.writeFieldBegin('transferLotId', TType.I64, 1)
      oprot.writeI64(self.transferLotId)
      oprot.writeFieldEnd()
    if self.scanType is not None:
      oprot.writeFieldBegin('scanType', TType.I32, 2)
      oprot.writeI32(self.scanType)
      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 getTransferLotItemsForMarkReceive_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = []
          (_etype215, _size212) = iprot.readListBegin()
          for _i216 in xrange(_size212):
            _elem217 = InventoryItem()
            _elem217.read(iprot)
            self.success.append(_elem217)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getTransferLotItemsForMarkReceive_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter218 in self.success:
        iter218.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 markItemsAsReceivedForTransferLotPartial_args:
  """
  Attributes:
   - inventoryItems
   - transferLotId
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'inventoryItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
    (2, TType.I64, 'transferLotId', None, None, ), # 2
  )

  def __init__(self, inventoryItems=None, transferLotId=None,):
    self.inventoryItems = inventoryItems
    self.transferLotId = transferLotId

  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.inventoryItems = []
          (_etype222, _size219) = iprot.readListBegin()
          for _i223 in xrange(_size219):
            _elem224 = InventoryItem()
            _elem224.read(iprot)
            self.inventoryItems.append(_elem224)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.transferLotId = 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('markItemsAsReceivedForTransferLotPartial_args')
    if self.inventoryItems is not None:
      oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
      oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
      for iter225 in self.inventoryItems:
        iter225.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.transferLotId is not None:
      oprot.writeFieldBegin('transferLotId', TType.I64, 2)
      oprot.writeI64(self.transferLotId)
      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 markItemsAsReceivedForTransferLotPartial_result:
  """
  Attributes:
   - wex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, wex=None,):
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('markItemsAsReceivedForTransferLotPartial_result')
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 markTransferLotAsReceivedPartial_args:
  """
  Attributes:
   - id
   - remoteTransferRefNumber
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'id', None, None, ), # 1
    (2, TType.STRING, 'remoteTransferRefNumber', None, None, ), # 2
  )

  def __init__(self, id=None, remoteTransferRefNumber=None,):
    self.id = id
    self.remoteTransferRefNumber = remoteTransferRefNumber

  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.remoteTransferRefNumber = 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('markTransferLotAsReceivedPartial_args')
    if self.id is not None:
      oprot.writeFieldBegin('id', TType.I64, 1)
      oprot.writeI64(self.id)
      oprot.writeFieldEnd()
    if self.remoteTransferRefNumber is not None:
      oprot.writeFieldBegin('remoteTransferRefNumber', TType.STRING, 2)
      oprot.writeString(self.remoteTransferRefNumber)
      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 markTransferLotAsReceivedPartial_result:
  """
  Attributes:
   - wex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, wex=None,):
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('markTransferLotAsReceivedPartial_result')
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getInventoryItemScannedInForPO_args:
  """
  Attributes:
   - itemId
   - purchaseIds
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'itemId', None, None, ), # 1
    (2, TType.LIST, 'purchaseIds', (TType.I64,None), None, ), # 2
  )

  def __init__(self, itemId=None, purchaseIds=None,):
    self.itemId = itemId
    self.purchaseIds = purchaseIds

  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.itemId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.LIST:
          self.purchaseIds = []
          (_etype229, _size226) = iprot.readListBegin()
          for _i230 in xrange(_size226):
            _elem231 = iprot.readI64();
            self.purchaseIds.append(_elem231)
          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('getInventoryItemScannedInForPO_args')
    if self.itemId is not None:
      oprot.writeFieldBegin('itemId', TType.I64, 1)
      oprot.writeI64(self.itemId)
      oprot.writeFieldEnd()
    if self.purchaseIds is not None:
      oprot.writeFieldBegin('purchaseIds', TType.LIST, 2)
      oprot.writeListBegin(TType.I64, len(self.purchaseIds))
      for iter232 in self.purchaseIds:
        oprot.writeI64(iter232)
      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 getInventoryItemScannedInForPO_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = []
          (_etype236, _size233) = iprot.readListBegin()
          for _i237 in xrange(_size233):
            _elem238 = InventoryItem()
            _elem238.read(iprot)
            self.success.append(_elem238)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getInventoryItemScannedInForPO_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter239 in self.success:
        iter239.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getAmazonTransferredSkuDetails_args:
  """
  Attributes:
   - itemIds
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
  )

  def __init__(self, itemIds=None,):
    self.itemIds = itemIds

  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.itemIds = []
          (_etype243, _size240) = iprot.readListBegin()
          for _i244 in xrange(_size240):
            _elem245 = iprot.readI64();
            self.itemIds.append(_elem245)
          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('getAmazonTransferredSkuDetails_args')
    if self.itemIds is not None:
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
      oprot.writeListBegin(TType.I64, len(self.itemIds))
      for iter246 in self.itemIds:
        oprot.writeI64(iter246)
      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 getAmazonTransferredSkuDetails_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonTransferredSkuDetail, AmazonTransferredSkuDetail.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = []
          (_etype250, _size247) = iprot.readListBegin()
          for _i251 in xrange(_size247):
            _elem252 = AmazonTransferredSkuDetail()
            _elem252.read(iprot)
            self.success.append(_elem252)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getAmazonTransferredSkuDetails_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter253 in self.success:
        iter253.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getScansforPurchase_args:
  """
  Attributes:
   - purchaseId
   - scanType
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'purchaseId', None, None, ), # 1
    (2, TType.I32, 'scanType', None, None, ), # 2
  )

  def __init__(self, purchaseId=None, scanType=None,):
    self.purchaseId = purchaseId
    self.scanType = scanType

  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.purchaseId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.scanType = iprot.readI32();
        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('getScansforPurchase_args')
    if self.purchaseId is not None:
      oprot.writeFieldBegin('purchaseId', TType.I64, 1)
      oprot.writeI64(self.purchaseId)
      oprot.writeFieldEnd()
    if self.scanType is not None:
      oprot.writeFieldBegin('scanType', TType.I32, 2)
      oprot.writeI32(self.scanType)
      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 getScansforPurchase_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = []
          (_etype257, _size254) = iprot.readListBegin()
          for _i258 in xrange(_size254):
            _elem259 = Scan()
            _elem259.read(iprot)
            self.success.append(_elem259)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getScansforPurchase_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter260 in self.success:
        iter260.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getCurrentBadQuantityForItem_args:
  """
  Attributes:
   - itemId
   - currentWarehouseId
   - physicalWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'itemId', None, None, ), # 1
    (2, TType.I64, 'currentWarehouseId', None, None, ), # 2
    (3, TType.I64, 'physicalWarehouseId', None, None, ), # 3
  )

  def __init__(self, itemId=None, currentWarehouseId=None, physicalWarehouseId=None,):
    self.itemId = itemId
    self.currentWarehouseId = currentWarehouseId
    self.physicalWarehouseId = physicalWarehouseId

  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.itemId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.currentWarehouseId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.physicalWarehouseId = 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('getCurrentBadQuantityForItem_args')
    if self.itemId is not None:
      oprot.writeFieldBegin('itemId', TType.I64, 1)
      oprot.writeI64(self.itemId)
      oprot.writeFieldEnd()
    if self.currentWarehouseId is not None:
      oprot.writeFieldBegin('currentWarehouseId', TType.I64, 2)
      oprot.writeI64(self.currentWarehouseId)
      oprot.writeFieldEnd()
    if self.physicalWarehouseId is not None:
      oprot.writeFieldBegin('physicalWarehouseId', TType.I64, 3)
      oprot.writeI64(self.physicalWarehouseId)
      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 getCurrentBadQuantityForItem_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.I64, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('getCurrentBadQuantityForItem_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I64, 0)
      oprot.writeI64(self.success)
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 scanForBadPurchaseReturn_args:
  """
  Attributes:
   - saleReturnItems
   - vendorId
   - billingWarehouseId
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'saleReturnItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
    (2, TType.I64, 'vendorId', None, None, ), # 2
    (3, TType.I64, 'billingWarehouseId', None, None, ), # 3
  )

  def __init__(self, saleReturnItems=None, vendorId=None, billingWarehouseId=None,):
    self.saleReturnItems = saleReturnItems
    self.vendorId = vendorId
    self.billingWarehouseId = billingWarehouseId

  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.saleReturnItems = []
          (_etype264, _size261) = iprot.readListBegin()
          for _i265 in xrange(_size261):
            _elem266 = InventoryItem()
            _elem266.read(iprot)
            self.saleReturnItems.append(_elem266)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.vendorId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.billingWarehouseId = 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('scanForBadPurchaseReturn_args')
    if self.saleReturnItems is not None:
      oprot.writeFieldBegin('saleReturnItems', TType.LIST, 1)
      oprot.writeListBegin(TType.STRUCT, len(self.saleReturnItems))
      for iter267 in self.saleReturnItems:
        iter267.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.vendorId is not None:
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
      oprot.writeI64(self.vendorId)
      oprot.writeFieldEnd()
    if self.billingWarehouseId is not None:
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 3)
      oprot.writeI64(self.billingWarehouseId)
      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 scanForBadPurchaseReturn_result:
  """
  Attributes:
   - success
   - ex
  """

  thrift_spec = (
    (0, TType.I64, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.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 = WarehouseServiceException()
          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('scanForBadPurchaseReturn_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 getItemsInPurchaseReturn_args:
  """
  Attributes:
   - purchaseReturnId
   - type
   - returnTime
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'purchaseReturnId', None, None, ), # 1
    (2, TType.I32, 'type', None, None, ), # 2
    (3, TType.STRING, 'returnTime', None, None, ), # 3
  )

  def __init__(self, purchaseReturnId=None, type=None, returnTime=None,):
    self.purchaseReturnId = purchaseReturnId
    self.type = type
    self.returnTime = returnTime

  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.purchaseReturnId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.type = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.returnTime = 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('getItemsInPurchaseReturn_args')
    if self.purchaseReturnId is not None:
      oprot.writeFieldBegin('purchaseReturnId', TType.I64, 1)
      oprot.writeI64(self.purchaseReturnId)
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.I32, 2)
      oprot.writeI32(self.type)
      oprot.writeFieldEnd()
    if self.returnTime is not None:
      oprot.writeFieldBegin('returnTime', TType.STRING, 3)
      oprot.writeString(self.returnTime)
      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 getItemsInPurchaseReturn_result:
  """
  Attributes:
   - success
   - ex
  """

  thrift_spec = (
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.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 = {}
          (_ktype269, _vtype270, _size268 ) = iprot.readMapBegin() 
          for _i272 in xrange(_size268):
            _key273 = iprot.readI64();
            _val274 = iprot.readI64();
            self.success[_key273] = _val274
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ex = WarehouseServiceException()
          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('getItemsInPurchaseReturn_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.MAP, 0)
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
      for kiter275,viter276 in self.success.items():
        oprot.writeI64(kiter275)
        oprot.writeI64(viter276)
      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 getScansForInventoryItem_args:
  """
  Attributes:
   - inventoryItemId
   - type
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'inventoryItemId', None, None, ), # 1
    (2, TType.I32, 'type', None, None, ), # 2
  )

  def __init__(self, inventoryItemId=None, type=None,):
    self.inventoryItemId = inventoryItemId
    self.type = type

  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.inventoryItemId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.type = iprot.readI32();
        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('getScansForInventoryItem_args')
    if self.inventoryItemId is not None:
      oprot.writeFieldBegin('inventoryItemId', TType.I64, 1)
      oprot.writeI64(self.inventoryItemId)
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.I32, 2)
      oprot.writeI32(self.type)
      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 getScansForInventoryItem_result:
  """
  Attributes:
   - success
   - ex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.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 = []
          (_etype280, _size277) = iprot.readListBegin()
          for _i281 in xrange(_size277):
            _elem282 = Scan()
            _elem282.read(iprot)
            self.success.append(_elem282)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ex = WarehouseServiceException()
          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('getScansForInventoryItem_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter283 in self.success:
        iter283.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 checkGrnImeiStatus_args:
  """
  Attributes:
   - imeiNos
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'imeiNos', (TType.STRING,None), None, ), # 1
  )

  def __init__(self, imeiNos=None,):
    self.imeiNos = imeiNos

  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.imeiNos = []
          (_etype287, _size284) = iprot.readListBegin()
          for _i288 in xrange(_size284):
            _elem289 = iprot.readString();
            self.imeiNos.append(_elem289)
          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('checkGrnImeiStatus_args')
    if self.imeiNos is not None:
      oprot.writeFieldBegin('imeiNos', TType.LIST, 1)
      oprot.writeListBegin(TType.STRING, len(self.imeiNos))
      for iter290 in self.imeiNos:
        oprot.writeString(iter290)
      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 checkGrnImeiStatus_result:
  """
  Attributes:
   - success
   - ex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.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 = []
          (_etype294, _size291) = iprot.readListBegin()
          for _i295 in xrange(_size291):
            _elem296 = iprot.readString();
            self.success.append(_elem296)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ex = WarehouseServiceException()
          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('checkGrnImeiStatus_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRING, len(self.success))
      for iter297 in self.success:
        oprot.writeString(iter297)
      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 getInventoryAgeConsideredItems_args:
  """
  Attributes:
   - itemId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'itemId', None, None, ), # 1
  )

  def __init__(self, itemId=None,):
    self.itemId = itemId

  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.itemId = 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('getInventoryAgeConsideredItems_args')
    if self.itemId is not None:
      oprot.writeFieldBegin('itemId', TType.I64, 1)
      oprot.writeI64(self.itemId)
      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 getInventoryAgeConsideredItems_result:
  """
  Attributes:
   - success
   - ex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InvAgeConsiderItems, InvAgeConsiderItems.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.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 = []
          (_etype301, _size298) = iprot.readListBegin()
          for _i302 in xrange(_size298):
            _elem303 = InvAgeConsiderItems()
            _elem303.read(iprot)
            self.success.append(_elem303)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ex = WarehouseServiceException()
          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('getInventoryAgeConsideredItems_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter304 in self.success:
        iter304.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 getCompleteMovementForThirdPartyWarehouse_args:
  """
  Attributes:
   - startDate
   - endDate
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'startDate', None, None, ), # 1
    (2, TType.I64, 'endDate', None, None, ), # 2
  )

  def __init__(self, startDate=None, endDate=None,):
    self.startDate = startDate
    self.endDate = endDate

  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.startDate = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.endDate = 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('getCompleteMovementForThirdPartyWarehouse_args')
    if self.startDate is not None:
      oprot.writeFieldBegin('startDate', TType.I64, 1)
      oprot.writeI64(self.startDate)
      oprot.writeFieldEnd()
    if self.endDate is not None:
      oprot.writeFieldBegin('endDate', TType.I64, 2)
      oprot.writeI64(self.endDate)
      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 getCompleteMovementForThirdPartyWarehouse_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.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 = []
          (_etype308, _size305) = iprot.readListBegin()
          for _i309 in xrange(_size305):
            _elem310 = InventoryMovement()
            _elem310.read(iprot)
            self.success.append(_elem310)
          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('getCompleteMovementForThirdPartyWarehouse_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter311 in self.success:
        iter311.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 getAllDoaOutInventoryItems_args:

  thrift_spec = (
  )

  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
      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('getAllDoaOutInventoryItems_args')
    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 getAllDoaOutInventoryItems_result:
  """
  Attributes:
   - success
   - ex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(DoaOutInventoryItem, DoaOutInventoryItem.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.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 = []
          (_etype315, _size312) = iprot.readListBegin()
          for _i316 in xrange(_size312):
            _elem317 = DoaOutInventoryItem()
            _elem317.read(iprot)
            self.success.append(_elem317)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ex = WarehouseServiceException()
          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('getAllDoaOutInventoryItems_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter318 in self.success:
        iter318.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 getAllUnCompletedStockShipments_args:
  """
  Attributes:
   - source
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'source', None, None, ), # 1
  )

  def __init__(self, source=None,):
    self.source = source

  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.STRING:
          self.source = 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('getAllUnCompletedStockShipments_args')
    if self.source is not None:
      oprot.writeFieldBegin('source', TType.STRING, 1)
      oprot.writeString(self.source)
      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 getAllUnCompletedStockShipments_result:
  """
  Attributes:
   - success
   - ex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(RemovalStockShipmentReference, RemovalStockShipmentReference.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.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 = []
          (_etype322, _size319) = iprot.readListBegin()
          for _i323 in xrange(_size319):
            _elem324 = RemovalStockShipmentReference()
            _elem324.read(iprot)
            self.success.append(_elem324)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ex = WarehouseServiceException()
          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('getAllUnCompletedStockShipments_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter325 in self.success:
        iter325.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 getRemovalStockShipmentReferenceById_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('getRemovalStockShipmentReferenceById_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 getRemovalStockShipmentReferenceById_result:
  """
  Attributes:
   - success
   - ex
  """

  thrift_spec = (
    (0, TType.STRUCT, 'success', (RemovalStockShipmentReference, RemovalStockShipmentReference.thrift_spec), None, ), # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.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 = RemovalStockShipmentReference()
          self.success.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.ex = WarehouseServiceException()
          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('getRemovalStockShipmentReferenceById_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 createRemovalStockShipmentReference_args:
  """
  Attributes:
   - removalStockShipmentReference
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'removalStockShipmentReference', (RemovalStockShipmentReference, RemovalStockShipmentReference.thrift_spec), None, ), # 1
  )

  def __init__(self, removalStockShipmentReference=None,):
    self.removalStockShipmentReference = removalStockShipmentReference

  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.removalStockShipmentReference = RemovalStockShipmentReference()
          self.removalStockShipmentReference.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('createRemovalStockShipmentReference_args')
    if self.removalStockShipmentReference is not None:
      oprot.writeFieldBegin('removalStockShipmentReference', TType.STRUCT, 1)
      self.removalStockShipmentReference.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 createRemovalStockShipmentReference_result:
  """
  Attributes:
   - success
   - ex
  """

  thrift_spec = (
    (0, TType.I64, 'success', None, None, ), # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.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 = WarehouseServiceException()
          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('createRemovalStockShipmentReference_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 updateShipmentReferenceTransferLot_args:
  """
  Attributes:
   - transferLotId
   - shipmentReferenceId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'transferLotId', None, None, ), # 1
    (2, TType.I64, 'shipmentReferenceId', None, None, ), # 2
  )

  def __init__(self, transferLotId=None, shipmentReferenceId=None,):
    self.transferLotId = transferLotId
    self.shipmentReferenceId = shipmentReferenceId

  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.transferLotId = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.shipmentReferenceId = 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('updateShipmentReferenceTransferLot_args')
    if self.transferLotId is not None:
      oprot.writeFieldBegin('transferLotId', TType.I64, 1)
      oprot.writeI64(self.transferLotId)
      oprot.writeFieldEnd()
    if self.shipmentReferenceId is not None:
      oprot.writeFieldBegin('shipmentReferenceId', TType.I64, 2)
      oprot.writeI64(self.shipmentReferenceId)
      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 updateShipmentReferenceTransferLot_result:
  """
  Attributes:
   - ex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, ex=None,):
    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 == 1:
        if ftype == TType.STRUCT:
          self.ex = WarehouseServiceException()
          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('updateShipmentReferenceTransferLot_result')
    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 fetchScansPerTransferInvoiceNumber_args:
  """
  Attributes:
   - date
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'date', None, None, ), # 1
  )

  def __init__(self, date=None,):
    self.date = date

  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.date = 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('fetchScansPerTransferInvoiceNumber_args')
    if self.date is not None:
      oprot.writeFieldBegin('date', TType.I64, 1)
      oprot.writeI64(self.date)
      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 fetchScansPerTransferInvoiceNumber_result:
  """
  Attributes:
   - success
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(TransferInvoiceScan, TransferInvoiceScan.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 = []
          (_etype329, _size326) = iprot.readListBegin()
          for _i330 in xrange(_size326):
            _elem331 = TransferInvoiceScan()
            _elem331.read(iprot)
            self.success.append(_elem331)
          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('fetchScansPerTransferInvoiceNumber_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter332 in self.success:
        iter332.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 getInventoryItems_args:
  """
  Attributes:
   - serialNumbers
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'serialNumbers', (TType.STRING,None), None, ), # 1
  )

  def __init__(self, serialNumbers=None,):
    self.serialNumbers = serialNumbers

  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.serialNumbers = []
          (_etype336, _size333) = iprot.readListBegin()
          for _i337 in xrange(_size333):
            _elem338 = iprot.readString();
            self.serialNumbers.append(_elem338)
          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('getInventoryItems_args')
    if self.serialNumbers is not None:
      oprot.writeFieldBegin('serialNumbers', TType.LIST, 1)
      oprot.writeListBegin(TType.STRING, len(self.serialNumbers))
      for iter339 in self.serialNumbers:
        oprot.writeString(iter339)
      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 getInventoryItems_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = []
          (_etype343, _size340) = iprot.readListBegin()
          for _i344 in xrange(_size340):
            _elem345 = InventoryItem()
            _elem345.read(iprot)
            self.success.append(_elem345)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getInventoryItems_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter346 in self.success:
        iter346.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 getInventoryItemsBySerailNumbers_args:
  """
  Attributes:
   - serialNumbers
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'serialNumbers', (TType.STRING,None), None, ), # 1
  )

  def __init__(self, serialNumbers=None,):
    self.serialNumbers = serialNumbers

  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.serialNumbers = []
          (_etype350, _size347) = iprot.readListBegin()
          for _i351 in xrange(_size347):
            _elem352 = iprot.readString();
            self.serialNumbers.append(_elem352)
          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('getInventoryItemsBySerailNumbers_args')
    if self.serialNumbers is not None:
      oprot.writeFieldBegin('serialNumbers', TType.LIST, 1)
      oprot.writeListBegin(TType.STRING, len(self.serialNumbers))
      for iter353 in self.serialNumbers:
        oprot.writeString(iter353)
      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 getInventoryItemsBySerailNumbers_result:
  """
  Attributes:
   - success
   - wex
  """

  thrift_spec = (
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, success=None, wex=None,):
    self.success = success
    self.wex = wex

  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 = []
          (_etype357, _size354) = iprot.readListBegin()
          for _i358 in xrange(_size354):
            _elem359 = InventoryItem()
            _elem359.read(iprot)
            self.success.append(_elem359)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 1:
        if ftype == TType.STRUCT:
          self.wex = WarehouseServiceException()
          self.wex.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('getInventoryItemsBySerailNumbers_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter360 in self.success:
        iter360.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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 scanPurchaseBulk_args:
  """
  Attributes:
   - inventoryItems
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'inventoryItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
  )

  def __init__(self, inventoryItems=None,):
    self.inventoryItems = inventoryItems

  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.inventoryItems = []
          (_etype364, _size361) = iprot.readListBegin()
          for _i365 in xrange(_size361):
            _elem366 = InventoryItem()
            _elem366.read(iprot)
            self.inventoryItems.append(_elem366)
          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('scanPurchaseBulk_args')
    if self.inventoryItems is not None:
      oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
      oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
      for iter367 in self.inventoryItems:
        iter367.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 scanPurchaseBulk_result:
  """
  Attributes:
   - wex
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
  )

  def __init__(self, wex=None,):
    self.wex = wex

  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.wex = WarehouseServiceException()
          self.wex.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('scanPurchaseBulk_result')
    if self.wex is not None:
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
      self.wex.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)