<?php

namespace StructType;

use \WsdlToPhp\PackageBase\AbstractStructBase;

/**
 * This class stands for ManufacturingOperationTaskSearchRowBasic StructType
 * @subpackage Structs
 */
class ManufacturingOperationTaskSearchRowBasic extends SearchRowBasic
{
    /**
     * The actualRunTime
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $actualRunTime;
    /**
     * The actualSetupTime
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $actualSetupTime;
    /**
     * The completedQuantity
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $completedQuantity;
    /**
     * The endDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $endDate;
    /**
     * The estimatedWork
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $estimatedWork;
    /**
     * The externalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $externalId;
    /**
     * The id
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnLongField[]
     */
    public $id;
    /**
     * The inputQuantity
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $inputQuantity;
    /**
     * The internalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $internalId;
    /**
     * The laborResources
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $laborResources;
    /**
     * 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 machineResources
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $machineResources;
    /**
     * 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 message
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $message;
    /**
     * The name
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $name;
    /**
     * The order
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $order;
    /**
     * The predecessor
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $predecessor;
    /**
     * The predecessorType
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $predecessorType;
    /**
     * The remainingQuantity
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $remainingQuantity;
    /**
     * The runRate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $runRate;
    /**
     * The runTime
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $runTime;
    /**
     * 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 startDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $startDate;
    /**
     * The status
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $status;
    /**
     * The workOrder
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $workOrder;
    /**
     * The customFieldList
     * Meta information extracted from the WSDL
     * - minOccurs: 0
     * @var \StructType\SearchColumnCustomFieldList
     */
    public $customFieldList;
    /**
     * Constructor method for ManufacturingOperationTaskSearchRowBasic
     * @uses ManufacturingOperationTaskSearchRowBasic::setActualRunTime()
     * @uses ManufacturingOperationTaskSearchRowBasic::setActualSetupTime()
     * @uses ManufacturingOperationTaskSearchRowBasic::setCompletedQuantity()
     * @uses ManufacturingOperationTaskSearchRowBasic::setEndDate()
     * @uses ManufacturingOperationTaskSearchRowBasic::setEstimatedWork()
     * @uses ManufacturingOperationTaskSearchRowBasic::setExternalId()
     * @uses ManufacturingOperationTaskSearchRowBasic::setId()
     * @uses ManufacturingOperationTaskSearchRowBasic::setInputQuantity()
     * @uses ManufacturingOperationTaskSearchRowBasic::setInternalId()
     * @uses ManufacturingOperationTaskSearchRowBasic::setLaborResources()
     * @uses ManufacturingOperationTaskSearchRowBasic::setLagAmount()
     * @uses ManufacturingOperationTaskSearchRowBasic::setLagType()
     * @uses ManufacturingOperationTaskSearchRowBasic::setLagUnits()
     * @uses ManufacturingOperationTaskSearchRowBasic::setMachineResources()
     * @uses ManufacturingOperationTaskSearchRowBasic::setManufacturingCostTemplate()
     * @uses ManufacturingOperationTaskSearchRowBasic::setManufacturingWorkCenter()
     * @uses ManufacturingOperationTaskSearchRowBasic::setMessage()
     * @uses ManufacturingOperationTaskSearchRowBasic::setName()
     * @uses ManufacturingOperationTaskSearchRowBasic::setOrder()
     * @uses ManufacturingOperationTaskSearchRowBasic::setPredecessor()
     * @uses ManufacturingOperationTaskSearchRowBasic::setPredecessorType()
     * @uses ManufacturingOperationTaskSearchRowBasic::setRemainingQuantity()
     * @uses ManufacturingOperationTaskSearchRowBasic::setRunRate()
     * @uses ManufacturingOperationTaskSearchRowBasic::setRunTime()
     * @uses ManufacturingOperationTaskSearchRowBasic::setSequence()
     * @uses ManufacturingOperationTaskSearchRowBasic::setSetupTime()
     * @uses ManufacturingOperationTaskSearchRowBasic::setStartDate()
     * @uses ManufacturingOperationTaskSearchRowBasic::setStatus()
     * @uses ManufacturingOperationTaskSearchRowBasic::setWorkOrder()
     * @uses ManufacturingOperationTaskSearchRowBasic::setCustomFieldList()
     * @param \StructType\SearchColumnDoubleField[] $actualRunTime
     * @param \StructType\SearchColumnDoubleField[] $actualSetupTime
     * @param \StructType\SearchColumnDoubleField[] $completedQuantity
     * @param \StructType\SearchColumnDateField[] $endDate
     * @param \StructType\SearchColumnDoubleField[] $estimatedWork
     * @param \StructType\SearchColumnSelectField[] $externalId
     * @param \StructType\SearchColumnLongField[] $id
     * @param \StructType\SearchColumnDoubleField[] $inputQuantity
     * @param \StructType\SearchColumnSelectField[] $internalId
     * @param \StructType\SearchColumnDoubleField[] $laborResources
     * @param \StructType\SearchColumnDoubleField[] $lagAmount
     * @param \StructType\SearchColumnEnumSelectField[] $lagType
     * @param \StructType\SearchColumnStringField[] $lagUnits
     * @param \StructType\SearchColumnDoubleField[] $machineResources
     * @param \StructType\SearchColumnSelectField[] $manufacturingCostTemplate
     * @param \StructType\SearchColumnSelectField[] $manufacturingWorkCenter
     * @param \StructType\SearchColumnStringField[] $message
     * @param \StructType\SearchColumnStringField[] $name
     * @param \StructType\SearchColumnDoubleField[] $order
     * @param \StructType\SearchColumnSelectField[] $predecessor
     * @param \StructType\SearchColumnStringField[] $predecessorType
     * @param \StructType\SearchColumnDoubleField[] $remainingQuantity
     * @param \StructType\SearchColumnDoubleField[] $runRate
     * @param \StructType\SearchColumnDoubleField[] $runTime
     * @param \StructType\SearchColumnLongField[] $sequence
     * @param \StructType\SearchColumnDoubleField[] $setupTime
     * @param \StructType\SearchColumnDateField[] $startDate
     * @param \StructType\SearchColumnSelectField[] $status
     * @param \StructType\SearchColumnStringField[] $workOrder
     * @param \StructType\SearchColumnCustomFieldList $customFieldList
     */
    public function __construct(array $actualRunTime = array(), array $actualSetupTime = array(), array $completedQuantity = array(), array $endDate = array(), array $estimatedWork = array(), array $externalId = array(), array $id = array(), array $inputQuantity = array(), array $internalId = array(), array $laborResources = array(), array $lagAmount = array(), array $lagType = array(), array $lagUnits = array(), array $machineResources = array(), array $manufacturingCostTemplate = array(), array $manufacturingWorkCenter = array(), array $message = array(), array $name = array(), array $order = array(), array $predecessor = array(), array $predecessorType = array(), array $remainingQuantity = array(), array $runRate = array(), array $runTime = array(), array $sequence = array(), array $setupTime = array(), array $startDate = array(), array $status = array(), array $workOrder = array(), \StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this
            ->setActualRunTime($actualRunTime)
            ->setActualSetupTime($actualSetupTime)
            ->setCompletedQuantity($completedQuantity)
            ->setEndDate($endDate)
            ->setEstimatedWork($estimatedWork)
            ->setExternalId($externalId)
            ->setId($id)
            ->setInputQuantity($inputQuantity)
            ->setInternalId($internalId)
            ->setLaborResources($laborResources)
            ->setLagAmount($lagAmount)
            ->setLagType($lagType)
            ->setLagUnits($lagUnits)
            ->setMachineResources($machineResources)
            ->setManufacturingCostTemplate($manufacturingCostTemplate)
            ->setManufacturingWorkCenter($manufacturingWorkCenter)
            ->setMessage($message)
            ->setName($name)
            ->setOrder($order)
            ->setPredecessor($predecessor)
            ->setPredecessorType($predecessorType)
            ->setRemainingQuantity($remainingQuantity)
            ->setRunRate($runRate)
            ->setRunTime($runTime)
            ->setSequence($sequence)
            ->setSetupTime($setupTime)
            ->setStartDate($startDate)
            ->setStatus($status)
            ->setWorkOrder($workOrder)
            ->setCustomFieldList($customFieldList);
    }
    /**
     * Get actualRunTime value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getActualRunTime()
    {
        return $this->actualRunTime;
    }
    /**
     * This method is responsible for validating the values passed to the setActualRunTime method
     * This method is willingly generated in order to preserve the one-line inline validation within the setActualRunTime method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateActualRunTimeForArrayConstraintsFromSetActualRunTime(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicActualRunTimeItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicActualRunTimeItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicActualRunTimeItem) ? get_class($manufacturingOperationTaskSearchRowBasicActualRunTimeItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicActualRunTimeItem), var_export($manufacturingOperationTaskSearchRowBasicActualRunTimeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The actualRunTime 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 actualRunTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $actualRunTime
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setActualRunTime(array $actualRunTime = array())
    {
        // validation for constraint: array
        if ('' !== ($actualRunTimeArrayErrorMessage = self::validateActualRunTimeForArrayConstraintsFromSetActualRunTime($actualRunTime))) {
            throw new \InvalidArgumentException($actualRunTimeArrayErrorMessage, __LINE__);
        }
        $this->actualRunTime = $actualRunTime;
        return $this;
    }
    /**
     * Add item to actualRunTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToActualRunTime(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The actualRunTime 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->actualRunTime[] = $item;
        return $this;
    }
    /**
     * Get actualSetupTime value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getActualSetupTime()
    {
        return $this->actualSetupTime;
    }
    /**
     * This method is responsible for validating the values passed to the setActualSetupTime method
     * This method is willingly generated in order to preserve the one-line inline validation within the setActualSetupTime method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateActualSetupTimeForArrayConstraintsFromSetActualSetupTime(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicActualSetupTimeItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicActualSetupTimeItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicActualSetupTimeItem) ? get_class($manufacturingOperationTaskSearchRowBasicActualSetupTimeItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicActualSetupTimeItem), var_export($manufacturingOperationTaskSearchRowBasicActualSetupTimeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The actualSetupTime 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 actualSetupTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $actualSetupTime
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setActualSetupTime(array $actualSetupTime = array())
    {
        // validation for constraint: array
        if ('' !== ($actualSetupTimeArrayErrorMessage = self::validateActualSetupTimeForArrayConstraintsFromSetActualSetupTime($actualSetupTime))) {
            throw new \InvalidArgumentException($actualSetupTimeArrayErrorMessage, __LINE__);
        }
        $this->actualSetupTime = $actualSetupTime;
        return $this;
    }
    /**
     * Add item to actualSetupTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToActualSetupTime(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The actualSetupTime 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->actualSetupTime[] = $item;
        return $this;
    }
    /**
     * Get completedQuantity value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getCompletedQuantity()
    {
        return $this->completedQuantity;
    }
    /**
     * This method is responsible for validating the values passed to the setCompletedQuantity method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCompletedQuantity method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCompletedQuantityForArrayConstraintsFromSetCompletedQuantity(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicCompletedQuantityItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicCompletedQuantityItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicCompletedQuantityItem) ? get_class($manufacturingOperationTaskSearchRowBasicCompletedQuantityItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicCompletedQuantityItem), var_export($manufacturingOperationTaskSearchRowBasicCompletedQuantityItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The completedQuantity 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 completedQuantity value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $completedQuantity
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setCompletedQuantity(array $completedQuantity = array())
    {
        // validation for constraint: array
        if ('' !== ($completedQuantityArrayErrorMessage = self::validateCompletedQuantityForArrayConstraintsFromSetCompletedQuantity($completedQuantity))) {
            throw new \InvalidArgumentException($completedQuantityArrayErrorMessage, __LINE__);
        }
        $this->completedQuantity = $completedQuantity;
        return $this;
    }
    /**
     * Add item to completedQuantity value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToCompletedQuantity(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The completedQuantity 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->completedQuantity[] = $item;
        return $this;
    }
    /**
     * Get endDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getEndDate()
    {
        return $this->endDate;
    }
    /**
     * This method is responsible for validating the values passed to the setEndDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEndDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEndDateForArrayConstraintsFromSetEndDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicEndDateItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicEndDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicEndDateItem) ? get_class($manufacturingOperationTaskSearchRowBasicEndDateItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicEndDateItem), var_export($manufacturingOperationTaskSearchRowBasicEndDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The endDate 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 endDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $endDate
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setEndDate(array $endDate = array())
    {
        // validation for constraint: array
        if ('' !== ($endDateArrayErrorMessage = self::validateEndDateForArrayConstraintsFromSetEndDate($endDate))) {
            throw new \InvalidArgumentException($endDateArrayErrorMessage, __LINE__);
        }
        $this->endDate = $endDate;
        return $this;
    }
    /**
     * Add item to endDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToEndDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The endDate 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->endDate[] = $item;
        return $this;
    }
    /**
     * Get estimatedWork value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getEstimatedWork()
    {
        return $this->estimatedWork;
    }
    /**
     * This method is responsible for validating the values passed to the setEstimatedWork method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEstimatedWork method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEstimatedWorkForArrayConstraintsFromSetEstimatedWork(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicEstimatedWorkItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicEstimatedWorkItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicEstimatedWorkItem) ? get_class($manufacturingOperationTaskSearchRowBasicEstimatedWorkItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicEstimatedWorkItem), var_export($manufacturingOperationTaskSearchRowBasicEstimatedWorkItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The estimatedWork 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 estimatedWork value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $estimatedWork
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setEstimatedWork(array $estimatedWork = array())
    {
        // validation for constraint: array
        if ('' !== ($estimatedWorkArrayErrorMessage = self::validateEstimatedWorkForArrayConstraintsFromSetEstimatedWork($estimatedWork))) {
            throw new \InvalidArgumentException($estimatedWorkArrayErrorMessage, __LINE__);
        }
        $this->estimatedWork = $estimatedWork;
        return $this;
    }
    /**
     * Add item to estimatedWork value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToEstimatedWork(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The estimatedWork 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->estimatedWork[] = $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 $manufacturingOperationTaskSearchRowBasicExternalIdItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicExternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicExternalIdItem) ? get_class($manufacturingOperationTaskSearchRowBasicExternalIdItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicExternalIdItem), var_export($manufacturingOperationTaskSearchRowBasicExternalIdItem, 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\ManufacturingOperationTaskSearchRowBasic
     */
    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\ManufacturingOperationTaskSearchRowBasic
     */
    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 id value
     * @return \StructType\SearchColumnLongField[]|null
     */
    public function getId()
    {
        return $this->id;
    }
    /**
     * This method is responsible for validating the values passed to the setId method
     * This method is willingly generated in order to preserve the one-line inline validation within the setId method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIdForArrayConstraintsFromSetId(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicIdItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicIdItem instanceof \StructType\SearchColumnLongField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicIdItem) ? get_class($manufacturingOperationTaskSearchRowBasicIdItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicIdItem), var_export($manufacturingOperationTaskSearchRowBasicIdItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The id 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 id value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnLongField[] $id
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setId(array $id = array())
    {
        // validation for constraint: array
        if ('' !== ($idArrayErrorMessage = self::validateIdForArrayConstraintsFromSetId($id))) {
            throw new \InvalidArgumentException($idArrayErrorMessage, __LINE__);
        }
        $this->id = $id;
        return $this;
    }
    /**
     * Add item to id value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnLongField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToId(\StructType\SearchColumnLongField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnLongField) {
            throw new \InvalidArgumentException(sprintf('The id 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->id[] = $item;
        return $this;
    }
    /**
     * Get inputQuantity value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getInputQuantity()
    {
        return $this->inputQuantity;
    }
    /**
     * This method is responsible for validating the values passed to the setInputQuantity method
     * This method is willingly generated in order to preserve the one-line inline validation within the setInputQuantity method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateInputQuantityForArrayConstraintsFromSetInputQuantity(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicInputQuantityItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicInputQuantityItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicInputQuantityItem) ? get_class($manufacturingOperationTaskSearchRowBasicInputQuantityItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicInputQuantityItem), var_export($manufacturingOperationTaskSearchRowBasicInputQuantityItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The inputQuantity 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 inputQuantity value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $inputQuantity
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setInputQuantity(array $inputQuantity = array())
    {
        // validation for constraint: array
        if ('' !== ($inputQuantityArrayErrorMessage = self::validateInputQuantityForArrayConstraintsFromSetInputQuantity($inputQuantity))) {
            throw new \InvalidArgumentException($inputQuantityArrayErrorMessage, __LINE__);
        }
        $this->inputQuantity = $inputQuantity;
        return $this;
    }
    /**
     * Add item to inputQuantity value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToInputQuantity(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The inputQuantity 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->inputQuantity[] = $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 $manufacturingOperationTaskSearchRowBasicInternalIdItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicInternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicInternalIdItem) ? get_class($manufacturingOperationTaskSearchRowBasicInternalIdItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicInternalIdItem), var_export($manufacturingOperationTaskSearchRowBasicInternalIdItem, 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\ManufacturingOperationTaskSearchRowBasic
     */
    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\ManufacturingOperationTaskSearchRowBasic
     */
    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 laborResources value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getLaborResources()
    {
        return $this->laborResources;
    }
    /**
     * This method is responsible for validating the values passed to the setLaborResources method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLaborResources method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLaborResourcesForArrayConstraintsFromSetLaborResources(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicLaborResourcesItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicLaborResourcesItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicLaborResourcesItem) ? get_class($manufacturingOperationTaskSearchRowBasicLaborResourcesItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicLaborResourcesItem), var_export($manufacturingOperationTaskSearchRowBasicLaborResourcesItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The laborResources 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 laborResources value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $laborResources
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setLaborResources(array $laborResources = array())
    {
        // validation for constraint: array
        if ('' !== ($laborResourcesArrayErrorMessage = self::validateLaborResourcesForArrayConstraintsFromSetLaborResources($laborResources))) {
            throw new \InvalidArgumentException($laborResourcesArrayErrorMessage, __LINE__);
        }
        $this->laborResources = $laborResources;
        return $this;
    }
    /**
     * Add item to laborResources value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToLaborResources(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The laborResources 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->laborResources[] = $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 $manufacturingOperationTaskSearchRowBasicLagAmountItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicLagAmountItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicLagAmountItem) ? get_class($manufacturingOperationTaskSearchRowBasicLagAmountItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicLagAmountItem), var_export($manufacturingOperationTaskSearchRowBasicLagAmountItem, 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\ManufacturingOperationTaskSearchRowBasic
     */
    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\ManufacturingOperationTaskSearchRowBasic
     */
    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 $manufacturingOperationTaskSearchRowBasicLagTypeItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicLagTypeItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicLagTypeItem) ? get_class($manufacturingOperationTaskSearchRowBasicLagTypeItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicLagTypeItem), var_export($manufacturingOperationTaskSearchRowBasicLagTypeItem, 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\ManufacturingOperationTaskSearchRowBasic
     */
    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\ManufacturingOperationTaskSearchRowBasic
     */
    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 $manufacturingOperationTaskSearchRowBasicLagUnitsItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicLagUnitsItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicLagUnitsItem) ? get_class($manufacturingOperationTaskSearchRowBasicLagUnitsItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicLagUnitsItem), var_export($manufacturingOperationTaskSearchRowBasicLagUnitsItem, 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\ManufacturingOperationTaskSearchRowBasic
     */
    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\ManufacturingOperationTaskSearchRowBasic
     */
    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 machineResources value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getMachineResources()
    {
        return $this->machineResources;
    }
    /**
     * This method is responsible for validating the values passed to the setMachineResources method
     * This method is willingly generated in order to preserve the one-line inline validation within the setMachineResources method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateMachineResourcesForArrayConstraintsFromSetMachineResources(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicMachineResourcesItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicMachineResourcesItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicMachineResourcesItem) ? get_class($manufacturingOperationTaskSearchRowBasicMachineResourcesItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicMachineResourcesItem), var_export($manufacturingOperationTaskSearchRowBasicMachineResourcesItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The machineResources 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 machineResources value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $machineResources
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setMachineResources(array $machineResources = array())
    {
        // validation for constraint: array
        if ('' !== ($machineResourcesArrayErrorMessage = self::validateMachineResourcesForArrayConstraintsFromSetMachineResources($machineResources))) {
            throw new \InvalidArgumentException($machineResourcesArrayErrorMessage, __LINE__);
        }
        $this->machineResources = $machineResources;
        return $this;
    }
    /**
     * Add item to machineResources value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToMachineResources(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The machineResources 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->machineResources[] = $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 $manufacturingOperationTaskSearchRowBasicManufacturingCostTemplateItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicManufacturingCostTemplateItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicManufacturingCostTemplateItem) ? get_class($manufacturingOperationTaskSearchRowBasicManufacturingCostTemplateItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicManufacturingCostTemplateItem), var_export($manufacturingOperationTaskSearchRowBasicManufacturingCostTemplateItem, 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\ManufacturingOperationTaskSearchRowBasic
     */
    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\ManufacturingOperationTaskSearchRowBasic
     */
    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 $manufacturingOperationTaskSearchRowBasicManufacturingWorkCenterItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicManufacturingWorkCenterItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicManufacturingWorkCenterItem) ? get_class($manufacturingOperationTaskSearchRowBasicManufacturingWorkCenterItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicManufacturingWorkCenterItem), var_export($manufacturingOperationTaskSearchRowBasicManufacturingWorkCenterItem, 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\ManufacturingOperationTaskSearchRowBasic
     */
    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\ManufacturingOperationTaskSearchRowBasic
     */
    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 message value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getMessage()
    {
        return $this->message;
    }
    /**
     * This method is responsible for validating the values passed to the setMessage method
     * This method is willingly generated in order to preserve the one-line inline validation within the setMessage method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateMessageForArrayConstraintsFromSetMessage(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicMessageItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicMessageItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicMessageItem) ? get_class($manufacturingOperationTaskSearchRowBasicMessageItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicMessageItem), var_export($manufacturingOperationTaskSearchRowBasicMessageItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The message 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 message value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $message
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setMessage(array $message = array())
    {
        // validation for constraint: array
        if ('' !== ($messageArrayErrorMessage = self::validateMessageForArrayConstraintsFromSetMessage($message))) {
            throw new \InvalidArgumentException($messageArrayErrorMessage, __LINE__);
        }
        $this->message = $message;
        return $this;
    }
    /**
     * Add item to message value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToMessage(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The message 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->message[] = $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 $manufacturingOperationTaskSearchRowBasicNameItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicNameItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicNameItem) ? get_class($manufacturingOperationTaskSearchRowBasicNameItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicNameItem), var_export($manufacturingOperationTaskSearchRowBasicNameItem, 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\ManufacturingOperationTaskSearchRowBasic
     */
    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\ManufacturingOperationTaskSearchRowBasic
     */
    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 order value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getOrder()
    {
        return $this->order;
    }
    /**
     * This method is responsible for validating the values passed to the setOrder method
     * This method is willingly generated in order to preserve the one-line inline validation within the setOrder method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateOrderForArrayConstraintsFromSetOrder(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicOrderItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicOrderItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicOrderItem) ? get_class($manufacturingOperationTaskSearchRowBasicOrderItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicOrderItem), var_export($manufacturingOperationTaskSearchRowBasicOrderItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The order 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 order value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $order
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setOrder(array $order = array())
    {
        // validation for constraint: array
        if ('' !== ($orderArrayErrorMessage = self::validateOrderForArrayConstraintsFromSetOrder($order))) {
            throw new \InvalidArgumentException($orderArrayErrorMessage, __LINE__);
        }
        $this->order = $order;
        return $this;
    }
    /**
     * Add item to order value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToOrder(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The order 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->order[] = $item;
        return $this;
    }
    /**
     * Get predecessor value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getPredecessor()
    {
        return $this->predecessor;
    }
    /**
     * This method is responsible for validating the values passed to the setPredecessor method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPredecessor method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePredecessorForArrayConstraintsFromSetPredecessor(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicPredecessorItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicPredecessorItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicPredecessorItem) ? get_class($manufacturingOperationTaskSearchRowBasicPredecessorItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicPredecessorItem), var_export($manufacturingOperationTaskSearchRowBasicPredecessorItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The predecessor 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 predecessor value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $predecessor
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setPredecessor(array $predecessor = array())
    {
        // validation for constraint: array
        if ('' !== ($predecessorArrayErrorMessage = self::validatePredecessorForArrayConstraintsFromSetPredecessor($predecessor))) {
            throw new \InvalidArgumentException($predecessorArrayErrorMessage, __LINE__);
        }
        $this->predecessor = $predecessor;
        return $this;
    }
    /**
     * Add item to predecessor value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToPredecessor(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The predecessor 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->predecessor[] = $item;
        return $this;
    }
    /**
     * Get predecessorType value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getPredecessorType()
    {
        return $this->predecessorType;
    }
    /**
     * This method is responsible for validating the values passed to the setPredecessorType method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPredecessorType method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePredecessorTypeForArrayConstraintsFromSetPredecessorType(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicPredecessorTypeItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicPredecessorTypeItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicPredecessorTypeItem) ? get_class($manufacturingOperationTaskSearchRowBasicPredecessorTypeItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicPredecessorTypeItem), var_export($manufacturingOperationTaskSearchRowBasicPredecessorTypeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The predecessorType 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 predecessorType value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $predecessorType
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setPredecessorType(array $predecessorType = array())
    {
        // validation for constraint: array
        if ('' !== ($predecessorTypeArrayErrorMessage = self::validatePredecessorTypeForArrayConstraintsFromSetPredecessorType($predecessorType))) {
            throw new \InvalidArgumentException($predecessorTypeArrayErrorMessage, __LINE__);
        }
        $this->predecessorType = $predecessorType;
        return $this;
    }
    /**
     * Add item to predecessorType value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToPredecessorType(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The predecessorType 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->predecessorType[] = $item;
        return $this;
    }
    /**
     * Get remainingQuantity value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getRemainingQuantity()
    {
        return $this->remainingQuantity;
    }
    /**
     * This method is responsible for validating the values passed to the setRemainingQuantity method
     * This method is willingly generated in order to preserve the one-line inline validation within the setRemainingQuantity method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateRemainingQuantityForArrayConstraintsFromSetRemainingQuantity(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicRemainingQuantityItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicRemainingQuantityItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicRemainingQuantityItem) ? get_class($manufacturingOperationTaskSearchRowBasicRemainingQuantityItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicRemainingQuantityItem), var_export($manufacturingOperationTaskSearchRowBasicRemainingQuantityItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The remainingQuantity 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 remainingQuantity value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $remainingQuantity
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setRemainingQuantity(array $remainingQuantity = array())
    {
        // validation for constraint: array
        if ('' !== ($remainingQuantityArrayErrorMessage = self::validateRemainingQuantityForArrayConstraintsFromSetRemainingQuantity($remainingQuantity))) {
            throw new \InvalidArgumentException($remainingQuantityArrayErrorMessage, __LINE__);
        }
        $this->remainingQuantity = $remainingQuantity;
        return $this;
    }
    /**
     * Add item to remainingQuantity value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToRemainingQuantity(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The remainingQuantity 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->remainingQuantity[] = $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 $manufacturingOperationTaskSearchRowBasicRunRateItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicRunRateItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicRunRateItem) ? get_class($manufacturingOperationTaskSearchRowBasicRunRateItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicRunRateItem), var_export($manufacturingOperationTaskSearchRowBasicRunRateItem, 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\ManufacturingOperationTaskSearchRowBasic
     */
    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\ManufacturingOperationTaskSearchRowBasic
     */
    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 runTime value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getRunTime()
    {
        return $this->runTime;
    }
    /**
     * This method is responsible for validating the values passed to the setRunTime method
     * This method is willingly generated in order to preserve the one-line inline validation within the setRunTime method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateRunTimeForArrayConstraintsFromSetRunTime(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicRunTimeItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicRunTimeItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicRunTimeItem) ? get_class($manufacturingOperationTaskSearchRowBasicRunTimeItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicRunTimeItem), var_export($manufacturingOperationTaskSearchRowBasicRunTimeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The runTime 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 runTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $runTime
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setRunTime(array $runTime = array())
    {
        // validation for constraint: array
        if ('' !== ($runTimeArrayErrorMessage = self::validateRunTimeForArrayConstraintsFromSetRunTime($runTime))) {
            throw new \InvalidArgumentException($runTimeArrayErrorMessage, __LINE__);
        }
        $this->runTime = $runTime;
        return $this;
    }
    /**
     * Add item to runTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToRunTime(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The runTime 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->runTime[] = $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 $manufacturingOperationTaskSearchRowBasicSequenceItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicSequenceItem instanceof \StructType\SearchColumnLongField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicSequenceItem) ? get_class($manufacturingOperationTaskSearchRowBasicSequenceItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicSequenceItem), var_export($manufacturingOperationTaskSearchRowBasicSequenceItem, 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\ManufacturingOperationTaskSearchRowBasic
     */
    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\ManufacturingOperationTaskSearchRowBasic
     */
    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 $manufacturingOperationTaskSearchRowBasicSetupTimeItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicSetupTimeItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicSetupTimeItem) ? get_class($manufacturingOperationTaskSearchRowBasicSetupTimeItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicSetupTimeItem), var_export($manufacturingOperationTaskSearchRowBasicSetupTimeItem, 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\ManufacturingOperationTaskSearchRowBasic
     */
    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\ManufacturingOperationTaskSearchRowBasic
     */
    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 startDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getStartDate()
    {
        return $this->startDate;
    }
    /**
     * This method is responsible for validating the values passed to the setStartDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setStartDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateStartDateForArrayConstraintsFromSetStartDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicStartDateItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicStartDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicStartDateItem) ? get_class($manufacturingOperationTaskSearchRowBasicStartDateItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicStartDateItem), var_export($manufacturingOperationTaskSearchRowBasicStartDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The startDate 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 startDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $startDate
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setStartDate(array $startDate = array())
    {
        // validation for constraint: array
        if ('' !== ($startDateArrayErrorMessage = self::validateStartDateForArrayConstraintsFromSetStartDate($startDate))) {
            throw new \InvalidArgumentException($startDateArrayErrorMessage, __LINE__);
        }
        $this->startDate = $startDate;
        return $this;
    }
    /**
     * Add item to startDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToStartDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The startDate 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->startDate[] = $item;
        return $this;
    }
    /**
     * Get status value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getStatus()
    {
        return $this->status;
    }
    /**
     * This method is responsible for validating the values passed to the setStatus method
     * This method is willingly generated in order to preserve the one-line inline validation within the setStatus method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateStatusForArrayConstraintsFromSetStatus(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicStatusItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicStatusItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicStatusItem) ? get_class($manufacturingOperationTaskSearchRowBasicStatusItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicStatusItem), var_export($manufacturingOperationTaskSearchRowBasicStatusItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The status 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 status value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $status
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setStatus(array $status = array())
    {
        // validation for constraint: array
        if ('' !== ($statusArrayErrorMessage = self::validateStatusForArrayConstraintsFromSetStatus($status))) {
            throw new \InvalidArgumentException($statusArrayErrorMessage, __LINE__);
        }
        $this->status = $status;
        return $this;
    }
    /**
     * Add item to status value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToStatus(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The status 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->status[] = $item;
        return $this;
    }
    /**
     * Get workOrder value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getWorkOrder()
    {
        return $this->workOrder;
    }
    /**
     * This method is responsible for validating the values passed to the setWorkOrder method
     * This method is willingly generated in order to preserve the one-line inline validation within the setWorkOrder method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateWorkOrderForArrayConstraintsFromSetWorkOrder(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $manufacturingOperationTaskSearchRowBasicWorkOrderItem) {
            // validation for constraint: itemType
            if (!$manufacturingOperationTaskSearchRowBasicWorkOrderItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($manufacturingOperationTaskSearchRowBasicWorkOrderItem) ? get_class($manufacturingOperationTaskSearchRowBasicWorkOrderItem) : sprintf('%s(%s)', gettype($manufacturingOperationTaskSearchRowBasicWorkOrderItem), var_export($manufacturingOperationTaskSearchRowBasicWorkOrderItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The workOrder 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 workOrder value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $workOrder
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function setWorkOrder(array $workOrder = array())
    {
        // validation for constraint: array
        if ('' !== ($workOrderArrayErrorMessage = self::validateWorkOrderForArrayConstraintsFromSetWorkOrder($workOrder))) {
            throw new \InvalidArgumentException($workOrderArrayErrorMessage, __LINE__);
        }
        $this->workOrder = $workOrder;
        return $this;
    }
    /**
     * Add item to workOrder value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\ManufacturingOperationTaskSearchRowBasic
     */
    public function addToWorkOrder(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The workOrder 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->workOrder[] = $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\ManufacturingOperationTaskSearchRowBasic
     */
    public function setCustomFieldList(\StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this->customFieldList = $customFieldList;
        return $this;
    }
}
