<?php

namespace StructType;

use \WsdlToPhp\PackageBase\AbstractStructBase;

/**
 * This class stands for InventoryNumberSearchRowBasic StructType
 * @subpackage Structs
 */
class InventoryNumberSearchRowBasic extends SearchRowBasic
{
    /**
     * The expirationDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $expirationDate;
    /**
     * The externalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $externalId;
    /**
     * The internalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $internalId;
    /**
     * The inventoryNumber
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $inventoryNumber;
    /**
     * The isonhand
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isonhand;
    /**
     * The item
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $item;
    /**
     * The location
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $location;
    /**
     * The memo
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $memo;
    /**
     * The quantityavailable
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $quantityavailable;
    /**
     * The quantityintransit
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $quantityintransit;
    /**
     * The quantityonhand
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $quantityonhand;
    /**
     * The quantityonorder
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $quantityonorder;
    /**
     * The customFieldList
     * Meta information extracted from the WSDL
     * - minOccurs: 0
     * @var \StructType\SearchColumnCustomFieldList
     */
    public $customFieldList;
    /**
     * Constructor method for InventoryNumberSearchRowBasic
     * @uses InventoryNumberSearchRowBasic::setExpirationDate()
     * @uses InventoryNumberSearchRowBasic::setExternalId()
     * @uses InventoryNumberSearchRowBasic::setInternalId()
     * @uses InventoryNumberSearchRowBasic::setInventoryNumber()
     * @uses InventoryNumberSearchRowBasic::setIsonhand()
     * @uses InventoryNumberSearchRowBasic::setItem()
     * @uses InventoryNumberSearchRowBasic::setLocation()
     * @uses InventoryNumberSearchRowBasic::setMemo()
     * @uses InventoryNumberSearchRowBasic::setQuantityavailable()
     * @uses InventoryNumberSearchRowBasic::setQuantityintransit()
     * @uses InventoryNumberSearchRowBasic::setQuantityonhand()
     * @uses InventoryNumberSearchRowBasic::setQuantityonorder()
     * @uses InventoryNumberSearchRowBasic::setCustomFieldList()
     * @param \StructType\SearchColumnDateField[] $expirationDate
     * @param \StructType\SearchColumnSelectField[] $externalId
     * @param \StructType\SearchColumnSelectField[] $internalId
     * @param \StructType\SearchColumnStringField[] $inventoryNumber
     * @param \StructType\SearchColumnBooleanField[] $isonhand
     * @param \StructType\SearchColumnSelectField[] $item
     * @param \StructType\SearchColumnSelectField[] $location
     * @param \StructType\SearchColumnStringField[] $memo
     * @param \StructType\SearchColumnDoubleField[] $quantityavailable
     * @param \StructType\SearchColumnDoubleField[] $quantityintransit
     * @param \StructType\SearchColumnDoubleField[] $quantityonhand
     * @param \StructType\SearchColumnDoubleField[] $quantityonorder
     * @param \StructType\SearchColumnCustomFieldList $customFieldList
     */
    public function __construct(array $expirationDate = array(), array $externalId = array(), array $internalId = array(), array $inventoryNumber = array(), array $isonhand = array(), array $item = array(), array $location = array(), array $memo = array(), array $quantityavailable = array(), array $quantityintransit = array(), array $quantityonhand = array(), array $quantityonorder = array(), \StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this
            ->setExpirationDate($expirationDate)
            ->setExternalId($externalId)
            ->setInternalId($internalId)
            ->setInventoryNumber($inventoryNumber)
            ->setIsonhand($isonhand)
            ->setItem($item)
            ->setLocation($location)
            ->setMemo($memo)
            ->setQuantityavailable($quantityavailable)
            ->setQuantityintransit($quantityintransit)
            ->setQuantityonhand($quantityonhand)
            ->setQuantityonorder($quantityonorder)
            ->setCustomFieldList($customFieldList);
    }
    /**
     * Get expirationDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getExpirationDate()
    {
        return $this->expirationDate;
    }
    /**
     * This method is responsible for validating the values passed to the setExpirationDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setExpirationDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateExpirationDateForArrayConstraintsFromSetExpirationDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicExpirationDateItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicExpirationDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicExpirationDateItem) ? get_class($inventoryNumberSearchRowBasicExpirationDateItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicExpirationDateItem), var_export($inventoryNumberSearchRowBasicExpirationDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The expirationDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set expirationDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $expirationDate
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setExpirationDate(array $expirationDate = array())
    {
        // validation for constraint: array
        if ('' !== ($expirationDateArrayErrorMessage = self::validateExpirationDateForArrayConstraintsFromSetExpirationDate($expirationDate))) {
            throw new \InvalidArgumentException($expirationDateArrayErrorMessage, __LINE__);
        }
        $this->expirationDate = $expirationDate;
        return $this;
    }
    /**
     * Add item to expirationDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToExpirationDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The expirationDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->expirationDate[] = $item;
        return $this;
    }
    /**
     * Get externalId value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getExternalId()
    {
        return $this->externalId;
    }
    /**
     * This method is responsible for validating the values passed to the setExternalId method
     * This method is willingly generated in order to preserve the one-line inline validation within the setExternalId method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateExternalIdForArrayConstraintsFromSetExternalId(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicExternalIdItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicExternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicExternalIdItem) ? get_class($inventoryNumberSearchRowBasicExternalIdItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicExternalIdItem), var_export($inventoryNumberSearchRowBasicExternalIdItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The externalId property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set externalId value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $externalId
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setExternalId(array $externalId = array())
    {
        // validation for constraint: array
        if ('' !== ($externalIdArrayErrorMessage = self::validateExternalIdForArrayConstraintsFromSetExternalId($externalId))) {
            throw new \InvalidArgumentException($externalIdArrayErrorMessage, __LINE__);
        }
        $this->externalId = $externalId;
        return $this;
    }
    /**
     * Add item to externalId value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToExternalId(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The externalId property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->externalId[] = $item;
        return $this;
    }
    /**
     * Get internalId value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getInternalId()
    {
        return $this->internalId;
    }
    /**
     * This method is responsible for validating the values passed to the setInternalId method
     * This method is willingly generated in order to preserve the one-line inline validation within the setInternalId method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateInternalIdForArrayConstraintsFromSetInternalId(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicInternalIdItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicInternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicInternalIdItem) ? get_class($inventoryNumberSearchRowBasicInternalIdItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicInternalIdItem), var_export($inventoryNumberSearchRowBasicInternalIdItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The internalId property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set internalId value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $internalId
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setInternalId(array $internalId = array())
    {
        // validation for constraint: array
        if ('' !== ($internalIdArrayErrorMessage = self::validateInternalIdForArrayConstraintsFromSetInternalId($internalId))) {
            throw new \InvalidArgumentException($internalIdArrayErrorMessage, __LINE__);
        }
        $this->internalId = $internalId;
        return $this;
    }
    /**
     * Add item to internalId value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToInternalId(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The internalId property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->internalId[] = $item;
        return $this;
    }
    /**
     * Get inventoryNumber value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getInventoryNumber()
    {
        return $this->inventoryNumber;
    }
    /**
     * This method is responsible for validating the values passed to the setInventoryNumber method
     * This method is willingly generated in order to preserve the one-line inline validation within the setInventoryNumber method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateInventoryNumberForArrayConstraintsFromSetInventoryNumber(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicInventoryNumberItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicInventoryNumberItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicInventoryNumberItem) ? get_class($inventoryNumberSearchRowBasicInventoryNumberItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicInventoryNumberItem), var_export($inventoryNumberSearchRowBasicInventoryNumberItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The inventoryNumber property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set inventoryNumber value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $inventoryNumber
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setInventoryNumber(array $inventoryNumber = array())
    {
        // validation for constraint: array
        if ('' !== ($inventoryNumberArrayErrorMessage = self::validateInventoryNumberForArrayConstraintsFromSetInventoryNumber($inventoryNumber))) {
            throw new \InvalidArgumentException($inventoryNumberArrayErrorMessage, __LINE__);
        }
        $this->inventoryNumber = $inventoryNumber;
        return $this;
    }
    /**
     * Add item to inventoryNumber value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToInventoryNumber(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The inventoryNumber property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->inventoryNumber[] = $item;
        return $this;
    }
    /**
     * Get isonhand value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsonhand()
    {
        return $this->isonhand;
    }
    /**
     * This method is responsible for validating the values passed to the setIsonhand method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsonhand method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsonhandForArrayConstraintsFromSetIsonhand(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicIsonhandItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicIsonhandItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicIsonhandItem) ? get_class($inventoryNumberSearchRowBasicIsonhandItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicIsonhandItem), var_export($inventoryNumberSearchRowBasicIsonhandItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isonhand property can only contain items of type \StructType\SearchColumnBooleanField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set isonhand value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isonhand
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setIsonhand(array $isonhand = array())
    {
        // validation for constraint: array
        if ('' !== ($isonhandArrayErrorMessage = self::validateIsonhandForArrayConstraintsFromSetIsonhand($isonhand))) {
            throw new \InvalidArgumentException($isonhandArrayErrorMessage, __LINE__);
        }
        $this->isonhand = $isonhand;
        return $this;
    }
    /**
     * Add item to isonhand value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToIsonhand(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isonhand property can only contain items of type \StructType\SearchColumnBooleanField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->isonhand[] = $item;
        return $this;
    }
    /**
     * Get item value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getItem()
    {
        return $this->item;
    }
    /**
     * This method is responsible for validating the values passed to the setItem method
     * This method is willingly generated in order to preserve the one-line inline validation within the setItem method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateItemForArrayConstraintsFromSetItem(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicItemItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicItemItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicItemItem) ? get_class($inventoryNumberSearchRowBasicItemItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicItemItem), var_export($inventoryNumberSearchRowBasicItemItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The item property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set item value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setItem(array $item = array())
    {
        // validation for constraint: array
        if ('' !== ($itemArrayErrorMessage = self::validateItemForArrayConstraintsFromSetItem($item))) {
            throw new \InvalidArgumentException($itemArrayErrorMessage, __LINE__);
        }
        $this->item = $item;
        return $this;
    }
    /**
     * Add item to item value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToItem(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The item property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->item[] = $item;
        return $this;
    }
    /**
     * Get location value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getLocation()
    {
        return $this->location;
    }
    /**
     * This method is responsible for validating the values passed to the setLocation method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLocation method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLocationForArrayConstraintsFromSetLocation(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicLocationItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicLocationItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicLocationItem) ? get_class($inventoryNumberSearchRowBasicLocationItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicLocationItem), var_export($inventoryNumberSearchRowBasicLocationItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The location property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set location value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $location
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setLocation(array $location = array())
    {
        // validation for constraint: array
        if ('' !== ($locationArrayErrorMessage = self::validateLocationForArrayConstraintsFromSetLocation($location))) {
            throw new \InvalidArgumentException($locationArrayErrorMessage, __LINE__);
        }
        $this->location = $location;
        return $this;
    }
    /**
     * Add item to location value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToLocation(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The location property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->location[] = $item;
        return $this;
    }
    /**
     * Get memo value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getMemo()
    {
        return $this->memo;
    }
    /**
     * This method is responsible for validating the values passed to the setMemo method
     * This method is willingly generated in order to preserve the one-line inline validation within the setMemo method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateMemoForArrayConstraintsFromSetMemo(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicMemoItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicMemoItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicMemoItem) ? get_class($inventoryNumberSearchRowBasicMemoItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicMemoItem), var_export($inventoryNumberSearchRowBasicMemoItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The memo property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set memo value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $memo
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setMemo(array $memo = array())
    {
        // validation for constraint: array
        if ('' !== ($memoArrayErrorMessage = self::validateMemoForArrayConstraintsFromSetMemo($memo))) {
            throw new \InvalidArgumentException($memoArrayErrorMessage, __LINE__);
        }
        $this->memo = $memo;
        return $this;
    }
    /**
     * Add item to memo value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToMemo(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The memo property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->memo[] = $item;
        return $this;
    }
    /**
     * Get quantityavailable value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getQuantityavailable()
    {
        return $this->quantityavailable;
    }
    /**
     * This method is responsible for validating the values passed to the setQuantityavailable method
     * This method is willingly generated in order to preserve the one-line inline validation within the setQuantityavailable method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateQuantityavailableForArrayConstraintsFromSetQuantityavailable(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicQuantityavailableItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicQuantityavailableItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicQuantityavailableItem) ? get_class($inventoryNumberSearchRowBasicQuantityavailableItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicQuantityavailableItem), var_export($inventoryNumberSearchRowBasicQuantityavailableItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The quantityavailable property can only contain items of type \StructType\SearchColumnDoubleField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set quantityavailable value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $quantityavailable
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setQuantityavailable(array $quantityavailable = array())
    {
        // validation for constraint: array
        if ('' !== ($quantityavailableArrayErrorMessage = self::validateQuantityavailableForArrayConstraintsFromSetQuantityavailable($quantityavailable))) {
            throw new \InvalidArgumentException($quantityavailableArrayErrorMessage, __LINE__);
        }
        $this->quantityavailable = $quantityavailable;
        return $this;
    }
    /**
     * Add item to quantityavailable value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToQuantityavailable(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The quantityavailable property can only contain items of type \StructType\SearchColumnDoubleField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->quantityavailable[] = $item;
        return $this;
    }
    /**
     * Get quantityintransit value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getQuantityintransit()
    {
        return $this->quantityintransit;
    }
    /**
     * This method is responsible for validating the values passed to the setQuantityintransit method
     * This method is willingly generated in order to preserve the one-line inline validation within the setQuantityintransit method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateQuantityintransitForArrayConstraintsFromSetQuantityintransit(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicQuantityintransitItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicQuantityintransitItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicQuantityintransitItem) ? get_class($inventoryNumberSearchRowBasicQuantityintransitItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicQuantityintransitItem), var_export($inventoryNumberSearchRowBasicQuantityintransitItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The quantityintransit property can only contain items of type \StructType\SearchColumnDoubleField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set quantityintransit value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $quantityintransit
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setQuantityintransit(array $quantityintransit = array())
    {
        // validation for constraint: array
        if ('' !== ($quantityintransitArrayErrorMessage = self::validateQuantityintransitForArrayConstraintsFromSetQuantityintransit($quantityintransit))) {
            throw new \InvalidArgumentException($quantityintransitArrayErrorMessage, __LINE__);
        }
        $this->quantityintransit = $quantityintransit;
        return $this;
    }
    /**
     * Add item to quantityintransit value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToQuantityintransit(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The quantityintransit property can only contain items of type \StructType\SearchColumnDoubleField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->quantityintransit[] = $item;
        return $this;
    }
    /**
     * Get quantityonhand value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getQuantityonhand()
    {
        return $this->quantityonhand;
    }
    /**
     * This method is responsible for validating the values passed to the setQuantityonhand method
     * This method is willingly generated in order to preserve the one-line inline validation within the setQuantityonhand method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateQuantityonhandForArrayConstraintsFromSetQuantityonhand(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicQuantityonhandItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicQuantityonhandItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicQuantityonhandItem) ? get_class($inventoryNumberSearchRowBasicQuantityonhandItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicQuantityonhandItem), var_export($inventoryNumberSearchRowBasicQuantityonhandItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The quantityonhand property can only contain items of type \StructType\SearchColumnDoubleField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set quantityonhand value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $quantityonhand
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setQuantityonhand(array $quantityonhand = array())
    {
        // validation for constraint: array
        if ('' !== ($quantityonhandArrayErrorMessage = self::validateQuantityonhandForArrayConstraintsFromSetQuantityonhand($quantityonhand))) {
            throw new \InvalidArgumentException($quantityonhandArrayErrorMessage, __LINE__);
        }
        $this->quantityonhand = $quantityonhand;
        return $this;
    }
    /**
     * Add item to quantityonhand value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToQuantityonhand(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The quantityonhand property can only contain items of type \StructType\SearchColumnDoubleField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->quantityonhand[] = $item;
        return $this;
    }
    /**
     * Get quantityonorder value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getQuantityonorder()
    {
        return $this->quantityonorder;
    }
    /**
     * This method is responsible for validating the values passed to the setQuantityonorder method
     * This method is willingly generated in order to preserve the one-line inline validation within the setQuantityonorder method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateQuantityonorderForArrayConstraintsFromSetQuantityonorder(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $inventoryNumberSearchRowBasicQuantityonorderItem) {
            // validation for constraint: itemType
            if (!$inventoryNumberSearchRowBasicQuantityonorderItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($inventoryNumberSearchRowBasicQuantityonorderItem) ? get_class($inventoryNumberSearchRowBasicQuantityonorderItem) : sprintf('%s(%s)', gettype($inventoryNumberSearchRowBasicQuantityonorderItem), var_export($inventoryNumberSearchRowBasicQuantityonorderItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The quantityonorder property can only contain items of type \StructType\SearchColumnDoubleField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set quantityonorder value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $quantityonorder
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setQuantityonorder(array $quantityonorder = array())
    {
        // validation for constraint: array
        if ('' !== ($quantityonorderArrayErrorMessage = self::validateQuantityonorderForArrayConstraintsFromSetQuantityonorder($quantityonorder))) {
            throw new \InvalidArgumentException($quantityonorderArrayErrorMessage, __LINE__);
        }
        $this->quantityonorder = $quantityonorder;
        return $this;
    }
    /**
     * Add item to quantityonorder value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function addToQuantityonorder(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The quantityonorder property can only contain items of type \StructType\SearchColumnDoubleField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->quantityonorder[] = $item;
        return $this;
    }
    /**
     * Get customFieldList value
     * @return \StructType\SearchColumnCustomFieldList|null
     */
    public function getCustomFieldList()
    {
        return $this->customFieldList;
    }
    /**
     * Set customFieldList value
     * @param \StructType\SearchColumnCustomFieldList $customFieldList
     * @return \StructType\InventoryNumberSearchRowBasic
     */
    public function setCustomFieldList(\StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this->customFieldList = $customFieldList;
        return $this;
    }
}
