<?php

namespace StructType;

use \WsdlToPhp\PackageBase\AbstractStructBase;

/**
 * This class stands for PhoneCallSearchRowBasic StructType
 * @subpackage Structs
 */
class PhoneCallSearchRowBasic extends SearchRowBasic
{
    /**
     * The accessLevel
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $accessLevel;
    /**
     * The assigned
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $assigned;
    /**
     * The company
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $company;
    /**
     * The completedDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $completedDate;
    /**
     * The contact
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $contact;
    /**
     * The createdDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $createdDate;
    /**
     * The endDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $endDate;
    /**
     * The externalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $externalId;
    /**
     * The internalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $internalId;
    /**
     * The lastModifiedDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $lastModifiedDate;
    /**
     * The markdone
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $markdone;
    /**
     * The message
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $message;
    /**
     * The owner
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $owner;
    /**
     * The phone
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $phone;
    /**
     * The priority
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnEnumSelectField[]
     */
    public $priority;
    /**
     * The startDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $startDate;
    /**
     * The startTime
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $startTime;
    /**
     * The status
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnEnumSelectField[]
     */
    public $status;
    /**
     * The title
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $title;
    /**
     * The transaction
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $transaction;
    /**
     * The customFieldList
     * Meta information extracted from the WSDL
     * - minOccurs: 0
     * @var \StructType\SearchColumnCustomFieldList
     */
    public $customFieldList;
    /**
     * Constructor method for PhoneCallSearchRowBasic
     * @uses PhoneCallSearchRowBasic::setAccessLevel()
     * @uses PhoneCallSearchRowBasic::setAssigned()
     * @uses PhoneCallSearchRowBasic::setCompany()
     * @uses PhoneCallSearchRowBasic::setCompletedDate()
     * @uses PhoneCallSearchRowBasic::setContact()
     * @uses PhoneCallSearchRowBasic::setCreatedDate()
     * @uses PhoneCallSearchRowBasic::setEndDate()
     * @uses PhoneCallSearchRowBasic::setExternalId()
     * @uses PhoneCallSearchRowBasic::setInternalId()
     * @uses PhoneCallSearchRowBasic::setLastModifiedDate()
     * @uses PhoneCallSearchRowBasic::setMarkdone()
     * @uses PhoneCallSearchRowBasic::setMessage()
     * @uses PhoneCallSearchRowBasic::setOwner()
     * @uses PhoneCallSearchRowBasic::setPhone()
     * @uses PhoneCallSearchRowBasic::setPriority()
     * @uses PhoneCallSearchRowBasic::setStartDate()
     * @uses PhoneCallSearchRowBasic::setStartTime()
     * @uses PhoneCallSearchRowBasic::setStatus()
     * @uses PhoneCallSearchRowBasic::setTitle()
     * @uses PhoneCallSearchRowBasic::setTransaction()
     * @uses PhoneCallSearchRowBasic::setCustomFieldList()
     * @param \StructType\SearchColumnStringField[] $accessLevel
     * @param \StructType\SearchColumnSelectField[] $assigned
     * @param \StructType\SearchColumnSelectField[] $company
     * @param \StructType\SearchColumnDateField[] $completedDate
     * @param \StructType\SearchColumnSelectField[] $contact
     * @param \StructType\SearchColumnDateField[] $createdDate
     * @param \StructType\SearchColumnDateField[] $endDate
     * @param \StructType\SearchColumnSelectField[] $externalId
     * @param \StructType\SearchColumnSelectField[] $internalId
     * @param \StructType\SearchColumnDateField[] $lastModifiedDate
     * @param \StructType\SearchColumnStringField[] $markdone
     * @param \StructType\SearchColumnStringField[] $message
     * @param \StructType\SearchColumnSelectField[] $owner
     * @param \StructType\SearchColumnStringField[] $phone
     * @param \StructType\SearchColumnEnumSelectField[] $priority
     * @param \StructType\SearchColumnDateField[] $startDate
     * @param \StructType\SearchColumnDateField[] $startTime
     * @param \StructType\SearchColumnEnumSelectField[] $status
     * @param \StructType\SearchColumnStringField[] $title
     * @param \StructType\SearchColumnSelectField[] $transaction
     * @param \StructType\SearchColumnCustomFieldList $customFieldList
     */
    public function __construct(array $accessLevel = array(), array $assigned = array(), array $company = array(), array $completedDate = array(), array $contact = array(), array $createdDate = array(), array $endDate = array(), array $externalId = array(), array $internalId = array(), array $lastModifiedDate = array(), array $markdone = array(), array $message = array(), array $owner = array(), array $phone = array(), array $priority = array(), array $startDate = array(), array $startTime = array(), array $status = array(), array $title = array(), array $transaction = array(), \StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this
            ->setAccessLevel($accessLevel)
            ->setAssigned($assigned)
            ->setCompany($company)
            ->setCompletedDate($completedDate)
            ->setContact($contact)
            ->setCreatedDate($createdDate)
            ->setEndDate($endDate)
            ->setExternalId($externalId)
            ->setInternalId($internalId)
            ->setLastModifiedDate($lastModifiedDate)
            ->setMarkdone($markdone)
            ->setMessage($message)
            ->setOwner($owner)
            ->setPhone($phone)
            ->setPriority($priority)
            ->setStartDate($startDate)
            ->setStartTime($startTime)
            ->setStatus($status)
            ->setTitle($title)
            ->setTransaction($transaction)
            ->setCustomFieldList($customFieldList);
    }
    /**
     * Get accessLevel value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getAccessLevel()
    {
        return $this->accessLevel;
    }
    /**
     * This method is responsible for validating the values passed to the setAccessLevel method
     * This method is willingly generated in order to preserve the one-line inline validation within the setAccessLevel method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateAccessLevelForArrayConstraintsFromSetAccessLevel(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicAccessLevelItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicAccessLevelItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicAccessLevelItem) ? get_class($phoneCallSearchRowBasicAccessLevelItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicAccessLevelItem), var_export($phoneCallSearchRowBasicAccessLevelItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The accessLevel property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set accessLevel value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $accessLevel
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setAccessLevel(array $accessLevel = array())
    {
        // validation for constraint: array
        if ('' !== ($accessLevelArrayErrorMessage = self::validateAccessLevelForArrayConstraintsFromSetAccessLevel($accessLevel))) {
            throw new \InvalidArgumentException($accessLevelArrayErrorMessage, __LINE__);
        }
        $this->accessLevel = $accessLevel;
        return $this;
    }
    /**
     * Add item to accessLevel value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToAccessLevel(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The accessLevel property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->accessLevel[] = $item;
        return $this;
    }
    /**
     * Get assigned value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getAssigned()
    {
        return $this->assigned;
    }
    /**
     * This method is responsible for validating the values passed to the setAssigned method
     * This method is willingly generated in order to preserve the one-line inline validation within the setAssigned method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateAssignedForArrayConstraintsFromSetAssigned(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicAssignedItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicAssignedItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicAssignedItem) ? get_class($phoneCallSearchRowBasicAssignedItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicAssignedItem), var_export($phoneCallSearchRowBasicAssignedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The assigned property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set assigned value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $assigned
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setAssigned(array $assigned = array())
    {
        // validation for constraint: array
        if ('' !== ($assignedArrayErrorMessage = self::validateAssignedForArrayConstraintsFromSetAssigned($assigned))) {
            throw new \InvalidArgumentException($assignedArrayErrorMessage, __LINE__);
        }
        $this->assigned = $assigned;
        return $this;
    }
    /**
     * Add item to assigned value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToAssigned(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The assigned property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->assigned[] = $item;
        return $this;
    }
    /**
     * Get company value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getCompany()
    {
        return $this->company;
    }
    /**
     * This method is responsible for validating the values passed to the setCompany method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCompany method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCompanyForArrayConstraintsFromSetCompany(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicCompanyItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicCompanyItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicCompanyItem) ? get_class($phoneCallSearchRowBasicCompanyItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicCompanyItem), var_export($phoneCallSearchRowBasicCompanyItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The company property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set company value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $company
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setCompany(array $company = array())
    {
        // validation for constraint: array
        if ('' !== ($companyArrayErrorMessage = self::validateCompanyForArrayConstraintsFromSetCompany($company))) {
            throw new \InvalidArgumentException($companyArrayErrorMessage, __LINE__);
        }
        $this->company = $company;
        return $this;
    }
    /**
     * Add item to company value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToCompany(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The company property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->company[] = $item;
        return $this;
    }
    /**
     * Get completedDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getCompletedDate()
    {
        return $this->completedDate;
    }
    /**
     * This method is responsible for validating the values passed to the setCompletedDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCompletedDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCompletedDateForArrayConstraintsFromSetCompletedDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicCompletedDateItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicCompletedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicCompletedDateItem) ? get_class($phoneCallSearchRowBasicCompletedDateItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicCompletedDateItem), var_export($phoneCallSearchRowBasicCompletedDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The completedDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set completedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $completedDate
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setCompletedDate(array $completedDate = array())
    {
        // validation for constraint: array
        if ('' !== ($completedDateArrayErrorMessage = self::validateCompletedDateForArrayConstraintsFromSetCompletedDate($completedDate))) {
            throw new \InvalidArgumentException($completedDateArrayErrorMessage, __LINE__);
        }
        $this->completedDate = $completedDate;
        return $this;
    }
    /**
     * Add item to completedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToCompletedDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The completedDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->completedDate[] = $item;
        return $this;
    }
    /**
     * Get contact value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getContact()
    {
        return $this->contact;
    }
    /**
     * This method is responsible for validating the values passed to the setContact method
     * This method is willingly generated in order to preserve the one-line inline validation within the setContact method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateContactForArrayConstraintsFromSetContact(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicContactItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicContactItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicContactItem) ? get_class($phoneCallSearchRowBasicContactItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicContactItem), var_export($phoneCallSearchRowBasicContactItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The contact property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set contact value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $contact
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setContact(array $contact = array())
    {
        // validation for constraint: array
        if ('' !== ($contactArrayErrorMessage = self::validateContactForArrayConstraintsFromSetContact($contact))) {
            throw new \InvalidArgumentException($contactArrayErrorMessage, __LINE__);
        }
        $this->contact = $contact;
        return $this;
    }
    /**
     * Add item to contact value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToContact(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The contact property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->contact[] = $item;
        return $this;
    }
    /**
     * Get createdDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getCreatedDate()
    {
        return $this->createdDate;
    }
    /**
     * This method is responsible for validating the values passed to the setCreatedDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCreatedDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCreatedDateForArrayConstraintsFromSetCreatedDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicCreatedDateItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicCreatedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicCreatedDateItem) ? get_class($phoneCallSearchRowBasicCreatedDateItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicCreatedDateItem), var_export($phoneCallSearchRowBasicCreatedDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The createdDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set createdDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $createdDate
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setCreatedDate(array $createdDate = array())
    {
        // validation for constraint: array
        if ('' !== ($createdDateArrayErrorMessage = self::validateCreatedDateForArrayConstraintsFromSetCreatedDate($createdDate))) {
            throw new \InvalidArgumentException($createdDateArrayErrorMessage, __LINE__);
        }
        $this->createdDate = $createdDate;
        return $this;
    }
    /**
     * Add item to createdDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToCreatedDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The createdDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->createdDate[] = $item;
        return $this;
    }
    /**
     * Get endDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getEndDate()
    {
        return $this->endDate;
    }
    /**
     * This method is responsible for validating the values passed to the setEndDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEndDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEndDateForArrayConstraintsFromSetEndDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicEndDateItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicEndDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicEndDateItem) ? get_class($phoneCallSearchRowBasicEndDateItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicEndDateItem), var_export($phoneCallSearchRowBasicEndDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The endDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set endDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $endDate
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setEndDate(array $endDate = array())
    {
        // validation for constraint: array
        if ('' !== ($endDateArrayErrorMessage = self::validateEndDateForArrayConstraintsFromSetEndDate($endDate))) {
            throw new \InvalidArgumentException($endDateArrayErrorMessage, __LINE__);
        }
        $this->endDate = $endDate;
        return $this;
    }
    /**
     * Add item to endDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToEndDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The endDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->endDate[] = $item;
        return $this;
    }
    /**
     * Get 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 $phoneCallSearchRowBasicExternalIdItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicExternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicExternalIdItem) ? get_class($phoneCallSearchRowBasicExternalIdItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicExternalIdItem), var_export($phoneCallSearchRowBasicExternalIdItem, 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\PhoneCallSearchRowBasic
     */
    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\PhoneCallSearchRowBasic
     */
    public function addToExternalId(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The externalId property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->externalId[] = $item;
        return $this;
    }
    /**
     * Get internalId value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getInternalId()
    {
        return $this->internalId;
    }
    /**
     * This method is responsible for validating the values passed to the setInternalId method
     * This method is willingly generated in order to preserve the one-line inline validation within the setInternalId method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateInternalIdForArrayConstraintsFromSetInternalId(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicInternalIdItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicInternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicInternalIdItem) ? get_class($phoneCallSearchRowBasicInternalIdItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicInternalIdItem), var_export($phoneCallSearchRowBasicInternalIdItem, 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\PhoneCallSearchRowBasic
     */
    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\PhoneCallSearchRowBasic
     */
    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 lastModifiedDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getLastModifiedDate()
    {
        return $this->lastModifiedDate;
    }
    /**
     * This method is responsible for validating the values passed to the setLastModifiedDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLastModifiedDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLastModifiedDateForArrayConstraintsFromSetLastModifiedDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicLastModifiedDateItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicLastModifiedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicLastModifiedDateItem) ? get_class($phoneCallSearchRowBasicLastModifiedDateItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicLastModifiedDateItem), var_export($phoneCallSearchRowBasicLastModifiedDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The lastModifiedDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set lastModifiedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $lastModifiedDate
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setLastModifiedDate(array $lastModifiedDate = array())
    {
        // validation for constraint: array
        if ('' !== ($lastModifiedDateArrayErrorMessage = self::validateLastModifiedDateForArrayConstraintsFromSetLastModifiedDate($lastModifiedDate))) {
            throw new \InvalidArgumentException($lastModifiedDateArrayErrorMessage, __LINE__);
        }
        $this->lastModifiedDate = $lastModifiedDate;
        return $this;
    }
    /**
     * Add item to lastModifiedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToLastModifiedDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The lastModifiedDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->lastModifiedDate[] = $item;
        return $this;
    }
    /**
     * Get markdone value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getMarkdone()
    {
        return $this->markdone;
    }
    /**
     * This method is responsible for validating the values passed to the setMarkdone method
     * This method is willingly generated in order to preserve the one-line inline validation within the setMarkdone method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateMarkdoneForArrayConstraintsFromSetMarkdone(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicMarkdoneItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicMarkdoneItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicMarkdoneItem) ? get_class($phoneCallSearchRowBasicMarkdoneItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicMarkdoneItem), var_export($phoneCallSearchRowBasicMarkdoneItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The markdone property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set markdone value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $markdone
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setMarkdone(array $markdone = array())
    {
        // validation for constraint: array
        if ('' !== ($markdoneArrayErrorMessage = self::validateMarkdoneForArrayConstraintsFromSetMarkdone($markdone))) {
            throw new \InvalidArgumentException($markdoneArrayErrorMessage, __LINE__);
        }
        $this->markdone = $markdone;
        return $this;
    }
    /**
     * Add item to markdone value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToMarkdone(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The markdone property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->markdone[] = $item;
        return $this;
    }
    /**
     * Get message value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getMessage()
    {
        return $this->message;
    }
    /**
     * This method is responsible for validating the values passed to the setMessage method
     * This method is willingly generated in order to preserve the one-line inline validation within the setMessage method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateMessageForArrayConstraintsFromSetMessage(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicMessageItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicMessageItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicMessageItem) ? get_class($phoneCallSearchRowBasicMessageItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicMessageItem), var_export($phoneCallSearchRowBasicMessageItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The message property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set message value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $message
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setMessage(array $message = array())
    {
        // validation for constraint: array
        if ('' !== ($messageArrayErrorMessage = self::validateMessageForArrayConstraintsFromSetMessage($message))) {
            throw new \InvalidArgumentException($messageArrayErrorMessage, __LINE__);
        }
        $this->message = $message;
        return $this;
    }
    /**
     * Add item to message value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToMessage(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The message property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->message[] = $item;
        return $this;
    }
    /**
     * Get owner value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getOwner()
    {
        return $this->owner;
    }
    /**
     * This method is responsible for validating the values passed to the setOwner method
     * This method is willingly generated in order to preserve the one-line inline validation within the setOwner method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateOwnerForArrayConstraintsFromSetOwner(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicOwnerItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicOwnerItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicOwnerItem) ? get_class($phoneCallSearchRowBasicOwnerItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicOwnerItem), var_export($phoneCallSearchRowBasicOwnerItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The owner property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set owner value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $owner
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setOwner(array $owner = array())
    {
        // validation for constraint: array
        if ('' !== ($ownerArrayErrorMessage = self::validateOwnerForArrayConstraintsFromSetOwner($owner))) {
            throw new \InvalidArgumentException($ownerArrayErrorMessage, __LINE__);
        }
        $this->owner = $owner;
        return $this;
    }
    /**
     * Add item to owner value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToOwner(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The owner property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->owner[] = $item;
        return $this;
    }
    /**
     * Get phone value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getPhone()
    {
        return $this->phone;
    }
    /**
     * This method is responsible for validating the values passed to the setPhone method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPhone method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePhoneForArrayConstraintsFromSetPhone(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicPhoneItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicPhoneItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicPhoneItem) ? get_class($phoneCallSearchRowBasicPhoneItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicPhoneItem), var_export($phoneCallSearchRowBasicPhoneItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The phone 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 phone value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $phone
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setPhone(array $phone = array())
    {
        // validation for constraint: array
        if ('' !== ($phoneArrayErrorMessage = self::validatePhoneForArrayConstraintsFromSetPhone($phone))) {
            throw new \InvalidArgumentException($phoneArrayErrorMessage, __LINE__);
        }
        $this->phone = $phone;
        return $this;
    }
    /**
     * Add item to phone value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToPhone(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The phone 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->phone[] = $item;
        return $this;
    }
    /**
     * Get priority value
     * @return \StructType\SearchColumnEnumSelectField[]|null
     */
    public function getPriority()
    {
        return $this->priority;
    }
    /**
     * This method is responsible for validating the values passed to the setPriority method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPriority method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePriorityForArrayConstraintsFromSetPriority(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicPriorityItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicPriorityItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicPriorityItem) ? get_class($phoneCallSearchRowBasicPriorityItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicPriorityItem), var_export($phoneCallSearchRowBasicPriorityItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The priority property can only contain items of type \StructType\SearchColumnEnumSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set priority value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField[] $priority
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setPriority(array $priority = array())
    {
        // validation for constraint: array
        if ('' !== ($priorityArrayErrorMessage = self::validatePriorityForArrayConstraintsFromSetPriority($priority))) {
            throw new \InvalidArgumentException($priorityArrayErrorMessage, __LINE__);
        }
        $this->priority = $priority;
        return $this;
    }
    /**
     * Add item to priority value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToPriority(\StructType\SearchColumnEnumSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnEnumSelectField) {
            throw new \InvalidArgumentException(sprintf('The priority property can only contain items of type \StructType\SearchColumnEnumSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->priority[] = $item;
        return $this;
    }
    /**
     * Get startDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getStartDate()
    {
        return $this->startDate;
    }
    /**
     * This method is responsible for validating the values passed to the setStartDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setStartDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateStartDateForArrayConstraintsFromSetStartDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicStartDateItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicStartDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicStartDateItem) ? get_class($phoneCallSearchRowBasicStartDateItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicStartDateItem), var_export($phoneCallSearchRowBasicStartDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The startDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set startDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $startDate
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setStartDate(array $startDate = array())
    {
        // validation for constraint: array
        if ('' !== ($startDateArrayErrorMessage = self::validateStartDateForArrayConstraintsFromSetStartDate($startDate))) {
            throw new \InvalidArgumentException($startDateArrayErrorMessage, __LINE__);
        }
        $this->startDate = $startDate;
        return $this;
    }
    /**
     * Add item to startDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToStartDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The startDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->startDate[] = $item;
        return $this;
    }
    /**
     * Get startTime value
     * @return \StructType\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 $phoneCallSearchRowBasicStartTimeItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicStartTimeItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicStartTimeItem) ? get_class($phoneCallSearchRowBasicStartTimeItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicStartTimeItem), var_export($phoneCallSearchRowBasicStartTimeItem, 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\PhoneCallSearchRowBasic
     */
    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\PhoneCallSearchRowBasic
     */
    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 status value
     * @return \StructType\SearchColumnEnumSelectField[]|null
     */
    public function getStatus()
    {
        return $this->status;
    }
    /**
     * This method is responsible for validating the values passed to the setStatus method
     * This method is willingly generated in order to preserve the one-line inline validation within the setStatus method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateStatusForArrayConstraintsFromSetStatus(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicStatusItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicStatusItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicStatusItem) ? get_class($phoneCallSearchRowBasicStatusItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicStatusItem), var_export($phoneCallSearchRowBasicStatusItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The status property can only contain items of type \StructType\SearchColumnEnumSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set status value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField[] $status
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setStatus(array $status = array())
    {
        // validation for constraint: array
        if ('' !== ($statusArrayErrorMessage = self::validateStatusForArrayConstraintsFromSetStatus($status))) {
            throw new \InvalidArgumentException($statusArrayErrorMessage, __LINE__);
        }
        $this->status = $status;
        return $this;
    }
    /**
     * Add item to status value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToStatus(\StructType\SearchColumnEnumSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnEnumSelectField) {
            throw new \InvalidArgumentException(sprintf('The status property can only contain items of type \StructType\SearchColumnEnumSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->status[] = $item;
        return $this;
    }
    /**
     * Get title value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getTitle()
    {
        return $this->title;
    }
    /**
     * This method is responsible for validating the values passed to the setTitle method
     * This method is willingly generated in order to preserve the one-line inline validation within the setTitle method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateTitleForArrayConstraintsFromSetTitle(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicTitleItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicTitleItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicTitleItem) ? get_class($phoneCallSearchRowBasicTitleItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicTitleItem), var_export($phoneCallSearchRowBasicTitleItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The title property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set title value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $title
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setTitle(array $title = array())
    {
        // validation for constraint: array
        if ('' !== ($titleArrayErrorMessage = self::validateTitleForArrayConstraintsFromSetTitle($title))) {
            throw new \InvalidArgumentException($titleArrayErrorMessage, __LINE__);
        }
        $this->title = $title;
        return $this;
    }
    /**
     * Add item to title value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToTitle(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The title property can only contain items of type \StructType\SearchColumnStringField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->title[] = $item;
        return $this;
    }
    /**
     * Get transaction value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getTransaction()
    {
        return $this->transaction;
    }
    /**
     * This method is responsible for validating the values passed to the setTransaction method
     * This method is willingly generated in order to preserve the one-line inline validation within the setTransaction method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateTransactionForArrayConstraintsFromSetTransaction(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $phoneCallSearchRowBasicTransactionItem) {
            // validation for constraint: itemType
            if (!$phoneCallSearchRowBasicTransactionItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($phoneCallSearchRowBasicTransactionItem) ? get_class($phoneCallSearchRowBasicTransactionItem) : sprintf('%s(%s)', gettype($phoneCallSearchRowBasicTransactionItem), var_export($phoneCallSearchRowBasicTransactionItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The transaction property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set transaction value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $transaction
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setTransaction(array $transaction = array())
    {
        // validation for constraint: array
        if ('' !== ($transactionArrayErrorMessage = self::validateTransactionForArrayConstraintsFromSetTransaction($transaction))) {
            throw new \InvalidArgumentException($transactionArrayErrorMessage, __LINE__);
        }
        $this->transaction = $transaction;
        return $this;
    }
    /**
     * Add item to transaction value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function addToTransaction(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The transaction property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->transaction[] = $item;
        return $this;
    }
    /**
     * Get customFieldList value
     * @return \StructType\SearchColumnCustomFieldList|null
     */
    public function getCustomFieldList()
    {
        return $this->customFieldList;
    }
    /**
     * Set customFieldList value
     * @param \StructType\SearchColumnCustomFieldList $customFieldList
     * @return \StructType\PhoneCallSearchRowBasic
     */
    public function setCustomFieldList(\StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this->customFieldList = $customFieldList;
        return $this;
    }
}
