<?php

namespace StructType;

use \WsdlToPhp\PackageBase\AbstractStructBase;

/**
 * This class stands for SupportCaseSearchRowBasic StructType
 * @subpackage Structs
 */
class SupportCaseSearchRowBasic extends SearchRowBasic
{
    /**
     * The assigned
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $assigned;
    /**
     * The awaitingReply
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $awaitingReply;
    /**
     * The caseNumber
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $caseNumber;
    /**
     * The category
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $category;
    /**
     * The company
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $company;
    /**
     * 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 customerStage
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnEnumSelectField[]
     */
    public $customerStage;
    /**
     * The email
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $email;
    /**
     * The endDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $endDate;
    /**
     * The escalatee
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $escalatee;
    /**
     * The externalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $externalId;
    /**
     * The helpDesk
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $helpDesk;
    /**
     * The inboundEmail
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $inboundEmail;
    /**
     * The internalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $internalId;
    /**
     * The isInactive
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isInactive;
    /**
     * The issue
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $issue;
    /**
     * The issueNumber
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $issueNumber;
    /**
     * The item
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $item;
    /**
     * The lastMessageDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $lastMessageDate;
    /**
     * The lastModifiedDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $lastModifiedDate;
    /**
     * The lastReopenedDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $lastReopenedDate;
    /**
     * The locked
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $locked;
    /**
     * The module
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $module;
    /**
     * The origin
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $origin;
    /**
     * The priority
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $priority;
    /**
     * The product
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $product;
    /**
     * The profile
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $profile;
    /**
     * The serialNumber
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $serialNumber;
    /**
     * The stage
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnEnumSelectField[]
     */
    public $stage;
    /**
     * The startDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $startDate;
    /**
     * The status
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $status;
    /**
     * The subsidiary
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $subsidiary;
    /**
     * The title
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $title;
    /**
     * The customFieldList
     * Meta information extracted from the WSDL
     * - minOccurs: 0
     * @var \StructType\SearchColumnCustomFieldList
     */
    public $customFieldList;
    /**
     * Constructor method for SupportCaseSearchRowBasic
     * @uses SupportCaseSearchRowBasic::setAssigned()
     * @uses SupportCaseSearchRowBasic::setAwaitingReply()
     * @uses SupportCaseSearchRowBasic::setCaseNumber()
     * @uses SupportCaseSearchRowBasic::setCategory()
     * @uses SupportCaseSearchRowBasic::setCompany()
     * @uses SupportCaseSearchRowBasic::setContact()
     * @uses SupportCaseSearchRowBasic::setCreatedDate()
     * @uses SupportCaseSearchRowBasic::setCustomerStage()
     * @uses SupportCaseSearchRowBasic::setEmail()
     * @uses SupportCaseSearchRowBasic::setEndDate()
     * @uses SupportCaseSearchRowBasic::setEscalatee()
     * @uses SupportCaseSearchRowBasic::setExternalId()
     * @uses SupportCaseSearchRowBasic::setHelpDesk()
     * @uses SupportCaseSearchRowBasic::setInboundEmail()
     * @uses SupportCaseSearchRowBasic::setInternalId()
     * @uses SupportCaseSearchRowBasic::setIsInactive()
     * @uses SupportCaseSearchRowBasic::setIssue()
     * @uses SupportCaseSearchRowBasic::setIssueNumber()
     * @uses SupportCaseSearchRowBasic::setItem()
     * @uses SupportCaseSearchRowBasic::setLastMessageDate()
     * @uses SupportCaseSearchRowBasic::setLastModifiedDate()
     * @uses SupportCaseSearchRowBasic::setLastReopenedDate()
     * @uses SupportCaseSearchRowBasic::setLocked()
     * @uses SupportCaseSearchRowBasic::setModule()
     * @uses SupportCaseSearchRowBasic::setOrigin()
     * @uses SupportCaseSearchRowBasic::setPriority()
     * @uses SupportCaseSearchRowBasic::setProduct()
     * @uses SupportCaseSearchRowBasic::setProfile()
     * @uses SupportCaseSearchRowBasic::setSerialNumber()
     * @uses SupportCaseSearchRowBasic::setStage()
     * @uses SupportCaseSearchRowBasic::setStartDate()
     * @uses SupportCaseSearchRowBasic::setStatus()
     * @uses SupportCaseSearchRowBasic::setSubsidiary()
     * @uses SupportCaseSearchRowBasic::setTitle()
     * @uses SupportCaseSearchRowBasic::setCustomFieldList()
     * @param \StructType\SearchColumnSelectField[] $assigned
     * @param \StructType\SearchColumnBooleanField[] $awaitingReply
     * @param \StructType\SearchColumnStringField[] $caseNumber
     * @param \StructType\SearchColumnSelectField[] $category
     * @param \StructType\SearchColumnSelectField[] $company
     * @param \StructType\SearchColumnSelectField[] $contact
     * @param \StructType\SearchColumnDateField[] $createdDate
     * @param \StructType\SearchColumnEnumSelectField[] $customerStage
     * @param \StructType\SearchColumnStringField[] $email
     * @param \StructType\SearchColumnDateField[] $endDate
     * @param \StructType\SearchColumnSelectField[] $escalatee
     * @param \StructType\SearchColumnSelectField[] $externalId
     * @param \StructType\SearchColumnBooleanField[] $helpDesk
     * @param \StructType\SearchColumnStringField[] $inboundEmail
     * @param \StructType\SearchColumnSelectField[] $internalId
     * @param \StructType\SearchColumnBooleanField[] $isInactive
     * @param \StructType\SearchColumnSelectField[] $issue
     * @param \StructType\SearchColumnStringField[] $issueNumber
     * @param \StructType\SearchColumnSelectField[] $item
     * @param \StructType\SearchColumnDateField[] $lastMessageDate
     * @param \StructType\SearchColumnDateField[] $lastModifiedDate
     * @param \StructType\SearchColumnDateField[] $lastReopenedDate
     * @param \StructType\SearchColumnBooleanField[] $locked
     * @param \StructType\SearchColumnSelectField[] $module
     * @param \StructType\SearchColumnSelectField[] $origin
     * @param \StructType\SearchColumnSelectField[] $priority
     * @param \StructType\SearchColumnSelectField[] $product
     * @param \StructType\SearchColumnSelectField[] $profile
     * @param \StructType\SearchColumnStringField[] $serialNumber
     * @param \StructType\SearchColumnEnumSelectField[] $stage
     * @param \StructType\SearchColumnDateField[] $startDate
     * @param \StructType\SearchColumnSelectField[] $status
     * @param \StructType\SearchColumnSelectField[] $subsidiary
     * @param \StructType\SearchColumnStringField[] $title
     * @param \StructType\SearchColumnCustomFieldList $customFieldList
     */
    public function __construct(array $assigned = array(), array $awaitingReply = array(), array $caseNumber = array(), array $category = array(), array $company = array(), array $contact = array(), array $createdDate = array(), array $customerStage = array(), array $email = array(), array $endDate = array(), array $escalatee = array(), array $externalId = array(), array $helpDesk = array(), array $inboundEmail = array(), array $internalId = array(), array $isInactive = array(), array $issue = array(), array $issueNumber = array(), array $item = array(), array $lastMessageDate = array(), array $lastModifiedDate = array(), array $lastReopenedDate = array(), array $locked = array(), array $module = array(), array $origin = array(), array $priority = array(), array $product = array(), array $profile = array(), array $serialNumber = array(), array $stage = array(), array $startDate = array(), array $status = array(), array $subsidiary = array(), array $title = array(), \StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this
            ->setAssigned($assigned)
            ->setAwaitingReply($awaitingReply)
            ->setCaseNumber($caseNumber)
            ->setCategory($category)
            ->setCompany($company)
            ->setContact($contact)
            ->setCreatedDate($createdDate)
            ->setCustomerStage($customerStage)
            ->setEmail($email)
            ->setEndDate($endDate)
            ->setEscalatee($escalatee)
            ->setExternalId($externalId)
            ->setHelpDesk($helpDesk)
            ->setInboundEmail($inboundEmail)
            ->setInternalId($internalId)
            ->setIsInactive($isInactive)
            ->setIssue($issue)
            ->setIssueNumber($issueNumber)
            ->setItem($item)
            ->setLastMessageDate($lastMessageDate)
            ->setLastModifiedDate($lastModifiedDate)
            ->setLastReopenedDate($lastReopenedDate)
            ->setLocked($locked)
            ->setModule($module)
            ->setOrigin($origin)
            ->setPriority($priority)
            ->setProduct($product)
            ->setProfile($profile)
            ->setSerialNumber($serialNumber)
            ->setStage($stage)
            ->setStartDate($startDate)
            ->setStatus($status)
            ->setSubsidiary($subsidiary)
            ->setTitle($title)
            ->setCustomFieldList($customFieldList);
    }
    /**
     * 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 $supportCaseSearchRowBasicAssignedItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicAssignedItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicAssignedItem) ? get_class($supportCaseSearchRowBasicAssignedItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicAssignedItem), var_export($supportCaseSearchRowBasicAssignedItem, 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\SupportCaseSearchRowBasic
     */
    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\SupportCaseSearchRowBasic
     */
    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 awaitingReply value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getAwaitingReply()
    {
        return $this->awaitingReply;
    }
    /**
     * This method is responsible for validating the values passed to the setAwaitingReply method
     * This method is willingly generated in order to preserve the one-line inline validation within the setAwaitingReply method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateAwaitingReplyForArrayConstraintsFromSetAwaitingReply(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicAwaitingReplyItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicAwaitingReplyItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicAwaitingReplyItem) ? get_class($supportCaseSearchRowBasicAwaitingReplyItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicAwaitingReplyItem), var_export($supportCaseSearchRowBasicAwaitingReplyItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The awaitingReply 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 awaitingReply value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $awaitingReply
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setAwaitingReply(array $awaitingReply = array())
    {
        // validation for constraint: array
        if ('' !== ($awaitingReplyArrayErrorMessage = self::validateAwaitingReplyForArrayConstraintsFromSetAwaitingReply($awaitingReply))) {
            throw new \InvalidArgumentException($awaitingReplyArrayErrorMessage, __LINE__);
        }
        $this->awaitingReply = $awaitingReply;
        return $this;
    }
    /**
     * Add item to awaitingReply value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToAwaitingReply(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The awaitingReply 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->awaitingReply[] = $item;
        return $this;
    }
    /**
     * Get caseNumber value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getCaseNumber()
    {
        return $this->caseNumber;
    }
    /**
     * This method is responsible for validating the values passed to the setCaseNumber method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCaseNumber method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCaseNumberForArrayConstraintsFromSetCaseNumber(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicCaseNumberItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicCaseNumberItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicCaseNumberItem) ? get_class($supportCaseSearchRowBasicCaseNumberItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicCaseNumberItem), var_export($supportCaseSearchRowBasicCaseNumberItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The caseNumber 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 caseNumber value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $caseNumber
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setCaseNumber(array $caseNumber = array())
    {
        // validation for constraint: array
        if ('' !== ($caseNumberArrayErrorMessage = self::validateCaseNumberForArrayConstraintsFromSetCaseNumber($caseNumber))) {
            throw new \InvalidArgumentException($caseNumberArrayErrorMessage, __LINE__);
        }
        $this->caseNumber = $caseNumber;
        return $this;
    }
    /**
     * Add item to caseNumber value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToCaseNumber(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The caseNumber 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->caseNumber[] = $item;
        return $this;
    }
    /**
     * Get category value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getCategory()
    {
        return $this->category;
    }
    /**
     * This method is responsible for validating the values passed to the setCategory method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCategory method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCategoryForArrayConstraintsFromSetCategory(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicCategoryItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicCategoryItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicCategoryItem) ? get_class($supportCaseSearchRowBasicCategoryItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicCategoryItem), var_export($supportCaseSearchRowBasicCategoryItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The category 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 category value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $category
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setCategory(array $category = array())
    {
        // validation for constraint: array
        if ('' !== ($categoryArrayErrorMessage = self::validateCategoryForArrayConstraintsFromSetCategory($category))) {
            throw new \InvalidArgumentException($categoryArrayErrorMessage, __LINE__);
        }
        $this->category = $category;
        return $this;
    }
    /**
     * Add item to category value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToCategory(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The category 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->category[] = $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 $supportCaseSearchRowBasicCompanyItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicCompanyItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicCompanyItem) ? get_class($supportCaseSearchRowBasicCompanyItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicCompanyItem), var_export($supportCaseSearchRowBasicCompanyItem, 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\SupportCaseSearchRowBasic
     */
    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\SupportCaseSearchRowBasic
     */
    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 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 $supportCaseSearchRowBasicContactItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicContactItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicContactItem) ? get_class($supportCaseSearchRowBasicContactItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicContactItem), var_export($supportCaseSearchRowBasicContactItem, 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\SupportCaseSearchRowBasic
     */
    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\SupportCaseSearchRowBasic
     */
    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 $supportCaseSearchRowBasicCreatedDateItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicCreatedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicCreatedDateItem) ? get_class($supportCaseSearchRowBasicCreatedDateItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicCreatedDateItem), var_export($supportCaseSearchRowBasicCreatedDateItem, 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\SupportCaseSearchRowBasic
     */
    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\SupportCaseSearchRowBasic
     */
    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 customerStage value
     * @return \StructType\SearchColumnEnumSelectField[]|null
     */
    public function getCustomerStage()
    {
        return $this->customerStage;
    }
    /**
     * This method is responsible for validating the values passed to the setCustomerStage method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCustomerStage method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCustomerStageForArrayConstraintsFromSetCustomerStage(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicCustomerStageItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicCustomerStageItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicCustomerStageItem) ? get_class($supportCaseSearchRowBasicCustomerStageItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicCustomerStageItem), var_export($supportCaseSearchRowBasicCustomerStageItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The customerStage 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 customerStage value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField[] $customerStage
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setCustomerStage(array $customerStage = array())
    {
        // validation for constraint: array
        if ('' !== ($customerStageArrayErrorMessage = self::validateCustomerStageForArrayConstraintsFromSetCustomerStage($customerStage))) {
            throw new \InvalidArgumentException($customerStageArrayErrorMessage, __LINE__);
        }
        $this->customerStage = $customerStage;
        return $this;
    }
    /**
     * Add item to customerStage value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToCustomerStage(\StructType\SearchColumnEnumSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnEnumSelectField) {
            throw new \InvalidArgumentException(sprintf('The customerStage 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->customerStage[] = $item;
        return $this;
    }
    /**
     * Get email value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getEmail()
    {
        return $this->email;
    }
    /**
     * This method is responsible for validating the values passed to the setEmail method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEmail method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEmailForArrayConstraintsFromSetEmail(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicEmailItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicEmailItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicEmailItem) ? get_class($supportCaseSearchRowBasicEmailItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicEmailItem), var_export($supportCaseSearchRowBasicEmailItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The email 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 email value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $email
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setEmail(array $email = array())
    {
        // validation for constraint: array
        if ('' !== ($emailArrayErrorMessage = self::validateEmailForArrayConstraintsFromSetEmail($email))) {
            throw new \InvalidArgumentException($emailArrayErrorMessage, __LINE__);
        }
        $this->email = $email;
        return $this;
    }
    /**
     * Add item to email value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToEmail(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The email 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->email[] = $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 $supportCaseSearchRowBasicEndDateItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicEndDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicEndDateItem) ? get_class($supportCaseSearchRowBasicEndDateItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicEndDateItem), var_export($supportCaseSearchRowBasicEndDateItem, 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\SupportCaseSearchRowBasic
     */
    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\SupportCaseSearchRowBasic
     */
    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 escalatee value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getEscalatee()
    {
        return $this->escalatee;
    }
    /**
     * This method is responsible for validating the values passed to the setEscalatee method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEscalatee method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEscalateeForArrayConstraintsFromSetEscalatee(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicEscalateeItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicEscalateeItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicEscalateeItem) ? get_class($supportCaseSearchRowBasicEscalateeItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicEscalateeItem), var_export($supportCaseSearchRowBasicEscalateeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The escalatee 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 escalatee value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $escalatee
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setEscalatee(array $escalatee = array())
    {
        // validation for constraint: array
        if ('' !== ($escalateeArrayErrorMessage = self::validateEscalateeForArrayConstraintsFromSetEscalatee($escalatee))) {
            throw new \InvalidArgumentException($escalateeArrayErrorMessage, __LINE__);
        }
        $this->escalatee = $escalatee;
        return $this;
    }
    /**
     * Add item to escalatee value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToEscalatee(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The escalatee 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->escalatee[] = $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 $supportCaseSearchRowBasicExternalIdItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicExternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicExternalIdItem) ? get_class($supportCaseSearchRowBasicExternalIdItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicExternalIdItem), var_export($supportCaseSearchRowBasicExternalIdItem, 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\SupportCaseSearchRowBasic
     */
    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\SupportCaseSearchRowBasic
     */
    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 helpDesk value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getHelpDesk()
    {
        return $this->helpDesk;
    }
    /**
     * This method is responsible for validating the values passed to the setHelpDesk method
     * This method is willingly generated in order to preserve the one-line inline validation within the setHelpDesk method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateHelpDeskForArrayConstraintsFromSetHelpDesk(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicHelpDeskItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicHelpDeskItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicHelpDeskItem) ? get_class($supportCaseSearchRowBasicHelpDeskItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicHelpDeskItem), var_export($supportCaseSearchRowBasicHelpDeskItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The helpDesk 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 helpDesk value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $helpDesk
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setHelpDesk(array $helpDesk = array())
    {
        // validation for constraint: array
        if ('' !== ($helpDeskArrayErrorMessage = self::validateHelpDeskForArrayConstraintsFromSetHelpDesk($helpDesk))) {
            throw new \InvalidArgumentException($helpDeskArrayErrorMessage, __LINE__);
        }
        $this->helpDesk = $helpDesk;
        return $this;
    }
    /**
     * Add item to helpDesk value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToHelpDesk(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The helpDesk 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->helpDesk[] = $item;
        return $this;
    }
    /**
     * Get inboundEmail value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getInboundEmail()
    {
        return $this->inboundEmail;
    }
    /**
     * This method is responsible for validating the values passed to the setInboundEmail method
     * This method is willingly generated in order to preserve the one-line inline validation within the setInboundEmail method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateInboundEmailForArrayConstraintsFromSetInboundEmail(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicInboundEmailItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicInboundEmailItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicInboundEmailItem) ? get_class($supportCaseSearchRowBasicInboundEmailItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicInboundEmailItem), var_export($supportCaseSearchRowBasicInboundEmailItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The inboundEmail 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 inboundEmail value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $inboundEmail
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setInboundEmail(array $inboundEmail = array())
    {
        // validation for constraint: array
        if ('' !== ($inboundEmailArrayErrorMessage = self::validateInboundEmailForArrayConstraintsFromSetInboundEmail($inboundEmail))) {
            throw new \InvalidArgumentException($inboundEmailArrayErrorMessage, __LINE__);
        }
        $this->inboundEmail = $inboundEmail;
        return $this;
    }
    /**
     * Add item to inboundEmail value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToInboundEmail(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The inboundEmail 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->inboundEmail[] = $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 $supportCaseSearchRowBasicInternalIdItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicInternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicInternalIdItem) ? get_class($supportCaseSearchRowBasicInternalIdItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicInternalIdItem), var_export($supportCaseSearchRowBasicInternalIdItem, 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\SupportCaseSearchRowBasic
     */
    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\SupportCaseSearchRowBasic
     */
    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 isInactive value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsInactive()
    {
        return $this->isInactive;
    }
    /**
     * This method is responsible for validating the values passed to the setIsInactive method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsInactive method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsInactiveForArrayConstraintsFromSetIsInactive(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicIsInactiveItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicIsInactiveItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicIsInactiveItem) ? get_class($supportCaseSearchRowBasicIsInactiveItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicIsInactiveItem), var_export($supportCaseSearchRowBasicIsInactiveItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isInactive property can only contain items of type \StructType\SearchColumnBooleanField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set isInactive value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isInactive
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setIsInactive(array $isInactive = array())
    {
        // validation for constraint: array
        if ('' !== ($isInactiveArrayErrorMessage = self::validateIsInactiveForArrayConstraintsFromSetIsInactive($isInactive))) {
            throw new \InvalidArgumentException($isInactiveArrayErrorMessage, __LINE__);
        }
        $this->isInactive = $isInactive;
        return $this;
    }
    /**
     * Add item to isInactive value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToIsInactive(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isInactive property can only contain items of type \StructType\SearchColumnBooleanField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->isInactive[] = $item;
        return $this;
    }
    /**
     * Get issue value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getIssue()
    {
        return $this->issue;
    }
    /**
     * This method is responsible for validating the values passed to the setIssue method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIssue method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIssueForArrayConstraintsFromSetIssue(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicIssueItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicIssueItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicIssueItem) ? get_class($supportCaseSearchRowBasicIssueItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicIssueItem), var_export($supportCaseSearchRowBasicIssueItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The issue 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 issue value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $issue
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setIssue(array $issue = array())
    {
        // validation for constraint: array
        if ('' !== ($issueArrayErrorMessage = self::validateIssueForArrayConstraintsFromSetIssue($issue))) {
            throw new \InvalidArgumentException($issueArrayErrorMessage, __LINE__);
        }
        $this->issue = $issue;
        return $this;
    }
    /**
     * Add item to issue value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToIssue(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The issue 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->issue[] = $item;
        return $this;
    }
    /**
     * Get issueNumber value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getIssueNumber()
    {
        return $this->issueNumber;
    }
    /**
     * This method is responsible for validating the values passed to the setIssueNumber method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIssueNumber method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIssueNumberForArrayConstraintsFromSetIssueNumber(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicIssueNumberItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicIssueNumberItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicIssueNumberItem) ? get_class($supportCaseSearchRowBasicIssueNumberItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicIssueNumberItem), var_export($supportCaseSearchRowBasicIssueNumberItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The issueNumber 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 issueNumber value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $issueNumber
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setIssueNumber(array $issueNumber = array())
    {
        // validation for constraint: array
        if ('' !== ($issueNumberArrayErrorMessage = self::validateIssueNumberForArrayConstraintsFromSetIssueNumber($issueNumber))) {
            throw new \InvalidArgumentException($issueNumberArrayErrorMessage, __LINE__);
        }
        $this->issueNumber = $issueNumber;
        return $this;
    }
    /**
     * Add item to issueNumber value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToIssueNumber(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The issueNumber 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->issueNumber[] = $item;
        return $this;
    }
    /**
     * Get item value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getItem()
    {
        return $this->item;
    }
    /**
     * This method is responsible for validating the values passed to the setItem method
     * This method is willingly generated in order to preserve the one-line inline validation within the setItem method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateItemForArrayConstraintsFromSetItem(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicItemItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicItemItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicItemItem) ? get_class($supportCaseSearchRowBasicItemItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicItemItem), var_export($supportCaseSearchRowBasicItemItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The item property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set item value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setItem(array $item = array())
    {
        // validation for constraint: array
        if ('' !== ($itemArrayErrorMessage = self::validateItemForArrayConstraintsFromSetItem($item))) {
            throw new \InvalidArgumentException($itemArrayErrorMessage, __LINE__);
        }
        $this->item = $item;
        return $this;
    }
    /**
     * Add item to item value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToItem(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The item property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->item[] = $item;
        return $this;
    }
    /**
     * Get lastMessageDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getLastMessageDate()
    {
        return $this->lastMessageDate;
    }
    /**
     * This method is responsible for validating the values passed to the setLastMessageDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLastMessageDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLastMessageDateForArrayConstraintsFromSetLastMessageDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicLastMessageDateItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicLastMessageDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicLastMessageDateItem) ? get_class($supportCaseSearchRowBasicLastMessageDateItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicLastMessageDateItem), var_export($supportCaseSearchRowBasicLastMessageDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The lastMessageDate 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 lastMessageDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $lastMessageDate
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setLastMessageDate(array $lastMessageDate = array())
    {
        // validation for constraint: array
        if ('' !== ($lastMessageDateArrayErrorMessage = self::validateLastMessageDateForArrayConstraintsFromSetLastMessageDate($lastMessageDate))) {
            throw new \InvalidArgumentException($lastMessageDateArrayErrorMessage, __LINE__);
        }
        $this->lastMessageDate = $lastMessageDate;
        return $this;
    }
    /**
     * Add item to lastMessageDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToLastMessageDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The lastMessageDate 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->lastMessageDate[] = $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 $supportCaseSearchRowBasicLastModifiedDateItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicLastModifiedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicLastModifiedDateItem) ? get_class($supportCaseSearchRowBasicLastModifiedDateItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicLastModifiedDateItem), var_export($supportCaseSearchRowBasicLastModifiedDateItem, 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\SupportCaseSearchRowBasic
     */
    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\SupportCaseSearchRowBasic
     */
    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 lastReopenedDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getLastReopenedDate()
    {
        return $this->lastReopenedDate;
    }
    /**
     * This method is responsible for validating the values passed to the setLastReopenedDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLastReopenedDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLastReopenedDateForArrayConstraintsFromSetLastReopenedDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicLastReopenedDateItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicLastReopenedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicLastReopenedDateItem) ? get_class($supportCaseSearchRowBasicLastReopenedDateItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicLastReopenedDateItem), var_export($supportCaseSearchRowBasicLastReopenedDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The lastReopenedDate 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 lastReopenedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $lastReopenedDate
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setLastReopenedDate(array $lastReopenedDate = array())
    {
        // validation for constraint: array
        if ('' !== ($lastReopenedDateArrayErrorMessage = self::validateLastReopenedDateForArrayConstraintsFromSetLastReopenedDate($lastReopenedDate))) {
            throw new \InvalidArgumentException($lastReopenedDateArrayErrorMessage, __LINE__);
        }
        $this->lastReopenedDate = $lastReopenedDate;
        return $this;
    }
    /**
     * Add item to lastReopenedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToLastReopenedDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The lastReopenedDate 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->lastReopenedDate[] = $item;
        return $this;
    }
    /**
     * Get locked value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getLocked()
    {
        return $this->locked;
    }
    /**
     * This method is responsible for validating the values passed to the setLocked method
     * This method is willingly generated in order to preserve the one-line inline validation within the setLocked method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateLockedForArrayConstraintsFromSetLocked(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicLockedItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicLockedItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicLockedItem) ? get_class($supportCaseSearchRowBasicLockedItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicLockedItem), var_export($supportCaseSearchRowBasicLockedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The locked 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 locked value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $locked
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setLocked(array $locked = array())
    {
        // validation for constraint: array
        if ('' !== ($lockedArrayErrorMessage = self::validateLockedForArrayConstraintsFromSetLocked($locked))) {
            throw new \InvalidArgumentException($lockedArrayErrorMessage, __LINE__);
        }
        $this->locked = $locked;
        return $this;
    }
    /**
     * Add item to locked value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToLocked(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The locked 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->locked[] = $item;
        return $this;
    }
    /**
     * Get module value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getModule()
    {
        return $this->module;
    }
    /**
     * This method is responsible for validating the values passed to the setModule method
     * This method is willingly generated in order to preserve the one-line inline validation within the setModule method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateModuleForArrayConstraintsFromSetModule(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicModuleItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicModuleItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicModuleItem) ? get_class($supportCaseSearchRowBasicModuleItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicModuleItem), var_export($supportCaseSearchRowBasicModuleItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The module 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 module value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $module
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setModule(array $module = array())
    {
        // validation for constraint: array
        if ('' !== ($moduleArrayErrorMessage = self::validateModuleForArrayConstraintsFromSetModule($module))) {
            throw new \InvalidArgumentException($moduleArrayErrorMessage, __LINE__);
        }
        $this->module = $module;
        return $this;
    }
    /**
     * Add item to module value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToModule(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The module 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->module[] = $item;
        return $this;
    }
    /**
     * Get origin value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getOrigin()
    {
        return $this->origin;
    }
    /**
     * This method is responsible for validating the values passed to the setOrigin method
     * This method is willingly generated in order to preserve the one-line inline validation within the setOrigin method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateOriginForArrayConstraintsFromSetOrigin(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicOriginItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicOriginItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicOriginItem) ? get_class($supportCaseSearchRowBasicOriginItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicOriginItem), var_export($supportCaseSearchRowBasicOriginItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The origin 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 origin value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $origin
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setOrigin(array $origin = array())
    {
        // validation for constraint: array
        if ('' !== ($originArrayErrorMessage = self::validateOriginForArrayConstraintsFromSetOrigin($origin))) {
            throw new \InvalidArgumentException($originArrayErrorMessage, __LINE__);
        }
        $this->origin = $origin;
        return $this;
    }
    /**
     * Add item to origin value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToOrigin(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The origin 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->origin[] = $item;
        return $this;
    }
    /**
     * Get priority value
     * @return \StructType\SearchColumnSelectField[]|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 $supportCaseSearchRowBasicPriorityItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicPriorityItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicPriorityItem) ? get_class($supportCaseSearchRowBasicPriorityItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicPriorityItem), var_export($supportCaseSearchRowBasicPriorityItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The priority 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 priority value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $priority
     * @return \StructType\SupportCaseSearchRowBasic
     */
    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\SearchColumnSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToPriority(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The priority 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->priority[] = $item;
        return $this;
    }
    /**
     * Get product value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getProduct()
    {
        return $this->product;
    }
    /**
     * This method is responsible for validating the values passed to the setProduct method
     * This method is willingly generated in order to preserve the one-line inline validation within the setProduct method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateProductForArrayConstraintsFromSetProduct(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicProductItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicProductItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicProductItem) ? get_class($supportCaseSearchRowBasicProductItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicProductItem), var_export($supportCaseSearchRowBasicProductItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The product 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 product value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $product
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setProduct(array $product = array())
    {
        // validation for constraint: array
        if ('' !== ($productArrayErrorMessage = self::validateProductForArrayConstraintsFromSetProduct($product))) {
            throw new \InvalidArgumentException($productArrayErrorMessage, __LINE__);
        }
        $this->product = $product;
        return $this;
    }
    /**
     * Add item to product value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToProduct(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The product 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->product[] = $item;
        return $this;
    }
    /**
     * Get profile value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getProfile()
    {
        return $this->profile;
    }
    /**
     * This method is responsible for validating the values passed to the setProfile method
     * This method is willingly generated in order to preserve the one-line inline validation within the setProfile method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateProfileForArrayConstraintsFromSetProfile(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicProfileItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicProfileItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicProfileItem) ? get_class($supportCaseSearchRowBasicProfileItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicProfileItem), var_export($supportCaseSearchRowBasicProfileItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The profile 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 profile value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $profile
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setProfile(array $profile = array())
    {
        // validation for constraint: array
        if ('' !== ($profileArrayErrorMessage = self::validateProfileForArrayConstraintsFromSetProfile($profile))) {
            throw new \InvalidArgumentException($profileArrayErrorMessage, __LINE__);
        }
        $this->profile = $profile;
        return $this;
    }
    /**
     * Add item to profile value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToProfile(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The profile 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->profile[] = $item;
        return $this;
    }
    /**
     * Get serialNumber value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getSerialNumber()
    {
        return $this->serialNumber;
    }
    /**
     * This method is responsible for validating the values passed to the setSerialNumber method
     * This method is willingly generated in order to preserve the one-line inline validation within the setSerialNumber method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateSerialNumberForArrayConstraintsFromSetSerialNumber(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicSerialNumberItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicSerialNumberItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicSerialNumberItem) ? get_class($supportCaseSearchRowBasicSerialNumberItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicSerialNumberItem), var_export($supportCaseSearchRowBasicSerialNumberItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The serialNumber 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 serialNumber value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $serialNumber
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setSerialNumber(array $serialNumber = array())
    {
        // validation for constraint: array
        if ('' !== ($serialNumberArrayErrorMessage = self::validateSerialNumberForArrayConstraintsFromSetSerialNumber($serialNumber))) {
            throw new \InvalidArgumentException($serialNumberArrayErrorMessage, __LINE__);
        }
        $this->serialNumber = $serialNumber;
        return $this;
    }
    /**
     * Add item to serialNumber value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToSerialNumber(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The serialNumber 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->serialNumber[] = $item;
        return $this;
    }
    /**
     * Get stage value
     * @return \StructType\SearchColumnEnumSelectField[]|null
     */
    public function getStage()
    {
        return $this->stage;
    }
    /**
     * This method is responsible for validating the values passed to the setStage method
     * This method is willingly generated in order to preserve the one-line inline validation within the setStage method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateStageForArrayConstraintsFromSetStage(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicStageItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicStageItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicStageItem) ? get_class($supportCaseSearchRowBasicStageItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicStageItem), var_export($supportCaseSearchRowBasicStageItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The stage 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 stage value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField[] $stage
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setStage(array $stage = array())
    {
        // validation for constraint: array
        if ('' !== ($stageArrayErrorMessage = self::validateStageForArrayConstraintsFromSetStage($stage))) {
            throw new \InvalidArgumentException($stageArrayErrorMessage, __LINE__);
        }
        $this->stage = $stage;
        return $this;
    }
    /**
     * Add item to stage value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToStage(\StructType\SearchColumnEnumSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnEnumSelectField) {
            throw new \InvalidArgumentException(sprintf('The stage 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->stage[] = $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 $supportCaseSearchRowBasicStartDateItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicStartDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicStartDateItem) ? get_class($supportCaseSearchRowBasicStartDateItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicStartDateItem), var_export($supportCaseSearchRowBasicStartDateItem, 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\SupportCaseSearchRowBasic
     */
    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\SupportCaseSearchRowBasic
     */
    public function addToStartDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The startDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->startDate[] = $item;
        return $this;
    }
    /**
     * Get status value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getStatus()
    {
        return $this->status;
    }
    /**
     * This method is responsible for validating the values passed to the setStatus method
     * This method is willingly generated in order to preserve the one-line inline validation within the setStatus method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateStatusForArrayConstraintsFromSetStatus(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicStatusItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicStatusItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicStatusItem) ? get_class($supportCaseSearchRowBasicStatusItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicStatusItem), var_export($supportCaseSearchRowBasicStatusItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The status property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set status value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $status
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setStatus(array $status = array())
    {
        // validation for constraint: array
        if ('' !== ($statusArrayErrorMessage = self::validateStatusForArrayConstraintsFromSetStatus($status))) {
            throw new \InvalidArgumentException($statusArrayErrorMessage, __LINE__);
        }
        $this->status = $status;
        return $this;
    }
    /**
     * Add item to status value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToStatus(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The status property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->status[] = $item;
        return $this;
    }
    /**
     * Get subsidiary value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getSubsidiary()
    {
        return $this->subsidiary;
    }
    /**
     * This method is responsible for validating the values passed to the setSubsidiary method
     * This method is willingly generated in order to preserve the one-line inline validation within the setSubsidiary method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateSubsidiaryForArrayConstraintsFromSetSubsidiary(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $supportCaseSearchRowBasicSubsidiaryItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicSubsidiaryItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicSubsidiaryItem) ? get_class($supportCaseSearchRowBasicSubsidiaryItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicSubsidiaryItem), var_export($supportCaseSearchRowBasicSubsidiaryItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The subsidiary property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set subsidiary value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $subsidiary
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setSubsidiary(array $subsidiary = array())
    {
        // validation for constraint: array
        if ('' !== ($subsidiaryArrayErrorMessage = self::validateSubsidiaryForArrayConstraintsFromSetSubsidiary($subsidiary))) {
            throw new \InvalidArgumentException($subsidiaryArrayErrorMessage, __LINE__);
        }
        $this->subsidiary = $subsidiary;
        return $this;
    }
    /**
     * Add item to subsidiary value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function addToSubsidiary(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The subsidiary property can only contain items of type \StructType\SearchColumnSelectField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->subsidiary[] = $item;
        return $this;
    }
    /**
     * Get 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 $supportCaseSearchRowBasicTitleItem) {
            // validation for constraint: itemType
            if (!$supportCaseSearchRowBasicTitleItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($supportCaseSearchRowBasicTitleItem) ? get_class($supportCaseSearchRowBasicTitleItem) : sprintf('%s(%s)', gettype($supportCaseSearchRowBasicTitleItem), var_export($supportCaseSearchRowBasicTitleItem, 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\SupportCaseSearchRowBasic
     */
    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\SupportCaseSearchRowBasic
     */
    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 customFieldList value
     * @return \StructType\SearchColumnCustomFieldList|null
     */
    public function getCustomFieldList()
    {
        return $this->customFieldList;
    }
    /**
     * Set customFieldList value
     * @param \StructType\SearchColumnCustomFieldList $customFieldList
     * @return \StructType\SupportCaseSearchRowBasic
     */
    public function setCustomFieldList(\StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this->customFieldList = $customFieldList;
        return $this;
    }
}
