<?php

namespace StructType;

use \WsdlToPhp\PackageBase\AbstractStructBase;

/**
 * This class stands for ManufacturingRoutingSearchRowBasic StructType
 * @subpackage Structs
 */
class ManufacturingRoutingSearchRowBasic extends SearchRowBasic
{
    /**
     * The autoCalculateLag
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $autoCalculateLag;
    /**
     * The billOfMaterials
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $billOfMaterials;
    /**
     * 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 isDefault
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isDefault;
    /**
     * The isInactive
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isInactive;
    /**
     * The item
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $item;
    /**
     * The lagAmount
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $lagAmount;
    /**
     * The lagType
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnEnumSelectField[]
     */
    public $lagType;
    /**
     * The lagUnits
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $lagUnits;
    /**
     * The location
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $location;
    /**
     * The manufacturingCostTemplate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $manufacturingCostTemplate;
    /**
     * The manufacturingWorkCenter
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $manufacturingWorkCenter;
    /**
     * The memo
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $memo;
    /**
     * The name
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $name;
    /**
     * The operationName
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $operationName;
    /**
     * The operationYield
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $operationYield;
    /**
     * The runRate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $runRate;
    /**
     * The sequence
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnLongField[]
     */
    public $sequence;
    /**
     * The setupTime
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $setupTime;
    /**
     * The subsidiary
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $subsidiary;
    /**
     * The customFieldList
     * Meta information extracted from the WSDL
     * - minOccurs: 0
     * @var \StructType\SearchColumnCustomFieldList
     */
    public $customFieldList;
    /**
     * Constructor method for ManufacturingRoutingSearchRowBasic
     * @uses ManufacturingRoutingSearchRowBasic::setAutoCalculateLag()
     * @uses ManufacturingRoutingSearchRowBasic::setBillOfMaterials()
     * @uses ManufacturingRoutingSearchRowBasic::setExternalId()
     * @uses ManufacturingRoutingSearchRowBasic::setInternalId()
     * @uses ManufacturingRoutingSearchRowBasic::setIsDefault()
     * @uses ManufacturingRoutingSearchRowBasic::setIsInactive()
     * @uses ManufacturingRoutingSearchRowBasic::setItem()
     * @uses ManufacturingRoutingSearchRowBasic::setLagAmount()
     * @uses ManufacturingRoutingSearchRowBasic::setLagType()
     * @uses ManufacturingRoutingSearchRowBasic::setLagUnits()
     * @uses ManufacturingRoutingSearchRowBasic::setLocation()
     * @uses ManufacturingRoutingSearchRowBasic::setManufacturingCostTemplate()
     * @uses ManufacturingRoutingSearchRowBasic::setManufacturingWorkCenter()
     * @uses ManufacturingRoutingSearchRowBasic::setMemo()
     * @uses ManufacturingRoutingSearchRowBasic::setName()
     * @uses ManufacturingRoutingSearchRowBasic::setOperationName()
     * @uses ManufacturingRoutingSearchRowBasic::setOperationYield()
     * @uses ManufacturingRoutingSearchRowBasic::setRunRate()
     * @uses ManufacturingRoutingSearchRowBasic::setSequence()
     * @uses ManufacturingRoutingSearchRowBasic::setSetupTime()
     * @uses ManufacturingRoutingSearchRowBasic::setSubsidiary()
     * @uses ManufacturingRoutingSearchRowBasic::setCustomFieldList()
     * @param \StructType\SearchColumnBooleanField[] $autoCalculateLag
     * @param \StructType\SearchColumnSelectField[] $billOfMaterials
     * @param \StructType\SearchColumnSelectField[] $externalId
     * @param \StructType\SearchColumnSelectField[] $internalId
     * @param \StructType\SearchColumnBooleanField[] $isDefault
     * @param \StructType\SearchColumnBooleanField[] $isInactive
     * @param \StructType\SearchColumnSelectField[] $item
     * @param \StructType\SearchColumnDoubleField[] $lagAmount
     * @param \StructType\SearchColumnEnumSelectField[] $lagType
     * @param \StructType\SearchColumnStringField[] $lagUnits
     * @param \StructType\SearchColumnSelectField[] $location
     * @param \StructType\SearchColumnSelectField[] $manufacturingCostTemplate
     * @param \StructType\SearchColumnSelectField[] $manufacturingWorkCenter
     * @param \StructType\SearchColumnStringField[] $memo
     * @param \StructType\SearchColumnStringField[] $name
     * @param \StructType\SearchColumnStringField[] $operationName
     * @param \StructType\SearchColumnDoubleField[] $operationYield
     * @param \StructType\SearchColumnDoubleField[] $runRate
     * @param \StructType\SearchColumnLongField[] $sequence
     * @param \StructType\SearchColumnDoubleField[] $setupTime
     * @param \StructType\SearchColumnSelectField[] $subsidiary
     * @param \StructType\SearchColumnCustomFieldList $customFieldList
     */
    public function __construct(array $autoCalculateLag = array(), array $billOfMaterials = array(), array $externalId = array(), array $internalId = array(), array $isDefault = array(), array $isInactive = array(), array $item = array(), array $lagAmount = array(), array $lagType = array(), array $lagUnits = array(), array $location = array(), array $manufacturingCostTemplate = array(), array $manufacturingWorkCenter = array(), array $memo = array(), array $name = array(), array $operationName = array(), array $operationYield = array(), array $runRate = array(), array $sequence = array(), array $setupTime = array(), array $subsidiary = array(), \StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this
            ->setAutoCalculateLag($autoCalculateLag)
            ->setBillOfMaterials($billOfMaterials)
            ->setExternalId($externalId)
            ->setInternalId($internalId)
            ->setIsDefault($isDefault)
            ->setIsInactive($isInactive)
            ->setItem($item)
            ->setLagAmount($lagAmount)
            ->setLagType($lagType)
            ->setLagUnits($lagUnits)
            ->setLocation($location)
            ->setManufacturingCostTemplate($manufacturingCostTemplate)
            ->setManufacturingWorkCenter($manufacturingWorkCenter)
            ->setMemo($memo)
            ->setName($name)
            ->setOperationName($operationName)
            ->setOperationYield($operationYield)
            ->setRunRate($runRate)
            ->setSequence($sequence)
            ->setSetupTime($setupTime)
            ->setSubsidiary($subsidiary)
            ->setCustomFieldList($customFieldList);
    }
    /**
     * Get autoCalculateLag value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getAutoCalculateLag()
    {
        return $this->autoCalculateLag;
    }
    /**
     * This method is responsible for validating the values passed to the setAutoCalculateLag method
     * This method is willingly generated in order to preserve the one-line inline validation within the setAutoCalculateLag method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateAutoCalculateLagForArrayConstraintsFromSetAutoCalculateLag(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicAutoCalculateLagItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicAutoCalculateLagItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicAutoCalculateLagItem) ? get_class($manufacturingRoutingSearchRowBasicAutoCalculateLagItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicAutoCalculateLagItem), var_export($manufacturingRoutingSearchRowBasicAutoCalculateLagItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The autoCalculateLag 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 autoCalculateLag value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $autoCalculateLag
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setAutoCalculateLag(array $autoCalculateLag = array())
    {
        // validation for constraint: array
        if ('' !== ($autoCalculateLagArrayErrorMessage = self::validateAutoCalculateLagForArrayConstraintsFromSetAutoCalculateLag($autoCalculateLag))) {
            throw new \InvalidArgumentException($autoCalculateLagArrayErrorMessage, __LINE__);
        }
        $this->autoCalculateLag = $autoCalculateLag;
        return $this;
    }
    /**
     * Add item to autoCalculateLag value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToAutoCalculateLag(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The autoCalculateLag 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->autoCalculateLag[] = $item;
        return $this;
    }
    /**
     * Get billOfMaterials value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getBillOfMaterials()
    {
        return $this->billOfMaterials;
    }
    /**
     * This method is responsible for validating the values passed to the setBillOfMaterials method
     * This method is willingly generated in order to preserve the one-line inline validation within the setBillOfMaterials method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateBillOfMaterialsForArrayConstraintsFromSetBillOfMaterials(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicBillOfMaterialsItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicBillOfMaterialsItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicBillOfMaterialsItem) ? get_class($manufacturingRoutingSearchRowBasicBillOfMaterialsItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicBillOfMaterialsItem), var_export($manufacturingRoutingSearchRowBasicBillOfMaterialsItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The billOfMaterials 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 billOfMaterials value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $billOfMaterials
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setBillOfMaterials(array $billOfMaterials = array())
    {
        // validation for constraint: array
        if ('' !== ($billOfMaterialsArrayErrorMessage = self::validateBillOfMaterialsForArrayConstraintsFromSetBillOfMaterials($billOfMaterials))) {
            throw new \InvalidArgumentException($billOfMaterialsArrayErrorMessage, __LINE__);
        }
        $this->billOfMaterials = $billOfMaterials;
        return $this;
    }
    /**
     * Add item to billOfMaterials value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToBillOfMaterials(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The billOfMaterials 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->billOfMaterials[] = $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 $manufacturingRoutingSearchRowBasicExternalIdItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicExternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicExternalIdItem) ? get_class($manufacturingRoutingSearchRowBasicExternalIdItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicExternalIdItem), var_export($manufacturingRoutingSearchRowBasicExternalIdItem, 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\ManufacturingRoutingSearchRowBasic
     */
    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\ManufacturingRoutingSearchRowBasic
     */
    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 $manufacturingRoutingSearchRowBasicInternalIdItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicInternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicInternalIdItem) ? get_class($manufacturingRoutingSearchRowBasicInternalIdItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicInternalIdItem), var_export($manufacturingRoutingSearchRowBasicInternalIdItem, 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\ManufacturingRoutingSearchRowBasic
     */
    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\ManufacturingRoutingSearchRowBasic
     */
    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 isDefault value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsDefault()
    {
        return $this->isDefault;
    }
    /**
     * This method is responsible for validating the values passed to the setIsDefault method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsDefault method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsDefaultForArrayConstraintsFromSetIsDefault(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicIsDefaultItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicIsDefaultItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicIsDefaultItem) ? get_class($manufacturingRoutingSearchRowBasicIsDefaultItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicIsDefaultItem), var_export($manufacturingRoutingSearchRowBasicIsDefaultItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isDefault 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 isDefault value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isDefault
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setIsDefault(array $isDefault = array())
    {
        // validation for constraint: array
        if ('' !== ($isDefaultArrayErrorMessage = self::validateIsDefaultForArrayConstraintsFromSetIsDefault($isDefault))) {
            throw new \InvalidArgumentException($isDefaultArrayErrorMessage, __LINE__);
        }
        $this->isDefault = $isDefault;
        return $this;
    }
    /**
     * Add item to isDefault value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToIsDefault(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isDefault 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->isDefault[] = $item;
        return $this;
    }
    /**
     * Get isInactive value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsInactive()
    {
        return $this->isInactive;
    }
    /**
     * This method is responsible for validating the values passed to the setIsInactive method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsInactive method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsInactiveForArrayConstraintsFromSetIsInactive(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicIsInactiveItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicIsInactiveItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicIsInactiveItem) ? get_class($manufacturingRoutingSearchRowBasicIsInactiveItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicIsInactiveItem), var_export($manufacturingRoutingSearchRowBasicIsInactiveItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isInactive 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 isInactive value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isInactive
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setIsInactive(array $isInactive = array())
    {
        // validation for constraint: array
        if ('' !== ($isInactiveArrayErrorMessage = self::validateIsInactiveForArrayConstraintsFromSetIsInactive($isInactive))) {
            throw new \InvalidArgumentException($isInactiveArrayErrorMessage, __LINE__);
        }
        $this->isInactive = $isInactive;
        return $this;
    }
    /**
     * Add item to isInactive value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToIsInactive(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isInactive 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->isInactive[] = $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 $manufacturingRoutingSearchRowBasicItemItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicItemItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicItemItem) ? get_class($manufacturingRoutingSearchRowBasicItemItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicItemItem), var_export($manufacturingRoutingSearchRowBasicItemItem, 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\ManufacturingRoutingSearchRowBasic
     */
    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\ManufacturingRoutingSearchRowBasic
     */
    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 lagAmount value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getLagAmount()
    {
        return $this->lagAmount;
    }
    /**
     * This method is responsible for validating the values passed to the setLagAmount method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLagAmount method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLagAmountForArrayConstraintsFromSetLagAmount(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicLagAmountItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicLagAmountItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicLagAmountItem) ? get_class($manufacturingRoutingSearchRowBasicLagAmountItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicLagAmountItem), var_export($manufacturingRoutingSearchRowBasicLagAmountItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The lagAmount 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 lagAmount value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $lagAmount
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setLagAmount(array $lagAmount = array())
    {
        // validation for constraint: array
        if ('' !== ($lagAmountArrayErrorMessage = self::validateLagAmountForArrayConstraintsFromSetLagAmount($lagAmount))) {
            throw new \InvalidArgumentException($lagAmountArrayErrorMessage, __LINE__);
        }
        $this->lagAmount = $lagAmount;
        return $this;
    }
    /**
     * Add item to lagAmount value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToLagAmount(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The lagAmount 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->lagAmount[] = $item;
        return $this;
    }
    /**
     * Get lagType value
     * @return \StructType\SearchColumnEnumSelectField[]|null
     */
    public function getLagType()
    {
        return $this->lagType;
    }
    /**
     * This method is responsible for validating the values passed to the setLagType method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLagType method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLagTypeForArrayConstraintsFromSetLagType(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicLagTypeItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicLagTypeItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicLagTypeItem) ? get_class($manufacturingRoutingSearchRowBasicLagTypeItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicLagTypeItem), var_export($manufacturingRoutingSearchRowBasicLagTypeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The lagType property can only contain items of type \StructType\SearchColumnEnumSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set lagType value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField[] $lagType
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setLagType(array $lagType = array())
    {
        // validation for constraint: array
        if ('' !== ($lagTypeArrayErrorMessage = self::validateLagTypeForArrayConstraintsFromSetLagType($lagType))) {
            throw new \InvalidArgumentException($lagTypeArrayErrorMessage, __LINE__);
        }
        $this->lagType = $lagType;
        return $this;
    }
    /**
     * Add item to lagType value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToLagType(\StructType\SearchColumnEnumSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnEnumSelectField) {
            throw new \InvalidArgumentException(sprintf('The lagType property can only contain items of type \StructType\SearchColumnEnumSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->lagType[] = $item;
        return $this;
    }
    /**
     * Get lagUnits value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getLagUnits()
    {
        return $this->lagUnits;
    }
    /**
     * This method is responsible for validating the values passed to the setLagUnits method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLagUnits method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLagUnitsForArrayConstraintsFromSetLagUnits(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicLagUnitsItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicLagUnitsItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicLagUnitsItem) ? get_class($manufacturingRoutingSearchRowBasicLagUnitsItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicLagUnitsItem), var_export($manufacturingRoutingSearchRowBasicLagUnitsItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The lagUnits 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 lagUnits value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $lagUnits
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setLagUnits(array $lagUnits = array())
    {
        // validation for constraint: array
        if ('' !== ($lagUnitsArrayErrorMessage = self::validateLagUnitsForArrayConstraintsFromSetLagUnits($lagUnits))) {
            throw new \InvalidArgumentException($lagUnitsArrayErrorMessage, __LINE__);
        }
        $this->lagUnits = $lagUnits;
        return $this;
    }
    /**
     * Add item to lagUnits value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToLagUnits(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The lagUnits 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->lagUnits[] = $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 $manufacturingRoutingSearchRowBasicLocationItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicLocationItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicLocationItem) ? get_class($manufacturingRoutingSearchRowBasicLocationItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicLocationItem), var_export($manufacturingRoutingSearchRowBasicLocationItem, 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\ManufacturingRoutingSearchRowBasic
     */
    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\ManufacturingRoutingSearchRowBasic
     */
    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 manufacturingCostTemplate value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getManufacturingCostTemplate()
    {
        return $this->manufacturingCostTemplate;
    }
    /**
     * This method is responsible for validating the values passed to the setManufacturingCostTemplate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setManufacturingCostTemplate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateManufacturingCostTemplateForArrayConstraintsFromSetManufacturingCostTemplate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicManufacturingCostTemplateItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicManufacturingCostTemplateItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicManufacturingCostTemplateItem) ? get_class($manufacturingRoutingSearchRowBasicManufacturingCostTemplateItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicManufacturingCostTemplateItem), var_export($manufacturingRoutingSearchRowBasicManufacturingCostTemplateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The manufacturingCostTemplate 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 manufacturingCostTemplate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $manufacturingCostTemplate
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setManufacturingCostTemplate(array $manufacturingCostTemplate = array())
    {
        // validation for constraint: array
        if ('' !== ($manufacturingCostTemplateArrayErrorMessage = self::validateManufacturingCostTemplateForArrayConstraintsFromSetManufacturingCostTemplate($manufacturingCostTemplate))) {
            throw new \InvalidArgumentException($manufacturingCostTemplateArrayErrorMessage, __LINE__);
        }
        $this->manufacturingCostTemplate = $manufacturingCostTemplate;
        return $this;
    }
    /**
     * Add item to manufacturingCostTemplate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToManufacturingCostTemplate(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The manufacturingCostTemplate 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->manufacturingCostTemplate[] = $item;
        return $this;
    }
    /**
     * Get manufacturingWorkCenter value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getManufacturingWorkCenter()
    {
        return $this->manufacturingWorkCenter;
    }
    /**
     * This method is responsible for validating the values passed to the setManufacturingWorkCenter method
     * This method is willingly generated in order to preserve the one-line inline validation within the setManufacturingWorkCenter method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateManufacturingWorkCenterForArrayConstraintsFromSetManufacturingWorkCenter(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicManufacturingWorkCenterItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicManufacturingWorkCenterItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicManufacturingWorkCenterItem) ? get_class($manufacturingRoutingSearchRowBasicManufacturingWorkCenterItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicManufacturingWorkCenterItem), var_export($manufacturingRoutingSearchRowBasicManufacturingWorkCenterItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The manufacturingWorkCenter 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 manufacturingWorkCenter value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $manufacturingWorkCenter
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setManufacturingWorkCenter(array $manufacturingWorkCenter = array())
    {
        // validation for constraint: array
        if ('' !== ($manufacturingWorkCenterArrayErrorMessage = self::validateManufacturingWorkCenterForArrayConstraintsFromSetManufacturingWorkCenter($manufacturingWorkCenter))) {
            throw new \InvalidArgumentException($manufacturingWorkCenterArrayErrorMessage, __LINE__);
        }
        $this->manufacturingWorkCenter = $manufacturingWorkCenter;
        return $this;
    }
    /**
     * Add item to manufacturingWorkCenter value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToManufacturingWorkCenter(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The manufacturingWorkCenter 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->manufacturingWorkCenter[] = $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 $manufacturingRoutingSearchRowBasicMemoItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicMemoItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicMemoItem) ? get_class($manufacturingRoutingSearchRowBasicMemoItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicMemoItem), var_export($manufacturingRoutingSearchRowBasicMemoItem, 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\ManufacturingRoutingSearchRowBasic
     */
    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\ManufacturingRoutingSearchRowBasic
     */
    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 name value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getName()
    {
        return $this->name;
    }
    /**
     * This method is responsible for validating the values passed to the setName method
     * This method is willingly generated in order to preserve the one-line inline validation within the setName method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateNameForArrayConstraintsFromSetName(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicNameItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicNameItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicNameItem) ? get_class($manufacturingRoutingSearchRowBasicNameItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicNameItem), var_export($manufacturingRoutingSearchRowBasicNameItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The name 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 name value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $name
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setName(array $name = array())
    {
        // validation for constraint: array
        if ('' !== ($nameArrayErrorMessage = self::validateNameForArrayConstraintsFromSetName($name))) {
            throw new \InvalidArgumentException($nameArrayErrorMessage, __LINE__);
        }
        $this->name = $name;
        return $this;
    }
    /**
     * Add item to name value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToName(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The name 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->name[] = $item;
        return $this;
    }
    /**
     * Get operationName value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getOperationName()
    {
        return $this->operationName;
    }
    /**
     * This method is responsible for validating the values passed to the setOperationName method
     * This method is willingly generated in order to preserve the one-line inline validation within the setOperationName method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateOperationNameForArrayConstraintsFromSetOperationName(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicOperationNameItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicOperationNameItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicOperationNameItem) ? get_class($manufacturingRoutingSearchRowBasicOperationNameItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicOperationNameItem), var_export($manufacturingRoutingSearchRowBasicOperationNameItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The operationName 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 operationName value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $operationName
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setOperationName(array $operationName = array())
    {
        // validation for constraint: array
        if ('' !== ($operationNameArrayErrorMessage = self::validateOperationNameForArrayConstraintsFromSetOperationName($operationName))) {
            throw new \InvalidArgumentException($operationNameArrayErrorMessage, __LINE__);
        }
        $this->operationName = $operationName;
        return $this;
    }
    /**
     * Add item to operationName value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToOperationName(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The operationName 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->operationName[] = $item;
        return $this;
    }
    /**
     * Get operationYield value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getOperationYield()
    {
        return $this->operationYield;
    }
    /**
     * This method is responsible for validating the values passed to the setOperationYield method
     * This method is willingly generated in order to preserve the one-line inline validation within the setOperationYield method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateOperationYieldForArrayConstraintsFromSetOperationYield(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicOperationYieldItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicOperationYieldItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicOperationYieldItem) ? get_class($manufacturingRoutingSearchRowBasicOperationYieldItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicOperationYieldItem), var_export($manufacturingRoutingSearchRowBasicOperationYieldItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The operationYield 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 operationYield value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $operationYield
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setOperationYield(array $operationYield = array())
    {
        // validation for constraint: array
        if ('' !== ($operationYieldArrayErrorMessage = self::validateOperationYieldForArrayConstraintsFromSetOperationYield($operationYield))) {
            throw new \InvalidArgumentException($operationYieldArrayErrorMessage, __LINE__);
        }
        $this->operationYield = $operationYield;
        return $this;
    }
    /**
     * Add item to operationYield value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToOperationYield(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The operationYield 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->operationYield[] = $item;
        return $this;
    }
    /**
     * Get runRate value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getRunRate()
    {
        return $this->runRate;
    }
    /**
     * This method is responsible for validating the values passed to the setRunRate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setRunRate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateRunRateForArrayConstraintsFromSetRunRate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicRunRateItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicRunRateItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicRunRateItem) ? get_class($manufacturingRoutingSearchRowBasicRunRateItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicRunRateItem), var_export($manufacturingRoutingSearchRowBasicRunRateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The runRate 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 runRate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $runRate
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setRunRate(array $runRate = array())
    {
        // validation for constraint: array
        if ('' !== ($runRateArrayErrorMessage = self::validateRunRateForArrayConstraintsFromSetRunRate($runRate))) {
            throw new \InvalidArgumentException($runRateArrayErrorMessage, __LINE__);
        }
        $this->runRate = $runRate;
        return $this;
    }
    /**
     * Add item to runRate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToRunRate(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The runRate 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->runRate[] = $item;
        return $this;
    }
    /**
     * Get sequence value
     * @return \StructType\SearchColumnLongField[]|null
     */
    public function getSequence()
    {
        return $this->sequence;
    }
    /**
     * This method is responsible for validating the values passed to the setSequence method
     * This method is willingly generated in order to preserve the one-line inline validation within the setSequence method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateSequenceForArrayConstraintsFromSetSequence(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicSequenceItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicSequenceItem instanceof \StructType\SearchColumnLongField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicSequenceItem) ? get_class($manufacturingRoutingSearchRowBasicSequenceItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicSequenceItem), var_export($manufacturingRoutingSearchRowBasicSequenceItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The sequence property can only contain items of type \StructType\SearchColumnLongField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set sequence value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnLongField[] $sequence
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setSequence(array $sequence = array())
    {
        // validation for constraint: array
        if ('' !== ($sequenceArrayErrorMessage = self::validateSequenceForArrayConstraintsFromSetSequence($sequence))) {
            throw new \InvalidArgumentException($sequenceArrayErrorMessage, __LINE__);
        }
        $this->sequence = $sequence;
        return $this;
    }
    /**
     * Add item to sequence value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnLongField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToSequence(\StructType\SearchColumnLongField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnLongField) {
            throw new \InvalidArgumentException(sprintf('The sequence property can only contain items of type \StructType\SearchColumnLongField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->sequence[] = $item;
        return $this;
    }
    /**
     * Get setupTime value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getSetupTime()
    {
        return $this->setupTime;
    }
    /**
     * This method is responsible for validating the values passed to the setSetupTime method
     * This method is willingly generated in order to preserve the one-line inline validation within the setSetupTime method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateSetupTimeForArrayConstraintsFromSetSetupTime(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicSetupTimeItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicSetupTimeItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicSetupTimeItem) ? get_class($manufacturingRoutingSearchRowBasicSetupTimeItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicSetupTimeItem), var_export($manufacturingRoutingSearchRowBasicSetupTimeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The setupTime 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 setupTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $setupTime
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setSetupTime(array $setupTime = array())
    {
        // validation for constraint: array
        if ('' !== ($setupTimeArrayErrorMessage = self::validateSetupTimeForArrayConstraintsFromSetSetupTime($setupTime))) {
            throw new \InvalidArgumentException($setupTimeArrayErrorMessage, __LINE__);
        }
        $this->setupTime = $setupTime;
        return $this;
    }
    /**
     * Add item to setupTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToSetupTime(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The setupTime 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->setupTime[] = $item;
        return $this;
    }
    /**
     * Get subsidiary value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getSubsidiary()
    {
        return $this->subsidiary;
    }
    /**
     * This method is responsible for validating the values passed to the setSubsidiary method
     * This method is willingly generated in order to preserve the one-line inline validation within the setSubsidiary method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateSubsidiaryForArrayConstraintsFromSetSubsidiary(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingRoutingSearchRowBasicSubsidiaryItem) {
            // validation for constraint: itemType
            if (!$manufacturingRoutingSearchRowBasicSubsidiaryItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingRoutingSearchRowBasicSubsidiaryItem) ? get_class($manufacturingRoutingSearchRowBasicSubsidiaryItem) : sprintf('%s(%s)', gettype($manufacturingRoutingSearchRowBasicSubsidiaryItem), var_export($manufacturingRoutingSearchRowBasicSubsidiaryItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The subsidiary 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 subsidiary value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $subsidiary
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function setSubsidiary(array $subsidiary = array())
    {
        // validation for constraint: array
        if ('' !== ($subsidiaryArrayErrorMessage = self::validateSubsidiaryForArrayConstraintsFromSetSubsidiary($subsidiary))) {
            throw new \InvalidArgumentException($subsidiaryArrayErrorMessage, __LINE__);
        }
        $this->subsidiary = $subsidiary;
        return $this;
    }
    /**
     * Add item to subsidiary value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\ManufacturingRoutingSearchRowBasic
     */
    public function addToSubsidiary(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The subsidiary 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->subsidiary[] = $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\ManufacturingRoutingSearchRowBasic
     */
    public function setCustomFieldList(\StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this->customFieldList = $customFieldList;
        return $this;
    }
}
