<?php

namespace StructType;

use \WsdlToPhp\PackageBase\AbstractStructBase;

/**
 * This class stands for TimeEntrySearchRowBasic StructType
 * @subpackage Structs
 */
class TimeEntrySearchRowBasic extends SearchRowBasic
{
    /**
     * The approvalStatus
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $approvalStatus;
    /**
     * The billingClass
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $billingClass;
    /**
     * The billingStatus
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $billingStatus;
    /**
     * The break
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $break;
    /**
     * The caseTaskEvent
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $caseTaskEvent;
    /**
     * The class
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $class;
    /**
     * The classNoHierarchy
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $classNoHierarchy;
    /**
     * The customer
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $customer;
    /**
     * The date
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $date;
    /**
     * The dateCreated
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $dateCreated;
    /**
     * The department
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $department;
    /**
     * The departmentNoHierarchy
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $departmentNoHierarchy;
    /**
     * The durationDecimal
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $durationDecimal;
    /**
     * The employee
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $employee;
    /**
     * The endTime
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $endTime;
    /**
     * The externalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $externalId;
    /**
     * The hours
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $hours;
    /**
     * The internalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $internalId;
    /**
     * The isBillable
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isBillable;
    /**
     * The isExempt
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isExempt;
    /**
     * The isProductive
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isProductive;
    /**
     * The isUtilized
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isUtilized;
    /**
     * The item
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $item;
    /**
     * The lastModified
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $lastModified;
    /**
     * The location
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $location;
    /**
     * The locationNoHierarchy
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $locationNoHierarchy;
    /**
     * The memo
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $memo;
    /**
     * The nextApprover
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $nextApprover;
    /**
     * The paidExternally
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $paidExternally;
    /**
     * The payItem
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $payItem;
    /**
     * The payrollDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $payrollDate;
    /**
     * The rate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDoubleField[]
     */
    public $rate;
    /**
     * The startTime
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $startTime;
    /**
     * The subsidiary
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $subsidiary;
    /**
     * The subsidiaryNoHierarchy
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $subsidiaryNoHierarchy;
    /**
     * The timeSheet
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $timeSheet;
    /**
     * The type
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnEnumSelectField[]
     */
    public $type;
    /**
     * The customFieldList
     * Meta information extracted from the WSDL
     * - minOccurs: 0
     * @var \StructType\SearchColumnCustomFieldList
     */
    public $customFieldList;
    /**
     * Constructor method for TimeEntrySearchRowBasic
     * @uses TimeEntrySearchRowBasic::setApprovalStatus()
     * @uses TimeEntrySearchRowBasic::setBillingClass()
     * @uses TimeEntrySearchRowBasic::setBillingStatus()
     * @uses TimeEntrySearchRowBasic::setBreak()
     * @uses TimeEntrySearchRowBasic::setCaseTaskEvent()
     * @uses TimeEntrySearchRowBasic::setClass()
     * @uses TimeEntrySearchRowBasic::setClassNoHierarchy()
     * @uses TimeEntrySearchRowBasic::setCustomer()
     * @uses TimeEntrySearchRowBasic::setDate()
     * @uses TimeEntrySearchRowBasic::setDateCreated()
     * @uses TimeEntrySearchRowBasic::setDepartment()
     * @uses TimeEntrySearchRowBasic::setDepartmentNoHierarchy()
     * @uses TimeEntrySearchRowBasic::setDurationDecimal()
     * @uses TimeEntrySearchRowBasic::setEmployee()
     * @uses TimeEntrySearchRowBasic::setEndTime()
     * @uses TimeEntrySearchRowBasic::setExternalId()
     * @uses TimeEntrySearchRowBasic::setHours()
     * @uses TimeEntrySearchRowBasic::setInternalId()
     * @uses TimeEntrySearchRowBasic::setIsBillable()
     * @uses TimeEntrySearchRowBasic::setIsExempt()
     * @uses TimeEntrySearchRowBasic::setIsProductive()
     * @uses TimeEntrySearchRowBasic::setIsUtilized()
     * @uses TimeEntrySearchRowBasic::setItem()
     * @uses TimeEntrySearchRowBasic::setLastModified()
     * @uses TimeEntrySearchRowBasic::setLocation()
     * @uses TimeEntrySearchRowBasic::setLocationNoHierarchy()
     * @uses TimeEntrySearchRowBasic::setMemo()
     * @uses TimeEntrySearchRowBasic::setNextApprover()
     * @uses TimeEntrySearchRowBasic::setPaidExternally()
     * @uses TimeEntrySearchRowBasic::setPayItem()
     * @uses TimeEntrySearchRowBasic::setPayrollDate()
     * @uses TimeEntrySearchRowBasic::setRate()
     * @uses TimeEntrySearchRowBasic::setStartTime()
     * @uses TimeEntrySearchRowBasic::setSubsidiary()
     * @uses TimeEntrySearchRowBasic::setSubsidiaryNoHierarchy()
     * @uses TimeEntrySearchRowBasic::setTimeSheet()
     * @uses TimeEntrySearchRowBasic::setType()
     * @uses TimeEntrySearchRowBasic::setCustomFieldList()
     * @param \StructType\SearchColumnSelectField[] $approvalStatus
     * @param \StructType\SearchColumnSelectField[] $billingClass
     * @param \StructType\SearchColumnStringField[] $billingStatus
     * @param \StructType\SearchColumnStringField[] $break
     * @param \StructType\SearchColumnSelectField[] $caseTaskEvent
     * @param \StructType\SearchColumnSelectField[] $class
     * @param \StructType\SearchColumnSelectField[] $classNoHierarchy
     * @param \StructType\SearchColumnSelectField[] $customer
     * @param \StructType\SearchColumnDateField[] $date
     * @param \StructType\SearchColumnDateField[] $dateCreated
     * @param \StructType\SearchColumnSelectField[] $department
     * @param \StructType\SearchColumnSelectField[] $departmentNoHierarchy
     * @param \StructType\SearchColumnDoubleField[] $durationDecimal
     * @param \StructType\SearchColumnSelectField[] $employee
     * @param \StructType\SearchColumnDateField[] $endTime
     * @param \StructType\SearchColumnSelectField[] $externalId
     * @param \StructType\SearchColumnStringField[] $hours
     * @param \StructType\SearchColumnSelectField[] $internalId
     * @param \StructType\SearchColumnBooleanField[] $isBillable
     * @param \StructType\SearchColumnBooleanField[] $isExempt
     * @param \StructType\SearchColumnBooleanField[] $isProductive
     * @param \StructType\SearchColumnBooleanField[] $isUtilized
     * @param \StructType\SearchColumnStringField[] $item
     * @param \StructType\SearchColumnDateField[] $lastModified
     * @param \StructType\SearchColumnSelectField[] $location
     * @param \StructType\SearchColumnSelectField[] $locationNoHierarchy
     * @param \StructType\SearchColumnStringField[] $memo
     * @param \StructType\SearchColumnSelectField[] $nextApprover
     * @param \StructType\SearchColumnBooleanField[] $paidExternally
     * @param \StructType\SearchColumnSelectField[] $payItem
     * @param \StructType\SearchColumnDateField[] $payrollDate
     * @param \StructType\SearchColumnDoubleField[] $rate
     * @param \StructType\SearchColumnDateField[] $startTime
     * @param \StructType\SearchColumnStringField[] $subsidiary
     * @param \StructType\SearchColumnStringField[] $subsidiaryNoHierarchy
     * @param \StructType\SearchColumnStringField[] $timeSheet
     * @param \StructType\SearchColumnEnumSelectField[] $type
     * @param \StructType\SearchColumnCustomFieldList $customFieldList
     */
    public function __construct(array $approvalStatus = array(), array $billingClass = array(), array $billingStatus = array(), array $break = array(), array $caseTaskEvent = array(), array $class = array(), array $classNoHierarchy = array(), array $customer = array(), array $date = array(), array $dateCreated = array(), array $department = array(), array $departmentNoHierarchy = array(), array $durationDecimal = array(), array $employee = array(), array $endTime = array(), array $externalId = array(), array $hours = array(), array $internalId = array(), array $isBillable = array(), array $isExempt = array(), array $isProductive = array(), array $isUtilized = array(), array $item = array(), array $lastModified = array(), array $location = array(), array $locationNoHierarchy = array(), array $memo = array(), array $nextApprover = array(), array $paidExternally = array(), array $payItem = array(), array $payrollDate = array(), array $rate = array(), array $startTime = array(), array $subsidiary = array(), array $subsidiaryNoHierarchy = array(), array $timeSheet = array(), array $type = array(), \StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this
            ->setApprovalStatus($approvalStatus)
            ->setBillingClass($billingClass)
            ->setBillingStatus($billingStatus)
            ->setBreak($break)
            ->setCaseTaskEvent($caseTaskEvent)
            ->setClass($class)
            ->setClassNoHierarchy($classNoHierarchy)
            ->setCustomer($customer)
            ->setDate($date)
            ->setDateCreated($dateCreated)
            ->setDepartment($department)
            ->setDepartmentNoHierarchy($departmentNoHierarchy)
            ->setDurationDecimal($durationDecimal)
            ->setEmployee($employee)
            ->setEndTime($endTime)
            ->setExternalId($externalId)
            ->setHours($hours)
            ->setInternalId($internalId)
            ->setIsBillable($isBillable)
            ->setIsExempt($isExempt)
            ->setIsProductive($isProductive)
            ->setIsUtilized($isUtilized)
            ->setItem($item)
            ->setLastModified($lastModified)
            ->setLocation($location)
            ->setLocationNoHierarchy($locationNoHierarchy)
            ->setMemo($memo)
            ->setNextApprover($nextApprover)
            ->setPaidExternally($paidExternally)
            ->setPayItem($payItem)
            ->setPayrollDate($payrollDate)
            ->setRate($rate)
            ->setStartTime($startTime)
            ->setSubsidiary($subsidiary)
            ->setSubsidiaryNoHierarchy($subsidiaryNoHierarchy)
            ->setTimeSheet($timeSheet)
            ->setType($type)
            ->setCustomFieldList($customFieldList);
    }
    /**
     * Get approvalStatus value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getApprovalStatus()
    {
        return $this->approvalStatus;
    }
    /**
     * This method is responsible for validating the values passed to the setApprovalStatus method
     * This method is willingly generated in order to preserve the one-line inline validation within the setApprovalStatus method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateApprovalStatusForArrayConstraintsFromSetApprovalStatus(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicApprovalStatusItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicApprovalStatusItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicApprovalStatusItem) ? get_class($timeEntrySearchRowBasicApprovalStatusItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicApprovalStatusItem), var_export($timeEntrySearchRowBasicApprovalStatusItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The approvalStatus 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 approvalStatus value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $approvalStatus
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setApprovalStatus(array $approvalStatus = array())
    {
        // validation for constraint: array
        if ('' !== ($approvalStatusArrayErrorMessage = self::validateApprovalStatusForArrayConstraintsFromSetApprovalStatus($approvalStatus))) {
            throw new \InvalidArgumentException($approvalStatusArrayErrorMessage, __LINE__);
        }
        $this->approvalStatus = $approvalStatus;
        return $this;
    }
    /**
     * Add item to approvalStatus value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToApprovalStatus(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The approvalStatus 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->approvalStatus[] = $item;
        return $this;
    }
    /**
     * Get billingClass value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getBillingClass()
    {
        return $this->billingClass;
    }
    /**
     * This method is responsible for validating the values passed to the setBillingClass method
     * This method is willingly generated in order to preserve the one-line inline validation within the setBillingClass method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateBillingClassForArrayConstraintsFromSetBillingClass(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicBillingClassItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicBillingClassItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicBillingClassItem) ? get_class($timeEntrySearchRowBasicBillingClassItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicBillingClassItem), var_export($timeEntrySearchRowBasicBillingClassItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The billingClass 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 billingClass value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $billingClass
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setBillingClass(array $billingClass = array())
    {
        // validation for constraint: array
        if ('' !== ($billingClassArrayErrorMessage = self::validateBillingClassForArrayConstraintsFromSetBillingClass($billingClass))) {
            throw new \InvalidArgumentException($billingClassArrayErrorMessage, __LINE__);
        }
        $this->billingClass = $billingClass;
        return $this;
    }
    /**
     * Add item to billingClass value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToBillingClass(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The billingClass 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->billingClass[] = $item;
        return $this;
    }
    /**
     * Get billingStatus value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getBillingStatus()
    {
        return $this->billingStatus;
    }
    /**
     * This method is responsible for validating the values passed to the setBillingStatus method
     * This method is willingly generated in order to preserve the one-line inline validation within the setBillingStatus method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateBillingStatusForArrayConstraintsFromSetBillingStatus(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicBillingStatusItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicBillingStatusItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicBillingStatusItem) ? get_class($timeEntrySearchRowBasicBillingStatusItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicBillingStatusItem), var_export($timeEntrySearchRowBasicBillingStatusItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The billingStatus 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 billingStatus value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $billingStatus
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setBillingStatus(array $billingStatus = array())
    {
        // validation for constraint: array
        if ('' !== ($billingStatusArrayErrorMessage = self::validateBillingStatusForArrayConstraintsFromSetBillingStatus($billingStatus))) {
            throw new \InvalidArgumentException($billingStatusArrayErrorMessage, __LINE__);
        }
        $this->billingStatus = $billingStatus;
        return $this;
    }
    /**
     * Add item to billingStatus value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToBillingStatus(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The billingStatus 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->billingStatus[] = $item;
        return $this;
    }
    /**
     * Get break value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getBreak()
    {
        return $this->break;
    }
    /**
     * This method is responsible for validating the values passed to the setBreak method
     * This method is willingly generated in order to preserve the one-line inline validation within the setBreak method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateBreakForArrayConstraintsFromSetBreak(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicBreakItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicBreakItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicBreakItem) ? get_class($timeEntrySearchRowBasicBreakItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicBreakItem), var_export($timeEntrySearchRowBasicBreakItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The break 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 break value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $break
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setBreak(array $break = array())
    {
        // validation for constraint: array
        if ('' !== ($breakArrayErrorMessage = self::validateBreakForArrayConstraintsFromSetBreak($break))) {
            throw new \InvalidArgumentException($breakArrayErrorMessage, __LINE__);
        }
        $this->break = $break;
        return $this;
    }
    /**
     * Add item to break value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToBreak(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The break 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->break[] = $item;
        return $this;
    }
    /**
     * Get caseTaskEvent value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getCaseTaskEvent()
    {
        return $this->caseTaskEvent;
    }
    /**
     * This method is responsible for validating the values passed to the setCaseTaskEvent method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCaseTaskEvent method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCaseTaskEventForArrayConstraintsFromSetCaseTaskEvent(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicCaseTaskEventItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicCaseTaskEventItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicCaseTaskEventItem) ? get_class($timeEntrySearchRowBasicCaseTaskEventItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicCaseTaskEventItem), var_export($timeEntrySearchRowBasicCaseTaskEventItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The caseTaskEvent 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 caseTaskEvent value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $caseTaskEvent
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setCaseTaskEvent(array $caseTaskEvent = array())
    {
        // validation for constraint: array
        if ('' !== ($caseTaskEventArrayErrorMessage = self::validateCaseTaskEventForArrayConstraintsFromSetCaseTaskEvent($caseTaskEvent))) {
            throw new \InvalidArgumentException($caseTaskEventArrayErrorMessage, __LINE__);
        }
        $this->caseTaskEvent = $caseTaskEvent;
        return $this;
    }
    /**
     * Add item to caseTaskEvent value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToCaseTaskEvent(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The caseTaskEvent 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->caseTaskEvent[] = $item;
        return $this;
    }
    /**
     * Get class value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getClass()
    {
        return $this->class;
    }
    /**
     * This method is responsible for validating the values passed to the setClass method
     * This method is willingly generated in order to preserve the one-line inline validation within the setClass method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateClassForArrayConstraintsFromSetClass(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicClassItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicClassItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicClassItem) ? get_class($timeEntrySearchRowBasicClassItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicClassItem), var_export($timeEntrySearchRowBasicClassItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The class 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 class value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $class
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setClass(array $class = array())
    {
        // validation for constraint: array
        if ('' !== ($classArrayErrorMessage = self::validateClassForArrayConstraintsFromSetClass($class))) {
            throw new \InvalidArgumentException($classArrayErrorMessage, __LINE__);
        }
        $this->class = $class;
        return $this;
    }
    /**
     * Add item to class value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToClass(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The class 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->class[] = $item;
        return $this;
    }
    /**
     * Get classNoHierarchy value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getClassNoHierarchy()
    {
        return $this->classNoHierarchy;
    }
    /**
     * This method is responsible for validating the values passed to the setClassNoHierarchy method
     * This method is willingly generated in order to preserve the one-line inline validation within the setClassNoHierarchy method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateClassNoHierarchyForArrayConstraintsFromSetClassNoHierarchy(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicClassNoHierarchyItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicClassNoHierarchyItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicClassNoHierarchyItem) ? get_class($timeEntrySearchRowBasicClassNoHierarchyItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicClassNoHierarchyItem), var_export($timeEntrySearchRowBasicClassNoHierarchyItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The classNoHierarchy 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 classNoHierarchy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $classNoHierarchy
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setClassNoHierarchy(array $classNoHierarchy = array())
    {
        // validation for constraint: array
        if ('' !== ($classNoHierarchyArrayErrorMessage = self::validateClassNoHierarchyForArrayConstraintsFromSetClassNoHierarchy($classNoHierarchy))) {
            throw new \InvalidArgumentException($classNoHierarchyArrayErrorMessage, __LINE__);
        }
        $this->classNoHierarchy = $classNoHierarchy;
        return $this;
    }
    /**
     * Add item to classNoHierarchy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToClassNoHierarchy(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The classNoHierarchy 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->classNoHierarchy[] = $item;
        return $this;
    }
    /**
     * Get customer value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getCustomer()
    {
        return $this->customer;
    }
    /**
     * This method is responsible for validating the values passed to the setCustomer method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCustomer method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCustomerForArrayConstraintsFromSetCustomer(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicCustomerItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicCustomerItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicCustomerItem) ? get_class($timeEntrySearchRowBasicCustomerItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicCustomerItem), var_export($timeEntrySearchRowBasicCustomerItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The customer 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 customer value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $customer
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setCustomer(array $customer = array())
    {
        // validation for constraint: array
        if ('' !== ($customerArrayErrorMessage = self::validateCustomerForArrayConstraintsFromSetCustomer($customer))) {
            throw new \InvalidArgumentException($customerArrayErrorMessage, __LINE__);
        }
        $this->customer = $customer;
        return $this;
    }
    /**
     * Add item to customer value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToCustomer(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The customer 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->customer[] = $item;
        return $this;
    }
    /**
     * Get date value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getDate()
    {
        return $this->date;
    }
    /**
     * This method is responsible for validating the values passed to the setDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateDateForArrayConstraintsFromSetDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicDateItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicDateItem) ? get_class($timeEntrySearchRowBasicDateItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicDateItem), var_export($timeEntrySearchRowBasicDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The date 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 date value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $date
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setDate(array $date = array())
    {
        // validation for constraint: array
        if ('' !== ($dateArrayErrorMessage = self::validateDateForArrayConstraintsFromSetDate($date))) {
            throw new \InvalidArgumentException($dateArrayErrorMessage, __LINE__);
        }
        $this->date = $date;
        return $this;
    }
    /**
     * Add item to date value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The date 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->date[] = $item;
        return $this;
    }
    /**
     * Get dateCreated value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getDateCreated()
    {
        return $this->dateCreated;
    }
    /**
     * This method is responsible for validating the values passed to the setDateCreated method
     * This method is willingly generated in order to preserve the one-line inline validation within the setDateCreated method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateDateCreatedForArrayConstraintsFromSetDateCreated(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicDateCreatedItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicDateCreatedItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicDateCreatedItem) ? get_class($timeEntrySearchRowBasicDateCreatedItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicDateCreatedItem), var_export($timeEntrySearchRowBasicDateCreatedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The dateCreated 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 dateCreated value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $dateCreated
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setDateCreated(array $dateCreated = array())
    {
        // validation for constraint: array
        if ('' !== ($dateCreatedArrayErrorMessage = self::validateDateCreatedForArrayConstraintsFromSetDateCreated($dateCreated))) {
            throw new \InvalidArgumentException($dateCreatedArrayErrorMessage, __LINE__);
        }
        $this->dateCreated = $dateCreated;
        return $this;
    }
    /**
     * Add item to dateCreated value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToDateCreated(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The dateCreated 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->dateCreated[] = $item;
        return $this;
    }
    /**
     * Get department value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getDepartment()
    {
        return $this->department;
    }
    /**
     * This method is responsible for validating the values passed to the setDepartment method
     * This method is willingly generated in order to preserve the one-line inline validation within the setDepartment method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateDepartmentForArrayConstraintsFromSetDepartment(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicDepartmentItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicDepartmentItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicDepartmentItem) ? get_class($timeEntrySearchRowBasicDepartmentItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicDepartmentItem), var_export($timeEntrySearchRowBasicDepartmentItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The department 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 department value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $department
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setDepartment(array $department = array())
    {
        // validation for constraint: array
        if ('' !== ($departmentArrayErrorMessage = self::validateDepartmentForArrayConstraintsFromSetDepartment($department))) {
            throw new \InvalidArgumentException($departmentArrayErrorMessage, __LINE__);
        }
        $this->department = $department;
        return $this;
    }
    /**
     * Add item to department value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToDepartment(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The department 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->department[] = $item;
        return $this;
    }
    /**
     * Get departmentNoHierarchy value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getDepartmentNoHierarchy()
    {
        return $this->departmentNoHierarchy;
    }
    /**
     * This method is responsible for validating the values passed to the setDepartmentNoHierarchy method
     * This method is willingly generated in order to preserve the one-line inline validation within the setDepartmentNoHierarchy method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateDepartmentNoHierarchyForArrayConstraintsFromSetDepartmentNoHierarchy(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicDepartmentNoHierarchyItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicDepartmentNoHierarchyItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicDepartmentNoHierarchyItem) ? get_class($timeEntrySearchRowBasicDepartmentNoHierarchyItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicDepartmentNoHierarchyItem), var_export($timeEntrySearchRowBasicDepartmentNoHierarchyItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The departmentNoHierarchy 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 departmentNoHierarchy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $departmentNoHierarchy
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setDepartmentNoHierarchy(array $departmentNoHierarchy = array())
    {
        // validation for constraint: array
        if ('' !== ($departmentNoHierarchyArrayErrorMessage = self::validateDepartmentNoHierarchyForArrayConstraintsFromSetDepartmentNoHierarchy($departmentNoHierarchy))) {
            throw new \InvalidArgumentException($departmentNoHierarchyArrayErrorMessage, __LINE__);
        }
        $this->departmentNoHierarchy = $departmentNoHierarchy;
        return $this;
    }
    /**
     * Add item to departmentNoHierarchy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToDepartmentNoHierarchy(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The departmentNoHierarchy 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->departmentNoHierarchy[] = $item;
        return $this;
    }
    /**
     * Get durationDecimal value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getDurationDecimal()
    {
        return $this->durationDecimal;
    }
    /**
     * This method is responsible for validating the values passed to the setDurationDecimal method
     * This method is willingly generated in order to preserve the one-line inline validation within the setDurationDecimal method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateDurationDecimalForArrayConstraintsFromSetDurationDecimal(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicDurationDecimalItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicDurationDecimalItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicDurationDecimalItem) ? get_class($timeEntrySearchRowBasicDurationDecimalItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicDurationDecimalItem), var_export($timeEntrySearchRowBasicDurationDecimalItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The durationDecimal 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 durationDecimal value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $durationDecimal
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setDurationDecimal(array $durationDecimal = array())
    {
        // validation for constraint: array
        if ('' !== ($durationDecimalArrayErrorMessage = self::validateDurationDecimalForArrayConstraintsFromSetDurationDecimal($durationDecimal))) {
            throw new \InvalidArgumentException($durationDecimalArrayErrorMessage, __LINE__);
        }
        $this->durationDecimal = $durationDecimal;
        return $this;
    }
    /**
     * Add item to durationDecimal value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToDurationDecimal(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The durationDecimal 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->durationDecimal[] = $item;
        return $this;
    }
    /**
     * Get employee value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getEmployee()
    {
        return $this->employee;
    }
    /**
     * This method is responsible for validating the values passed to the setEmployee method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEmployee method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEmployeeForArrayConstraintsFromSetEmployee(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicEmployeeItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicEmployeeItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicEmployeeItem) ? get_class($timeEntrySearchRowBasicEmployeeItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicEmployeeItem), var_export($timeEntrySearchRowBasicEmployeeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The employee 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 employee value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $employee
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setEmployee(array $employee = array())
    {
        // validation for constraint: array
        if ('' !== ($employeeArrayErrorMessage = self::validateEmployeeForArrayConstraintsFromSetEmployee($employee))) {
            throw new \InvalidArgumentException($employeeArrayErrorMessage, __LINE__);
        }
        $this->employee = $employee;
        return $this;
    }
    /**
     * Add item to employee value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToEmployee(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The employee 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->employee[] = $item;
        return $this;
    }
    /**
     * Get endTime value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getEndTime()
    {
        return $this->endTime;
    }
    /**
     * This method is responsible for validating the values passed to the setEndTime method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEndTime method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEndTimeForArrayConstraintsFromSetEndTime(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicEndTimeItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicEndTimeItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicEndTimeItem) ? get_class($timeEntrySearchRowBasicEndTimeItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicEndTimeItem), var_export($timeEntrySearchRowBasicEndTimeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The endTime 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 endTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $endTime
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setEndTime(array $endTime = array())
    {
        // validation for constraint: array
        if ('' !== ($endTimeArrayErrorMessage = self::validateEndTimeForArrayConstraintsFromSetEndTime($endTime))) {
            throw new \InvalidArgumentException($endTimeArrayErrorMessage, __LINE__);
        }
        $this->endTime = $endTime;
        return $this;
    }
    /**
     * Add item to endTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToEndTime(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The endTime 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->endTime[] = $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 $timeEntrySearchRowBasicExternalIdItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicExternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicExternalIdItem) ? get_class($timeEntrySearchRowBasicExternalIdItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicExternalIdItem), var_export($timeEntrySearchRowBasicExternalIdItem, 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\TimeEntrySearchRowBasic
     */
    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\TimeEntrySearchRowBasic
     */
    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 hours value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getHours()
    {
        return $this->hours;
    }
    /**
     * This method is responsible for validating the values passed to the setHours method
     * This method is willingly generated in order to preserve the one-line inline validation within the setHours method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateHoursForArrayConstraintsFromSetHours(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicHoursItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicHoursItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicHoursItem) ? get_class($timeEntrySearchRowBasicHoursItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicHoursItem), var_export($timeEntrySearchRowBasicHoursItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The hours 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 hours value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $hours
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setHours(array $hours = array())
    {
        // validation for constraint: array
        if ('' !== ($hoursArrayErrorMessage = self::validateHoursForArrayConstraintsFromSetHours($hours))) {
            throw new \InvalidArgumentException($hoursArrayErrorMessage, __LINE__);
        }
        $this->hours = $hours;
        return $this;
    }
    /**
     * Add item to hours value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToHours(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The hours 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->hours[] = $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 $timeEntrySearchRowBasicInternalIdItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicInternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicInternalIdItem) ? get_class($timeEntrySearchRowBasicInternalIdItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicInternalIdItem), var_export($timeEntrySearchRowBasicInternalIdItem, 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\TimeEntrySearchRowBasic
     */
    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\TimeEntrySearchRowBasic
     */
    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 isBillable value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsBillable()
    {
        return $this->isBillable;
    }
    /**
     * This method is responsible for validating the values passed to the setIsBillable method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsBillable method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsBillableForArrayConstraintsFromSetIsBillable(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicIsBillableItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicIsBillableItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicIsBillableItem) ? get_class($timeEntrySearchRowBasicIsBillableItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicIsBillableItem), var_export($timeEntrySearchRowBasicIsBillableItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isBillable 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 isBillable value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isBillable
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setIsBillable(array $isBillable = array())
    {
        // validation for constraint: array
        if ('' !== ($isBillableArrayErrorMessage = self::validateIsBillableForArrayConstraintsFromSetIsBillable($isBillable))) {
            throw new \InvalidArgumentException($isBillableArrayErrorMessage, __LINE__);
        }
        $this->isBillable = $isBillable;
        return $this;
    }
    /**
     * Add item to isBillable value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToIsBillable(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isBillable 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->isBillable[] = $item;
        return $this;
    }
    /**
     * Get isExempt value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsExempt()
    {
        return $this->isExempt;
    }
    /**
     * This method is responsible for validating the values passed to the setIsExempt method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsExempt method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsExemptForArrayConstraintsFromSetIsExempt(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicIsExemptItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicIsExemptItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicIsExemptItem) ? get_class($timeEntrySearchRowBasicIsExemptItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicIsExemptItem), var_export($timeEntrySearchRowBasicIsExemptItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isExempt 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 isExempt value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isExempt
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setIsExempt(array $isExempt = array())
    {
        // validation for constraint: array
        if ('' !== ($isExemptArrayErrorMessage = self::validateIsExemptForArrayConstraintsFromSetIsExempt($isExempt))) {
            throw new \InvalidArgumentException($isExemptArrayErrorMessage, __LINE__);
        }
        $this->isExempt = $isExempt;
        return $this;
    }
    /**
     * Add item to isExempt value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToIsExempt(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isExempt 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->isExempt[] = $item;
        return $this;
    }
    /**
     * Get isProductive value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsProductive()
    {
        return $this->isProductive;
    }
    /**
     * This method is responsible for validating the values passed to the setIsProductive method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsProductive method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsProductiveForArrayConstraintsFromSetIsProductive(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicIsProductiveItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicIsProductiveItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicIsProductiveItem) ? get_class($timeEntrySearchRowBasicIsProductiveItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicIsProductiveItem), var_export($timeEntrySearchRowBasicIsProductiveItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isProductive 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 isProductive value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isProductive
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setIsProductive(array $isProductive = array())
    {
        // validation for constraint: array
        if ('' !== ($isProductiveArrayErrorMessage = self::validateIsProductiveForArrayConstraintsFromSetIsProductive($isProductive))) {
            throw new \InvalidArgumentException($isProductiveArrayErrorMessage, __LINE__);
        }
        $this->isProductive = $isProductive;
        return $this;
    }
    /**
     * Add item to isProductive value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToIsProductive(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isProductive 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->isProductive[] = $item;
        return $this;
    }
    /**
     * Get isUtilized value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsUtilized()
    {
        return $this->isUtilized;
    }
    /**
     * This method is responsible for validating the values passed to the setIsUtilized method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsUtilized method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsUtilizedForArrayConstraintsFromSetIsUtilized(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicIsUtilizedItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicIsUtilizedItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicIsUtilizedItem) ? get_class($timeEntrySearchRowBasicIsUtilizedItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicIsUtilizedItem), var_export($timeEntrySearchRowBasicIsUtilizedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isUtilized 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 isUtilized value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isUtilized
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setIsUtilized(array $isUtilized = array())
    {
        // validation for constraint: array
        if ('' !== ($isUtilizedArrayErrorMessage = self::validateIsUtilizedForArrayConstraintsFromSetIsUtilized($isUtilized))) {
            throw new \InvalidArgumentException($isUtilizedArrayErrorMessage, __LINE__);
        }
        $this->isUtilized = $isUtilized;
        return $this;
    }
    /**
     * Add item to isUtilized value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToIsUtilized(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isUtilized 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->isUtilized[] = $item;
        return $this;
    }
    /**
     * Get item value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getItem()
    {
        return $this->item;
    }
    /**
     * This method is responsible for validating the values passed to the setItem method
     * This method is willingly generated in order to preserve the one-line inline validation within the setItem method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateItemForArrayConstraintsFromSetItem(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicItemItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicItemItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicItemItem) ? get_class($timeEntrySearchRowBasicItemItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicItemItem), var_export($timeEntrySearchRowBasicItemItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The item 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 item value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setItem(array $item = array())
    {
        // validation for constraint: array
        if ('' !== ($itemArrayErrorMessage = self::validateItemForArrayConstraintsFromSetItem($item))) {
            throw new \InvalidArgumentException($itemArrayErrorMessage, __LINE__);
        }
        $this->item = $item;
        return $this;
    }
    /**
     * Add item to item value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToItem(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The item 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->item[] = $item;
        return $this;
    }
    /**
     * Get lastModified value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getLastModified()
    {
        return $this->lastModified;
    }
    /**
     * This method is responsible for validating the values passed to the setLastModified method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLastModified method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLastModifiedForArrayConstraintsFromSetLastModified(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicLastModifiedItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicLastModifiedItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicLastModifiedItem) ? get_class($timeEntrySearchRowBasicLastModifiedItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicLastModifiedItem), var_export($timeEntrySearchRowBasicLastModifiedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The lastModified 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 lastModified value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $lastModified
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setLastModified(array $lastModified = array())
    {
        // validation for constraint: array
        if ('' !== ($lastModifiedArrayErrorMessage = self::validateLastModifiedForArrayConstraintsFromSetLastModified($lastModified))) {
            throw new \InvalidArgumentException($lastModifiedArrayErrorMessage, __LINE__);
        }
        $this->lastModified = $lastModified;
        return $this;
    }
    /**
     * Add item to lastModified value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToLastModified(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The lastModified 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->lastModified[] = $item;
        return $this;
    }
    /**
     * Get location value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getLocation()
    {
        return $this->location;
    }
    /**
     * This method is responsible for validating the values passed to the setLocation method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLocation method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLocationForArrayConstraintsFromSetLocation(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicLocationItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicLocationItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicLocationItem) ? get_class($timeEntrySearchRowBasicLocationItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicLocationItem), var_export($timeEntrySearchRowBasicLocationItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The location property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set location value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $location
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setLocation(array $location = array())
    {
        // validation for constraint: array
        if ('' !== ($locationArrayErrorMessage = self::validateLocationForArrayConstraintsFromSetLocation($location))) {
            throw new \InvalidArgumentException($locationArrayErrorMessage, __LINE__);
        }
        $this->location = $location;
        return $this;
    }
    /**
     * Add item to location value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToLocation(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The location property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->location[] = $item;
        return $this;
    }
    /**
     * Get locationNoHierarchy value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getLocationNoHierarchy()
    {
        return $this->locationNoHierarchy;
    }
    /**
     * This method is responsible for validating the values passed to the setLocationNoHierarchy method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLocationNoHierarchy method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLocationNoHierarchyForArrayConstraintsFromSetLocationNoHierarchy(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicLocationNoHierarchyItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicLocationNoHierarchyItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicLocationNoHierarchyItem) ? get_class($timeEntrySearchRowBasicLocationNoHierarchyItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicLocationNoHierarchyItem), var_export($timeEntrySearchRowBasicLocationNoHierarchyItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The locationNoHierarchy 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 locationNoHierarchy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $locationNoHierarchy
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setLocationNoHierarchy(array $locationNoHierarchy = array())
    {
        // validation for constraint: array
        if ('' !== ($locationNoHierarchyArrayErrorMessage = self::validateLocationNoHierarchyForArrayConstraintsFromSetLocationNoHierarchy($locationNoHierarchy))) {
            throw new \InvalidArgumentException($locationNoHierarchyArrayErrorMessage, __LINE__);
        }
        $this->locationNoHierarchy = $locationNoHierarchy;
        return $this;
    }
    /**
     * Add item to locationNoHierarchy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToLocationNoHierarchy(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The locationNoHierarchy 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->locationNoHierarchy[] = $item;
        return $this;
    }
    /**
     * Get memo value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getMemo()
    {
        return $this->memo;
    }
    /**
     * This method is responsible for validating the values passed to the setMemo method
     * This method is willingly generated in order to preserve the one-line inline validation within the setMemo method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateMemoForArrayConstraintsFromSetMemo(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicMemoItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicMemoItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicMemoItem) ? get_class($timeEntrySearchRowBasicMemoItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicMemoItem), var_export($timeEntrySearchRowBasicMemoItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The memo property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set memo value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $memo
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setMemo(array $memo = array())
    {
        // validation for constraint: array
        if ('' !== ($memoArrayErrorMessage = self::validateMemoForArrayConstraintsFromSetMemo($memo))) {
            throw new \InvalidArgumentException($memoArrayErrorMessage, __LINE__);
        }
        $this->memo = $memo;
        return $this;
    }
    /**
     * Add item to memo value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToMemo(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The memo property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->memo[] = $item;
        return $this;
    }
    /**
     * Get nextApprover value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getNextApprover()
    {
        return $this->nextApprover;
    }
    /**
     * This method is responsible for validating the values passed to the setNextApprover method
     * This method is willingly generated in order to preserve the one-line inline validation within the setNextApprover method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateNextApproverForArrayConstraintsFromSetNextApprover(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicNextApproverItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicNextApproverItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicNextApproverItem) ? get_class($timeEntrySearchRowBasicNextApproverItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicNextApproverItem), var_export($timeEntrySearchRowBasicNextApproverItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The nextApprover 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 nextApprover value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $nextApprover
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setNextApprover(array $nextApprover = array())
    {
        // validation for constraint: array
        if ('' !== ($nextApproverArrayErrorMessage = self::validateNextApproverForArrayConstraintsFromSetNextApprover($nextApprover))) {
            throw new \InvalidArgumentException($nextApproverArrayErrorMessage, __LINE__);
        }
        $this->nextApprover = $nextApprover;
        return $this;
    }
    /**
     * Add item to nextApprover value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToNextApprover(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The nextApprover 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->nextApprover[] = $item;
        return $this;
    }
    /**
     * Get paidExternally value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getPaidExternally()
    {
        return $this->paidExternally;
    }
    /**
     * This method is responsible for validating the values passed to the setPaidExternally method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPaidExternally method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePaidExternallyForArrayConstraintsFromSetPaidExternally(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicPaidExternallyItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicPaidExternallyItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicPaidExternallyItem) ? get_class($timeEntrySearchRowBasicPaidExternallyItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicPaidExternallyItem), var_export($timeEntrySearchRowBasicPaidExternallyItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The paidExternally 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 paidExternally value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $paidExternally
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setPaidExternally(array $paidExternally = array())
    {
        // validation for constraint: array
        if ('' !== ($paidExternallyArrayErrorMessage = self::validatePaidExternallyForArrayConstraintsFromSetPaidExternally($paidExternally))) {
            throw new \InvalidArgumentException($paidExternallyArrayErrorMessage, __LINE__);
        }
        $this->paidExternally = $paidExternally;
        return $this;
    }
    /**
     * Add item to paidExternally value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToPaidExternally(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The paidExternally 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->paidExternally[] = $item;
        return $this;
    }
    /**
     * Get payItem value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getPayItem()
    {
        return $this->payItem;
    }
    /**
     * This method is responsible for validating the values passed to the setPayItem method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPayItem method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePayItemForArrayConstraintsFromSetPayItem(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicPayItemItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicPayItemItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicPayItemItem) ? get_class($timeEntrySearchRowBasicPayItemItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicPayItemItem), var_export($timeEntrySearchRowBasicPayItemItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The payItem 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 payItem value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $payItem
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setPayItem(array $payItem = array())
    {
        // validation for constraint: array
        if ('' !== ($payItemArrayErrorMessage = self::validatePayItemForArrayConstraintsFromSetPayItem($payItem))) {
            throw new \InvalidArgumentException($payItemArrayErrorMessage, __LINE__);
        }
        $this->payItem = $payItem;
        return $this;
    }
    /**
     * Add item to payItem value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToPayItem(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The payItem 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->payItem[] = $item;
        return $this;
    }
    /**
     * Get payrollDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getPayrollDate()
    {
        return $this->payrollDate;
    }
    /**
     * This method is responsible for validating the values passed to the setPayrollDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPayrollDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePayrollDateForArrayConstraintsFromSetPayrollDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicPayrollDateItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicPayrollDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicPayrollDateItem) ? get_class($timeEntrySearchRowBasicPayrollDateItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicPayrollDateItem), var_export($timeEntrySearchRowBasicPayrollDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The payrollDate 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 payrollDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $payrollDate
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setPayrollDate(array $payrollDate = array())
    {
        // validation for constraint: array
        if ('' !== ($payrollDateArrayErrorMessage = self::validatePayrollDateForArrayConstraintsFromSetPayrollDate($payrollDate))) {
            throw new \InvalidArgumentException($payrollDateArrayErrorMessage, __LINE__);
        }
        $this->payrollDate = $payrollDate;
        return $this;
    }
    /**
     * Add item to payrollDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToPayrollDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The payrollDate 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->payrollDate[] = $item;
        return $this;
    }
    /**
     * Get rate value
     * @return \StructType\SearchColumnDoubleField[]|null
     */
    public function getRate()
    {
        return $this->rate;
    }
    /**
     * This method is responsible for validating the values passed to the setRate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setRate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateRateForArrayConstraintsFromSetRate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicRateItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicRateItem instanceof \StructType\SearchColumnDoubleField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicRateItem) ? get_class($timeEntrySearchRowBasicRateItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicRateItem), var_export($timeEntrySearchRowBasicRateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The rate 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 rate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField[] $rate
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setRate(array $rate = array())
    {
        // validation for constraint: array
        if ('' !== ($rateArrayErrorMessage = self::validateRateForArrayConstraintsFromSetRate($rate))) {
            throw new \InvalidArgumentException($rateArrayErrorMessage, __LINE__);
        }
        $this->rate = $rate;
        return $this;
    }
    /**
     * Add item to rate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDoubleField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToRate(\StructType\SearchColumnDoubleField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDoubleField) {
            throw new \InvalidArgumentException(sprintf('The rate 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->rate[] = $item;
        return $this;
    }
    /**
     * Get startTime value
     * @return \StructType\SearchColumnDateField[]|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 $timeEntrySearchRowBasicStartTimeItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicStartTimeItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicStartTimeItem) ? get_class($timeEntrySearchRowBasicStartTimeItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicStartTimeItem), var_export($timeEntrySearchRowBasicStartTimeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The startTime 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 startTime value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $startTime
     * @return \StructType\TimeEntrySearchRowBasic
     */
    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\SearchColumnDateField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToStartTime(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The startTime 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->startTime[] = $item;
        return $this;
    }
    /**
     * Get subsidiary value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getSubsidiary()
    {
        return $this->subsidiary;
    }
    /**
     * This method is responsible for validating the values passed to the setSubsidiary method
     * This method is willingly generated in order to preserve the one-line inline validation within the setSubsidiary method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateSubsidiaryForArrayConstraintsFromSetSubsidiary(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicSubsidiaryItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicSubsidiaryItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicSubsidiaryItem) ? get_class($timeEntrySearchRowBasicSubsidiaryItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicSubsidiaryItem), var_export($timeEntrySearchRowBasicSubsidiaryItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The subsidiary 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 subsidiary value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $subsidiary
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setSubsidiary(array $subsidiary = array())
    {
        // validation for constraint: array
        if ('' !== ($subsidiaryArrayErrorMessage = self::validateSubsidiaryForArrayConstraintsFromSetSubsidiary($subsidiary))) {
            throw new \InvalidArgumentException($subsidiaryArrayErrorMessage, __LINE__);
        }
        $this->subsidiary = $subsidiary;
        return $this;
    }
    /**
     * Add item to subsidiary value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToSubsidiary(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The subsidiary 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->subsidiary[] = $item;
        return $this;
    }
    /**
     * Get subsidiaryNoHierarchy value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getSubsidiaryNoHierarchy()
    {
        return $this->subsidiaryNoHierarchy;
    }
    /**
     * This method is responsible for validating the values passed to the setSubsidiaryNoHierarchy method
     * This method is willingly generated in order to preserve the one-line inline validation within the setSubsidiaryNoHierarchy method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateSubsidiaryNoHierarchyForArrayConstraintsFromSetSubsidiaryNoHierarchy(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicSubsidiaryNoHierarchyItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicSubsidiaryNoHierarchyItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicSubsidiaryNoHierarchyItem) ? get_class($timeEntrySearchRowBasicSubsidiaryNoHierarchyItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicSubsidiaryNoHierarchyItem), var_export($timeEntrySearchRowBasicSubsidiaryNoHierarchyItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The subsidiaryNoHierarchy 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 subsidiaryNoHierarchy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $subsidiaryNoHierarchy
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setSubsidiaryNoHierarchy(array $subsidiaryNoHierarchy = array())
    {
        // validation for constraint: array
        if ('' !== ($subsidiaryNoHierarchyArrayErrorMessage = self::validateSubsidiaryNoHierarchyForArrayConstraintsFromSetSubsidiaryNoHierarchy($subsidiaryNoHierarchy))) {
            throw new \InvalidArgumentException($subsidiaryNoHierarchyArrayErrorMessage, __LINE__);
        }
        $this->subsidiaryNoHierarchy = $subsidiaryNoHierarchy;
        return $this;
    }
    /**
     * Add item to subsidiaryNoHierarchy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToSubsidiaryNoHierarchy(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The subsidiaryNoHierarchy 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->subsidiaryNoHierarchy[] = $item;
        return $this;
    }
    /**
     * Get timeSheet value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getTimeSheet()
    {
        return $this->timeSheet;
    }
    /**
     * This method is responsible for validating the values passed to the setTimeSheet method
     * This method is willingly generated in order to preserve the one-line inline validation within the setTimeSheet method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateTimeSheetForArrayConstraintsFromSetTimeSheet(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicTimeSheetItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicTimeSheetItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicTimeSheetItem) ? get_class($timeEntrySearchRowBasicTimeSheetItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicTimeSheetItem), var_export($timeEntrySearchRowBasicTimeSheetItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The timeSheet 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 timeSheet value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $timeSheet
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setTimeSheet(array $timeSheet = array())
    {
        // validation for constraint: array
        if ('' !== ($timeSheetArrayErrorMessage = self::validateTimeSheetForArrayConstraintsFromSetTimeSheet($timeSheet))) {
            throw new \InvalidArgumentException($timeSheetArrayErrorMessage, __LINE__);
        }
        $this->timeSheet = $timeSheet;
        return $this;
    }
    /**
     * Add item to timeSheet value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToTimeSheet(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The timeSheet 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->timeSheet[] = $item;
        return $this;
    }
    /**
     * Get type value
     * @return \StructType\SearchColumnEnumSelectField[]|null
     */
    public function getType()
    {
        return $this->type;
    }
    /**
     * This method is responsible for validating the values passed to the setType method
     * This method is willingly generated in order to preserve the one-line inline validation within the setType method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateTypeForArrayConstraintsFromSetType(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $timeEntrySearchRowBasicTypeItem) {
            // validation for constraint: itemType
            if (!$timeEntrySearchRowBasicTypeItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($timeEntrySearchRowBasicTypeItem) ? get_class($timeEntrySearchRowBasicTypeItem) : sprintf('%s(%s)', gettype($timeEntrySearchRowBasicTypeItem), var_export($timeEntrySearchRowBasicTypeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The type 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 type value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField[] $type
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function setType(array $type = array())
    {
        // validation for constraint: array
        if ('' !== ($typeArrayErrorMessage = self::validateTypeForArrayConstraintsFromSetType($type))) {
            throw new \InvalidArgumentException($typeArrayErrorMessage, __LINE__);
        }
        $this->type = $type;
        return $this;
    }
    /**
     * Add item to type value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField $item
     * @return \StructType\TimeEntrySearchRowBasic
     */
    public function addToType(\StructType\SearchColumnEnumSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnEnumSelectField) {
            throw new \InvalidArgumentException(sprintf('The type 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->type[] = $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\TimeEntrySearchRowBasic
     */
    public function setCustomFieldList(\StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this->customFieldList = $customFieldList;
        return $this;
    }
}
