<?php

namespace StructType;

use \WsdlToPhp\PackageBase\AbstractStructBase;

/**
 * This class stands for TaskSearchRowBasic StructType
 * @subpackage Structs
 */
class TaskSearchRowBasic extends SearchRowBasic
{
    /**
     * The accessLevel
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $accessLevel;
    /**
     * The actualTime
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $actualTime;
    /**
     * The assigned
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $assigned;
    /**
     * The company
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $company;
    /**
     * The completedDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $completedDate;
    /**
     * The contact
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $contact;
    /**
     * The createdDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $createdDate;
    /**
     * The dueDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $dueDate;
    /**
     * The estimatedTime
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $estimatedTime;
    /**
     * The estimatedTimeOverride
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $estimatedTimeOverride;
    /**
     * The externalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $externalId;
    /**
     * The internalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $internalId;
    /**
     * The isJobSummaryTask
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isJobSummaryTask;
    /**
     * The isJobTask
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isJobTask;
    /**
     * The lastModifiedDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $lastModifiedDate;
    /**
     * The markdone
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $markdone;
    /**
     * The message
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $message;
    /**
     * The milestone
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $milestone;
    /**
     * The order
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnLongField[]
     */
    public $order;
    /**
     * The owner
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $owner;
    /**
     * The percentComplete
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $percentComplete;
    /**
     * The percentTimeComplete
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $percentTimeComplete;
    /**
     * The priority
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnEnumSelectField[]
     */
    public $priority;
    /**
     * The startDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $startDate;
    /**
     * The startTime
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $startTime;
    /**
     * The status
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnEnumSelectField[]
     */
    public $status;
    /**
     * The timeRemaining
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $timeRemaining;
    /**
     * The title
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $title;
    /**
     * The transaction
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $transaction;
    /**
     * The customFieldList
     * Meta information extracted from the WSDL
     * - minOccurs: 0
     * @var \StructType\SearchColumnCustomFieldList
     */
    public $customFieldList;
    /**
     * Constructor method for TaskSearchRowBasic
     * @uses TaskSearchRowBasic::setAccessLevel()
     * @uses TaskSearchRowBasic::setActualTime()
     * @uses TaskSearchRowBasic::setAssigned()
     * @uses TaskSearchRowBasic::setCompany()
     * @uses TaskSearchRowBasic::setCompletedDate()
     * @uses TaskSearchRowBasic::setContact()
     * @uses TaskSearchRowBasic::setCreatedDate()
     * @uses TaskSearchRowBasic::setDueDate()
     * @uses TaskSearchRowBasic::setEstimatedTime()
     * @uses TaskSearchRowBasic::setEstimatedTimeOverride()
     * @uses TaskSearchRowBasic::setExternalId()
     * @uses TaskSearchRowBasic::setInternalId()
     * @uses TaskSearchRowBasic::setIsJobSummaryTask()
     * @uses TaskSearchRowBasic::setIsJobTask()
     * @uses TaskSearchRowBasic::setLastModifiedDate()
     * @uses TaskSearchRowBasic::setMarkdone()
     * @uses TaskSearchRowBasic::setMessage()
     * @uses TaskSearchRowBasic::setMilestone()
     * @uses TaskSearchRowBasic::setOrder()
     * @uses TaskSearchRowBasic::setOwner()
     * @uses TaskSearchRowBasic::setPercentComplete()
     * @uses TaskSearchRowBasic::setPercentTimeComplete()
     * @uses TaskSearchRowBasic::setPriority()
     * @uses TaskSearchRowBasic::setStartDate()
     * @uses TaskSearchRowBasic::setStartTime()
     * @uses TaskSearchRowBasic::setStatus()
     * @uses TaskSearchRowBasic::setTimeRemaining()
     * @uses TaskSearchRowBasic::setTitle()
     * @uses TaskSearchRowBasic::setTransaction()
     * @uses TaskSearchRowBasic::setCustomFieldList()
     * @param \StructType\SearchColumnStringField[] $accessLevel
     * @param \StructType\SearchColumnDoubleField[] $actualTime
     * @param \StructType\SearchColumnSelectField[] $assigned
     * @param \StructType\SearchColumnSelectField[] $company
     * @param \StructType\SearchColumnDateField[] $completedDate
     * @param \StructType\SearchColumnSelectField[] $contact
     * @param \StructType\SearchColumnDateField[] $createdDate
     * @param \StructType\SearchColumnDateField[] $dueDate
     * @param \StructType\SearchColumnDoubleField[] $estimatedTime
     * @param \StructType\SearchColumnDoubleField[] $estimatedTimeOverride
     * @param \StructType\SearchColumnSelectField[] $externalId
     * @param \StructType\SearchColumnSelectField[] $internalId
     * @param \StructType\SearchColumnBooleanField[] $isJobSummaryTask
     * @param \StructType\SearchColumnBooleanField[] $isJobTask
     * @param \StructType\SearchColumnDateField[] $lastModifiedDate
     * @param \StructType\SearchColumnStringField[] $markdone
     * @param \StructType\SearchColumnStringField[] $message
     * @param \StructType\SearchColumnSelectField[] $milestone
     * @param \StructType\SearchColumnLongField[] $order
     * @param \StructType\SearchColumnSelectField[] $owner
     * @param \StructType\SearchColumnDoubleField[] $percentComplete
     * @param \StructType\SearchColumnDoubleField[] $percentTimeComplete
     * @param \StructType\SearchColumnEnumSelectField[] $priority
     * @param \StructType\SearchColumnDateField[] $startDate
     * @param \StructType\SearchColumnStringField[] $startTime
     * @param \StructType\SearchColumnEnumSelectField[] $status
     * @param \StructType\SearchColumnDoubleField[] $timeRemaining
     * @param \StructType\SearchColumnStringField[] $title
     * @param \StructType\SearchColumnSelectField[] $transaction
     * @param \StructType\SearchColumnCustomFieldList $customFieldList
     */
    public function __construct(array $accessLevel = array(), array $actualTime = array(), array $assigned = array(), array $company = array(), array $completedDate = array(), array $contact = array(), array $createdDate = array(), array $dueDate = array(), array $estimatedTime = array(), array $estimatedTimeOverride = array(), array $externalId = array(), array $internalId = array(), array $isJobSummaryTask = array(), array $isJobTask = array(), array $lastModifiedDate = array(), array $markdone = array(), array $message = array(), array $milestone = array(), array $order = array(), array $owner = array(), array $percentComplete = array(), array $percentTimeComplete = array(), array $priority = array(), array $startDate = array(), array $startTime = array(), array $status = array(), array $timeRemaining = array(), array $title = array(), array $transaction = array(), \StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this
            ->setAccessLevel($accessLevel)
            ->setActualTime($actualTime)
            ->setAssigned($assigned)
            ->setCompany($company)
            ->setCompletedDate($completedDate)
            ->setContact($contact)
            ->setCreatedDate($createdDate)
            ->setDueDate($dueDate)
            ->setEstimatedTime($estimatedTime)
            ->setEstimatedTimeOverride($estimatedTimeOverride)
            ->setExternalId($externalId)
            ->setInternalId($internalId)
            ->setIsJobSummaryTask($isJobSummaryTask)
            ->setIsJobTask($isJobTask)
            ->setLastModifiedDate($lastModifiedDate)
            ->setMarkdone($markdone)
            ->setMessage($message)
            ->setMilestone($milestone)
            ->setOrder($order)
            ->setOwner($owner)
            ->setPercentComplete($percentComplete)
            ->setPercentTimeComplete($percentTimeComplete)
            ->setPriority($priority)
            ->setStartDate($startDate)
            ->setStartTime($startTime)
            ->setStatus($status)
            ->setTimeRemaining($timeRemaining)
            ->setTitle($title)
            ->setTransaction($transaction)
            ->setCustomFieldList($customFieldList);
    }
    /**
     * Get accessLevel value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getAccessLevel()
    {
        return $this->accessLevel;
    }
    /**
     * This method is responsible for validating the values passed to the setAccessLevel method
     * This method is willingly generated in order to preserve the one-line inline validation within the setAccessLevel method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateAccessLevelForArrayConstraintsFromSetAccessLevel(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicAccessLevelItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicAccessLevelItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($taskSearchRowBasicAccessLevelItem) ? get_class($taskSearchRowBasicAccessLevelItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicAccessLevelItem), var_export($taskSearchRowBasicAccessLevelItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The accessLevel 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 accessLevel value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $accessLevel
     * @return \StructType\TaskSearchRowBasic
     */
    public function setAccessLevel(array $accessLevel = array())
    {
        // validation for constraint: array
        if ('' !== ($accessLevelArrayErrorMessage = self::validateAccessLevelForArrayConstraintsFromSetAccessLevel($accessLevel))) {
            throw new \InvalidArgumentException($accessLevelArrayErrorMessage, __LINE__);
        }
        $this->accessLevel = $accessLevel;
        return $this;
    }
    /**
     * Add item to accessLevel value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToAccessLevel(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The accessLevel 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->accessLevel[] = $item;
        return $this;
    }
    /**
     * Get actualTime value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getActualTime()
    {
        return $this->actualTime;
    }
    /**
     * This method is responsible for validating the values passed to the setActualTime method
     * This method is willingly generated in order to preserve the one-line inline validation within the setActualTime method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateActualTimeForArrayConstraintsFromSetActualTime(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicActualTimeItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicActualTimeItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($taskSearchRowBasicActualTimeItem) ? get_class($taskSearchRowBasicActualTimeItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicActualTimeItem), var_export($taskSearchRowBasicActualTimeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The actualTime 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 actualTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $actualTime
     * @return \StructType\TaskSearchRowBasic
     */
    public function setActualTime(array $actualTime = array())
    {
        // validation for constraint: array
        if ('' !== ($actualTimeArrayErrorMessage = self::validateActualTimeForArrayConstraintsFromSetActualTime($actualTime))) {
            throw new \InvalidArgumentException($actualTimeArrayErrorMessage, __LINE__);
        }
        $this->actualTime = $actualTime;
        return $this;
    }
    /**
     * Add item to actualTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToActualTime(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The actualTime 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->actualTime[] = $item;
        return $this;
    }
    /**
     * Get assigned value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getAssigned()
    {
        return $this->assigned;
    }
    /**
     * This method is responsible for validating the values passed to the setAssigned method
     * This method is willingly generated in order to preserve the one-line inline validation within the setAssigned method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateAssignedForArrayConstraintsFromSetAssigned(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicAssignedItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicAssignedItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($taskSearchRowBasicAssignedItem) ? get_class($taskSearchRowBasicAssignedItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicAssignedItem), var_export($taskSearchRowBasicAssignedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The assigned 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 assigned value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $assigned
     * @return \StructType\TaskSearchRowBasic
     */
    public function setAssigned(array $assigned = array())
    {
        // validation for constraint: array
        if ('' !== ($assignedArrayErrorMessage = self::validateAssignedForArrayConstraintsFromSetAssigned($assigned))) {
            throw new \InvalidArgumentException($assignedArrayErrorMessage, __LINE__);
        }
        $this->assigned = $assigned;
        return $this;
    }
    /**
     * Add item to assigned value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToAssigned(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The assigned 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->assigned[] = $item;
        return $this;
    }
    /**
     * Get company value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getCompany()
    {
        return $this->company;
    }
    /**
     * This method is responsible for validating the values passed to the setCompany method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCompany method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCompanyForArrayConstraintsFromSetCompany(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicCompanyItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicCompanyItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($taskSearchRowBasicCompanyItem) ? get_class($taskSearchRowBasicCompanyItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicCompanyItem), var_export($taskSearchRowBasicCompanyItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The company 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 company value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $company
     * @return \StructType\TaskSearchRowBasic
     */
    public function setCompany(array $company = array())
    {
        // validation for constraint: array
        if ('' !== ($companyArrayErrorMessage = self::validateCompanyForArrayConstraintsFromSetCompany($company))) {
            throw new \InvalidArgumentException($companyArrayErrorMessage, __LINE__);
        }
        $this->company = $company;
        return $this;
    }
    /**
     * Add item to company value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToCompany(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The company 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->company[] = $item;
        return $this;
    }
    /**
     * Get completedDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getCompletedDate()
    {
        return $this->completedDate;
    }
    /**
     * This method is responsible for validating the values passed to the setCompletedDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCompletedDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCompletedDateForArrayConstraintsFromSetCompletedDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicCompletedDateItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicCompletedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($taskSearchRowBasicCompletedDateItem) ? get_class($taskSearchRowBasicCompletedDateItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicCompletedDateItem), var_export($taskSearchRowBasicCompletedDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The completedDate 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 completedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $completedDate
     * @return \StructType\TaskSearchRowBasic
     */
    public function setCompletedDate(array $completedDate = array())
    {
        // validation for constraint: array
        if ('' !== ($completedDateArrayErrorMessage = self::validateCompletedDateForArrayConstraintsFromSetCompletedDate($completedDate))) {
            throw new \InvalidArgumentException($completedDateArrayErrorMessage, __LINE__);
        }
        $this->completedDate = $completedDate;
        return $this;
    }
    /**
     * Add item to completedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToCompletedDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The completedDate 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->completedDate[] = $item;
        return $this;
    }
    /**
     * Get contact value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getContact()
    {
        return $this->contact;
    }
    /**
     * This method is responsible for validating the values passed to the setContact method
     * This method is willingly generated in order to preserve the one-line inline validation within the setContact method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateContactForArrayConstraintsFromSetContact(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicContactItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicContactItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($taskSearchRowBasicContactItem) ? get_class($taskSearchRowBasicContactItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicContactItem), var_export($taskSearchRowBasicContactItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The contact 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 contact value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $contact
     * @return \StructType\TaskSearchRowBasic
     */
    public function setContact(array $contact = array())
    {
        // validation for constraint: array
        if ('' !== ($contactArrayErrorMessage = self::validateContactForArrayConstraintsFromSetContact($contact))) {
            throw new \InvalidArgumentException($contactArrayErrorMessage, __LINE__);
        }
        $this->contact = $contact;
        return $this;
    }
    /**
     * Add item to contact value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToContact(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The contact 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->contact[] = $item;
        return $this;
    }
    /**
     * Get createdDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getCreatedDate()
    {
        return $this->createdDate;
    }
    /**
     * This method is responsible for validating the values passed to the setCreatedDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCreatedDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCreatedDateForArrayConstraintsFromSetCreatedDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicCreatedDateItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicCreatedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($taskSearchRowBasicCreatedDateItem) ? get_class($taskSearchRowBasicCreatedDateItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicCreatedDateItem), var_export($taskSearchRowBasicCreatedDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The createdDate 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 createdDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $createdDate
     * @return \StructType\TaskSearchRowBasic
     */
    public function setCreatedDate(array $createdDate = array())
    {
        // validation for constraint: array
        if ('' !== ($createdDateArrayErrorMessage = self::validateCreatedDateForArrayConstraintsFromSetCreatedDate($createdDate))) {
            throw new \InvalidArgumentException($createdDateArrayErrorMessage, __LINE__);
        }
        $this->createdDate = $createdDate;
        return $this;
    }
    /**
     * Add item to createdDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToCreatedDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The createdDate 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->createdDate[] = $item;
        return $this;
    }
    /**
     * Get dueDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getDueDate()
    {
        return $this->dueDate;
    }
    /**
     * This method is responsible for validating the values passed to the setDueDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setDueDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateDueDateForArrayConstraintsFromSetDueDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicDueDateItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicDueDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($taskSearchRowBasicDueDateItem) ? get_class($taskSearchRowBasicDueDateItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicDueDateItem), var_export($taskSearchRowBasicDueDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The dueDate 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 dueDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $dueDate
     * @return \StructType\TaskSearchRowBasic
     */
    public function setDueDate(array $dueDate = array())
    {
        // validation for constraint: array
        if ('' !== ($dueDateArrayErrorMessage = self::validateDueDateForArrayConstraintsFromSetDueDate($dueDate))) {
            throw new \InvalidArgumentException($dueDateArrayErrorMessage, __LINE__);
        }
        $this->dueDate = $dueDate;
        return $this;
    }
    /**
     * Add item to dueDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToDueDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The dueDate 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->dueDate[] = $item;
        return $this;
    }
    /**
     * Get estimatedTime value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getEstimatedTime()
    {
        return $this->estimatedTime;
    }
    /**
     * This method is responsible for validating the values passed to the setEstimatedTime method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEstimatedTime method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEstimatedTimeForArrayConstraintsFromSetEstimatedTime(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicEstimatedTimeItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicEstimatedTimeItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($taskSearchRowBasicEstimatedTimeItem) ? get_class($taskSearchRowBasicEstimatedTimeItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicEstimatedTimeItem), var_export($taskSearchRowBasicEstimatedTimeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The estimatedTime 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 estimatedTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $estimatedTime
     * @return \StructType\TaskSearchRowBasic
     */
    public function setEstimatedTime(array $estimatedTime = array())
    {
        // validation for constraint: array
        if ('' !== ($estimatedTimeArrayErrorMessage = self::validateEstimatedTimeForArrayConstraintsFromSetEstimatedTime($estimatedTime))) {
            throw new \InvalidArgumentException($estimatedTimeArrayErrorMessage, __LINE__);
        }
        $this->estimatedTime = $estimatedTime;
        return $this;
    }
    /**
     * Add item to estimatedTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToEstimatedTime(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The estimatedTime 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->estimatedTime[] = $item;
        return $this;
    }
    /**
     * Get estimatedTimeOverride value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getEstimatedTimeOverride()
    {
        return $this->estimatedTimeOverride;
    }
    /**
     * This method is responsible for validating the values passed to the setEstimatedTimeOverride method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEstimatedTimeOverride method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEstimatedTimeOverrideForArrayConstraintsFromSetEstimatedTimeOverride(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicEstimatedTimeOverrideItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicEstimatedTimeOverrideItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($taskSearchRowBasicEstimatedTimeOverrideItem) ? get_class($taskSearchRowBasicEstimatedTimeOverrideItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicEstimatedTimeOverrideItem), var_export($taskSearchRowBasicEstimatedTimeOverrideItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The estimatedTimeOverride 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 estimatedTimeOverride value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $estimatedTimeOverride
     * @return \StructType\TaskSearchRowBasic
     */
    public function setEstimatedTimeOverride(array $estimatedTimeOverride = array())
    {
        // validation for constraint: array
        if ('' !== ($estimatedTimeOverrideArrayErrorMessage = self::validateEstimatedTimeOverrideForArrayConstraintsFromSetEstimatedTimeOverride($estimatedTimeOverride))) {
            throw new \InvalidArgumentException($estimatedTimeOverrideArrayErrorMessage, __LINE__);
        }
        $this->estimatedTimeOverride = $estimatedTimeOverride;
        return $this;
    }
    /**
     * Add item to estimatedTimeOverride value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToEstimatedTimeOverride(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The estimatedTimeOverride 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->estimatedTimeOverride[] = $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 $taskSearchRowBasicExternalIdItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicExternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($taskSearchRowBasicExternalIdItem) ? get_class($taskSearchRowBasicExternalIdItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicExternalIdItem), var_export($taskSearchRowBasicExternalIdItem, 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\TaskSearchRowBasic
     */
    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\TaskSearchRowBasic
     */
    public function addToExternalId(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The externalId property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->externalId[] = $item;
        return $this;
    }
    /**
     * Get internalId value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getInternalId()
    {
        return $this->internalId;
    }
    /**
     * This method is responsible for validating the values passed to the setInternalId method
     * This method is willingly generated in order to preserve the one-line inline validation within the setInternalId method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateInternalIdForArrayConstraintsFromSetInternalId(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicInternalIdItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicInternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($taskSearchRowBasicInternalIdItem) ? get_class($taskSearchRowBasicInternalIdItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicInternalIdItem), var_export($taskSearchRowBasicInternalIdItem, 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\TaskSearchRowBasic
     */
    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\TaskSearchRowBasic
     */
    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 isJobSummaryTask value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsJobSummaryTask()
    {
        return $this->isJobSummaryTask;
    }
    /**
     * This method is responsible for validating the values passed to the setIsJobSummaryTask method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsJobSummaryTask method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsJobSummaryTaskForArrayConstraintsFromSetIsJobSummaryTask(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicIsJobSummaryTaskItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicIsJobSummaryTaskItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($taskSearchRowBasicIsJobSummaryTaskItem) ? get_class($taskSearchRowBasicIsJobSummaryTaskItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicIsJobSummaryTaskItem), var_export($taskSearchRowBasicIsJobSummaryTaskItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isJobSummaryTask property can only contain items of type \StructType\SearchColumnBooleanField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set isJobSummaryTask value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isJobSummaryTask
     * @return \StructType\TaskSearchRowBasic
     */
    public function setIsJobSummaryTask(array $isJobSummaryTask = array())
    {
        // validation for constraint: array
        if ('' !== ($isJobSummaryTaskArrayErrorMessage = self::validateIsJobSummaryTaskForArrayConstraintsFromSetIsJobSummaryTask($isJobSummaryTask))) {
            throw new \InvalidArgumentException($isJobSummaryTaskArrayErrorMessage, __LINE__);
        }
        $this->isJobSummaryTask = $isJobSummaryTask;
        return $this;
    }
    /**
     * Add item to isJobSummaryTask value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToIsJobSummaryTask(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isJobSummaryTask property can only contain items of type \StructType\SearchColumnBooleanField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->isJobSummaryTask[] = $item;
        return $this;
    }
    /**
     * Get isJobTask value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsJobTask()
    {
        return $this->isJobTask;
    }
    /**
     * This method is responsible for validating the values passed to the setIsJobTask method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsJobTask method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsJobTaskForArrayConstraintsFromSetIsJobTask(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicIsJobTaskItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicIsJobTaskItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($taskSearchRowBasicIsJobTaskItem) ? get_class($taskSearchRowBasicIsJobTaskItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicIsJobTaskItem), var_export($taskSearchRowBasicIsJobTaskItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isJobTask property can only contain items of type \StructType\SearchColumnBooleanField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set isJobTask value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isJobTask
     * @return \StructType\TaskSearchRowBasic
     */
    public function setIsJobTask(array $isJobTask = array())
    {
        // validation for constraint: array
        if ('' !== ($isJobTaskArrayErrorMessage = self::validateIsJobTaskForArrayConstraintsFromSetIsJobTask($isJobTask))) {
            throw new \InvalidArgumentException($isJobTaskArrayErrorMessage, __LINE__);
        }
        $this->isJobTask = $isJobTask;
        return $this;
    }
    /**
     * Add item to isJobTask value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToIsJobTask(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isJobTask property can only contain items of type \StructType\SearchColumnBooleanField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->isJobTask[] = $item;
        return $this;
    }
    /**
     * Get lastModifiedDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getLastModifiedDate()
    {
        return $this->lastModifiedDate;
    }
    /**
     * This method is responsible for validating the values passed to the setLastModifiedDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLastModifiedDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLastModifiedDateForArrayConstraintsFromSetLastModifiedDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicLastModifiedDateItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicLastModifiedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($taskSearchRowBasicLastModifiedDateItem) ? get_class($taskSearchRowBasicLastModifiedDateItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicLastModifiedDateItem), var_export($taskSearchRowBasicLastModifiedDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The lastModifiedDate 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 lastModifiedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $lastModifiedDate
     * @return \StructType\TaskSearchRowBasic
     */
    public function setLastModifiedDate(array $lastModifiedDate = array())
    {
        // validation for constraint: array
        if ('' !== ($lastModifiedDateArrayErrorMessage = self::validateLastModifiedDateForArrayConstraintsFromSetLastModifiedDate($lastModifiedDate))) {
            throw new \InvalidArgumentException($lastModifiedDateArrayErrorMessage, __LINE__);
        }
        $this->lastModifiedDate = $lastModifiedDate;
        return $this;
    }
    /**
     * Add item to lastModifiedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToLastModifiedDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The lastModifiedDate 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->lastModifiedDate[] = $item;
        return $this;
    }
    /**
     * Get markdone value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getMarkdone()
    {
        return $this->markdone;
    }
    /**
     * This method is responsible for validating the values passed to the setMarkdone method
     * This method is willingly generated in order to preserve the one-line inline validation within the setMarkdone method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateMarkdoneForArrayConstraintsFromSetMarkdone(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicMarkdoneItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicMarkdoneItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($taskSearchRowBasicMarkdoneItem) ? get_class($taskSearchRowBasicMarkdoneItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicMarkdoneItem), var_export($taskSearchRowBasicMarkdoneItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The markdone 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 markdone value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $markdone
     * @return \StructType\TaskSearchRowBasic
     */
    public function setMarkdone(array $markdone = array())
    {
        // validation for constraint: array
        if ('' !== ($markdoneArrayErrorMessage = self::validateMarkdoneForArrayConstraintsFromSetMarkdone($markdone))) {
            throw new \InvalidArgumentException($markdoneArrayErrorMessage, __LINE__);
        }
        $this->markdone = $markdone;
        return $this;
    }
    /**
     * Add item to markdone value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToMarkdone(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The markdone 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->markdone[] = $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 $taskSearchRowBasicMessageItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicMessageItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($taskSearchRowBasicMessageItem) ? get_class($taskSearchRowBasicMessageItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicMessageItem), var_export($taskSearchRowBasicMessageItem, 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\TaskSearchRowBasic
     */
    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\TaskSearchRowBasic
     */
    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 milestone value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getMilestone()
    {
        return $this->milestone;
    }
    /**
     * This method is responsible for validating the values passed to the setMilestone method
     * This method is willingly generated in order to preserve the one-line inline validation within the setMilestone method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateMilestoneForArrayConstraintsFromSetMilestone(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicMilestoneItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicMilestoneItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($taskSearchRowBasicMilestoneItem) ? get_class($taskSearchRowBasicMilestoneItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicMilestoneItem), var_export($taskSearchRowBasicMilestoneItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The milestone 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 milestone value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $milestone
     * @return \StructType\TaskSearchRowBasic
     */
    public function setMilestone(array $milestone = array())
    {
        // validation for constraint: array
        if ('' !== ($milestoneArrayErrorMessage = self::validateMilestoneForArrayConstraintsFromSetMilestone($milestone))) {
            throw new \InvalidArgumentException($milestoneArrayErrorMessage, __LINE__);
        }
        $this->milestone = $milestone;
        return $this;
    }
    /**
     * Add item to milestone value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToMilestone(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The milestone 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->milestone[] = $item;
        return $this;
    }
    /**
     * Get order value
     * @return \StructType\SearchColumnLongField[]|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 $taskSearchRowBasicOrderItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicOrderItem instanceof \StructType\SearchColumnLongField) {
                $invalidValues[] = is_object($taskSearchRowBasicOrderItem) ? get_class($taskSearchRowBasicOrderItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicOrderItem), var_export($taskSearchRowBasicOrderItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The order 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 order value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnLongField[] $order
     * @return \StructType\TaskSearchRowBasic
     */
    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\SearchColumnLongField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToOrder(\StructType\SearchColumnLongField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnLongField) {
            throw new \InvalidArgumentException(sprintf('The order 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->order[] = $item;
        return $this;
    }
    /**
     * Get owner value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getOwner()
    {
        return $this->owner;
    }
    /**
     * This method is responsible for validating the values passed to the setOwner method
     * This method is willingly generated in order to preserve the one-line inline validation within the setOwner method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateOwnerForArrayConstraintsFromSetOwner(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicOwnerItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicOwnerItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($taskSearchRowBasicOwnerItem) ? get_class($taskSearchRowBasicOwnerItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicOwnerItem), var_export($taskSearchRowBasicOwnerItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The owner 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 owner value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $owner
     * @return \StructType\TaskSearchRowBasic
     */
    public function setOwner(array $owner = array())
    {
        // validation for constraint: array
        if ('' !== ($ownerArrayErrorMessage = self::validateOwnerForArrayConstraintsFromSetOwner($owner))) {
            throw new \InvalidArgumentException($ownerArrayErrorMessage, __LINE__);
        }
        $this->owner = $owner;
        return $this;
    }
    /**
     * Add item to owner value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToOwner(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The owner 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->owner[] = $item;
        return $this;
    }
    /**
     * Get percentComplete value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getPercentComplete()
    {
        return $this->percentComplete;
    }
    /**
     * This method is responsible for validating the values passed to the setPercentComplete method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPercentComplete method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePercentCompleteForArrayConstraintsFromSetPercentComplete(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicPercentCompleteItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicPercentCompleteItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($taskSearchRowBasicPercentCompleteItem) ? get_class($taskSearchRowBasicPercentCompleteItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicPercentCompleteItem), var_export($taskSearchRowBasicPercentCompleteItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The percentComplete 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 percentComplete value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $percentComplete
     * @return \StructType\TaskSearchRowBasic
     */
    public function setPercentComplete(array $percentComplete = array())
    {
        // validation for constraint: array
        if ('' !== ($percentCompleteArrayErrorMessage = self::validatePercentCompleteForArrayConstraintsFromSetPercentComplete($percentComplete))) {
            throw new \InvalidArgumentException($percentCompleteArrayErrorMessage, __LINE__);
        }
        $this->percentComplete = $percentComplete;
        return $this;
    }
    /**
     * Add item to percentComplete value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToPercentComplete(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The percentComplete 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->percentComplete[] = $item;
        return $this;
    }
    /**
     * Get percentTimeComplete value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getPercentTimeComplete()
    {
        return $this->percentTimeComplete;
    }
    /**
     * This method is responsible for validating the values passed to the setPercentTimeComplete method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPercentTimeComplete method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePercentTimeCompleteForArrayConstraintsFromSetPercentTimeComplete(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicPercentTimeCompleteItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicPercentTimeCompleteItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($taskSearchRowBasicPercentTimeCompleteItem) ? get_class($taskSearchRowBasicPercentTimeCompleteItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicPercentTimeCompleteItem), var_export($taskSearchRowBasicPercentTimeCompleteItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The percentTimeComplete 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 percentTimeComplete value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $percentTimeComplete
     * @return \StructType\TaskSearchRowBasic
     */
    public function setPercentTimeComplete(array $percentTimeComplete = array())
    {
        // validation for constraint: array
        if ('' !== ($percentTimeCompleteArrayErrorMessage = self::validatePercentTimeCompleteForArrayConstraintsFromSetPercentTimeComplete($percentTimeComplete))) {
            throw new \InvalidArgumentException($percentTimeCompleteArrayErrorMessage, __LINE__);
        }
        $this->percentTimeComplete = $percentTimeComplete;
        return $this;
    }
    /**
     * Add item to percentTimeComplete value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToPercentTimeComplete(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The percentTimeComplete 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->percentTimeComplete[] = $item;
        return $this;
    }
    /**
     * Get priority value
     * @return \StructType\SearchColumnEnumSelectField[]|null
     */
    public function getPriority()
    {
        return $this->priority;
    }
    /**
     * This method is responsible for validating the values passed to the setPriority method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPriority method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePriorityForArrayConstraintsFromSetPriority(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicPriorityItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicPriorityItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($taskSearchRowBasicPriorityItem) ? get_class($taskSearchRowBasicPriorityItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicPriorityItem), var_export($taskSearchRowBasicPriorityItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The priority 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 priority value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField[] $priority
     * @return \StructType\TaskSearchRowBasic
     */
    public function setPriority(array $priority = array())
    {
        // validation for constraint: array
        if ('' !== ($priorityArrayErrorMessage = self::validatePriorityForArrayConstraintsFromSetPriority($priority))) {
            throw new \InvalidArgumentException($priorityArrayErrorMessage, __LINE__);
        }
        $this->priority = $priority;
        return $this;
    }
    /**
     * Add item to priority value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToPriority(\StructType\SearchColumnEnumSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnEnumSelectField) {
            throw new \InvalidArgumentException(sprintf('The priority 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->priority[] = $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 $taskSearchRowBasicStartDateItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicStartDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($taskSearchRowBasicStartDateItem) ? get_class($taskSearchRowBasicStartDateItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicStartDateItem), var_export($taskSearchRowBasicStartDateItem, 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\TaskSearchRowBasic
     */
    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\TaskSearchRowBasic
     */
    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 startTime value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getStartTime()
    {
        return $this->startTime;
    }
    /**
     * This method is responsible for validating the values passed to the setStartTime method
     * This method is willingly generated in order to preserve the one-line inline validation within the setStartTime method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateStartTimeForArrayConstraintsFromSetStartTime(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicStartTimeItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicStartTimeItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($taskSearchRowBasicStartTimeItem) ? get_class($taskSearchRowBasicStartTimeItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicStartTimeItem), var_export($taskSearchRowBasicStartTimeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The startTime 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 startTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $startTime
     * @return \StructType\TaskSearchRowBasic
     */
    public function setStartTime(array $startTime = array())
    {
        // validation for constraint: array
        if ('' !== ($startTimeArrayErrorMessage = self::validateStartTimeForArrayConstraintsFromSetStartTime($startTime))) {
            throw new \InvalidArgumentException($startTimeArrayErrorMessage, __LINE__);
        }
        $this->startTime = $startTime;
        return $this;
    }
    /**
     * Add item to startTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToStartTime(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The startTime 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->startTime[] = $item;
        return $this;
    }
    /**
     * Get status value
     * @return \StructType\SearchColumnEnumSelectField[]|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 $taskSearchRowBasicStatusItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicStatusItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($taskSearchRowBasicStatusItem) ? get_class($taskSearchRowBasicStatusItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicStatusItem), var_export($taskSearchRowBasicStatusItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The status 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 status value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField[] $status
     * @return \StructType\TaskSearchRowBasic
     */
    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\SearchColumnEnumSelectField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToStatus(\StructType\SearchColumnEnumSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnEnumSelectField) {
            throw new \InvalidArgumentException(sprintf('The status 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->status[] = $item;
        return $this;
    }
    /**
     * Get timeRemaining value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getTimeRemaining()
    {
        return $this->timeRemaining;
    }
    /**
     * This method is responsible for validating the values passed to the setTimeRemaining method
     * This method is willingly generated in order to preserve the one-line inline validation within the setTimeRemaining method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateTimeRemainingForArrayConstraintsFromSetTimeRemaining(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicTimeRemainingItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicTimeRemainingItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($taskSearchRowBasicTimeRemainingItem) ? get_class($taskSearchRowBasicTimeRemainingItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicTimeRemainingItem), var_export($taskSearchRowBasicTimeRemainingItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The timeRemaining 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 timeRemaining value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $timeRemaining
     * @return \StructType\TaskSearchRowBasic
     */
    public function setTimeRemaining(array $timeRemaining = array())
    {
        // validation for constraint: array
        if ('' !== ($timeRemainingArrayErrorMessage = self::validateTimeRemainingForArrayConstraintsFromSetTimeRemaining($timeRemaining))) {
            throw new \InvalidArgumentException($timeRemainingArrayErrorMessage, __LINE__);
        }
        $this->timeRemaining = $timeRemaining;
        return $this;
    }
    /**
     * Add item to timeRemaining value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToTimeRemaining(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The timeRemaining 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->timeRemaining[] = $item;
        return $this;
    }
    /**
     * Get title value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getTitle()
    {
        return $this->title;
    }
    /**
     * This method is responsible for validating the values passed to the setTitle method
     * This method is willingly generated in order to preserve the one-line inline validation within the setTitle method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateTitleForArrayConstraintsFromSetTitle(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicTitleItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicTitleItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($taskSearchRowBasicTitleItem) ? get_class($taskSearchRowBasicTitleItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicTitleItem), var_export($taskSearchRowBasicTitleItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The title 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 title value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $title
     * @return \StructType\TaskSearchRowBasic
     */
    public function setTitle(array $title = array())
    {
        // validation for constraint: array
        if ('' !== ($titleArrayErrorMessage = self::validateTitleForArrayConstraintsFromSetTitle($title))) {
            throw new \InvalidArgumentException($titleArrayErrorMessage, __LINE__);
        }
        $this->title = $title;
        return $this;
    }
    /**
     * Add item to title value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToTitle(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The title 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->title[] = $item;
        return $this;
    }
    /**
     * Get transaction value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getTransaction()
    {
        return $this->transaction;
    }
    /**
     * This method is responsible for validating the values passed to the setTransaction method
     * This method is willingly generated in order to preserve the one-line inline validation within the setTransaction method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateTransactionForArrayConstraintsFromSetTransaction(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $taskSearchRowBasicTransactionItem) {
            // validation for constraint: itemType
            if (!$taskSearchRowBasicTransactionItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($taskSearchRowBasicTransactionItem) ? get_class($taskSearchRowBasicTransactionItem) : sprintf('%s(%s)', gettype($taskSearchRowBasicTransactionItem), var_export($taskSearchRowBasicTransactionItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The transaction 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 transaction value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $transaction
     * @return \StructType\TaskSearchRowBasic
     */
    public function setTransaction(array $transaction = array())
    {
        // validation for constraint: array
        if ('' !== ($transactionArrayErrorMessage = self::validateTransactionForArrayConstraintsFromSetTransaction($transaction))) {
            throw new \InvalidArgumentException($transactionArrayErrorMessage, __LINE__);
        }
        $this->transaction = $transaction;
        return $this;
    }
    /**
     * Add item to transaction value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TaskSearchRowBasic
     */
    public function addToTransaction(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The transaction 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->transaction[] = $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\TaskSearchRowBasic
     */
    public function setCustomFieldList(\StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this->customFieldList = $customFieldList;
        return $this;
    }
}
