<?php

namespace StructType;

use \WsdlToPhp\PackageBase\AbstractStructBase;

/**
 * This class stands for IssueSearchRowBasic StructType
 * @subpackage Structs
 */
class IssueSearchRowBasic extends SearchRowBasic
{
    /**
     * The ageInMonths
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnLongField[]
     */
    public $ageInMonths;
    /**
     * The assigned
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $assigned;
    /**
     * The buildBroken
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $buildBroken;
    /**
     * The buildFixed
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $buildFixed;
    /**
     * The buildTarget
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $buildTarget;
    /**
     * The caseCount
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnLongField[]
     */
    public $caseCount;
    /**
     * The caseNumber
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $caseNumber;
    /**
     * The closedDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $closedDate;
    /**
     * The createdDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $createdDate;
    /**
     * The dateReleased
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $dateReleased;
    /**
     * The duplicateOf
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $duplicateOf;
    /**
     * The employeeOrTeam
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $employeeOrTeam;
    /**
     * The eventStatus
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnEnumSelectField[]
     */
    public $eventStatus;
    /**
     * The externalAbstract
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $externalAbstract;
    /**
     * The externalDetails
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $externalDetails;
    /**
     * The externalFixedIn
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $externalFixedIn;
    /**
     * The externalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $externalId;
    /**
     * The externalStatus
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $externalStatus;
    /**
     * The fixed
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $fixed;
    /**
     * The fixedBy
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $fixedBy;
    /**
     * The internalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $internalId;
    /**
     * The isOwner
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isOwner;
    /**
     * The isReviewed
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isReviewed;
    /**
     * The isShowStopper
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isShowStopper;
    /**
     * The issueAbstract
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $issueAbstract;
    /**
     * The issueStatus
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $issueStatus;
    /**
     * The item
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $item;
    /**
     * The lastModifiedDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $lastModifiedDate;
    /**
     * The module
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $module;
    /**
     * The number
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $number;
    /**
     * The originalFixedIn
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $originalFixedIn;
    /**
     * 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 productTeam
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $productTeam;
    /**
     * The relatedIssue
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $relatedIssue;
    /**
     * The relationship
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnEnumSelectField[]
     */
    public $relationship;
    /**
     * The relationshipComment
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $relationshipComment;
    /**
     * The reportedBy
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $reportedBy;
    /**
     * The reproduce
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $reproduce;
    /**
     * The resolved
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $resolved;
    /**
     * The resolvedBy
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $resolvedBy;
    /**
     * The reviewer
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $reviewer;
    /**
     * The severity
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $severity;
    /**
     * The source
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnEnumSelectField[]
     */
    public $source;
    /**
     * The tags
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $tags;
    /**
     * The type
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $type;
    /**
     * The userType
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $userType;
    /**
     * The versionBroken
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $versionBroken;
    /**
     * The versionFixed
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $versionFixed;
    /**
     * The versionTarget
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $versionTarget;
    /**
     * The customFieldList
     * Meta information extracted from the WSDL
     * - minOccurs: 0
     * @var \StructType\SearchColumnCustomFieldList
     */
    public $customFieldList;
    /**
     * Constructor method for IssueSearchRowBasic
     * @uses IssueSearchRowBasic::setAgeInMonths()
     * @uses IssueSearchRowBasic::setAssigned()
     * @uses IssueSearchRowBasic::setBuildBroken()
     * @uses IssueSearchRowBasic::setBuildFixed()
     * @uses IssueSearchRowBasic::setBuildTarget()
     * @uses IssueSearchRowBasic::setCaseCount()
     * @uses IssueSearchRowBasic::setCaseNumber()
     * @uses IssueSearchRowBasic::setClosedDate()
     * @uses IssueSearchRowBasic::setCreatedDate()
     * @uses IssueSearchRowBasic::setDateReleased()
     * @uses IssueSearchRowBasic::setDuplicateOf()
     * @uses IssueSearchRowBasic::setEmployeeOrTeam()
     * @uses IssueSearchRowBasic::setEventStatus()
     * @uses IssueSearchRowBasic::setExternalAbstract()
     * @uses IssueSearchRowBasic::setExternalDetails()
     * @uses IssueSearchRowBasic::setExternalFixedIn()
     * @uses IssueSearchRowBasic::setExternalId()
     * @uses IssueSearchRowBasic::setExternalStatus()
     * @uses IssueSearchRowBasic::setFixed()
     * @uses IssueSearchRowBasic::setFixedBy()
     * @uses IssueSearchRowBasic::setInternalId()
     * @uses IssueSearchRowBasic::setIsOwner()
     * @uses IssueSearchRowBasic::setIsReviewed()
     * @uses IssueSearchRowBasic::setIsShowStopper()
     * @uses IssueSearchRowBasic::setIssueAbstract()
     * @uses IssueSearchRowBasic::setIssueStatus()
     * @uses IssueSearchRowBasic::setItem()
     * @uses IssueSearchRowBasic::setLastModifiedDate()
     * @uses IssueSearchRowBasic::setModule()
     * @uses IssueSearchRowBasic::setNumber()
     * @uses IssueSearchRowBasic::setOriginalFixedIn()
     * @uses IssueSearchRowBasic::setPriority()
     * @uses IssueSearchRowBasic::setProduct()
     * @uses IssueSearchRowBasic::setProductTeam()
     * @uses IssueSearchRowBasic::setRelatedIssue()
     * @uses IssueSearchRowBasic::setRelationship()
     * @uses IssueSearchRowBasic::setRelationshipComment()
     * @uses IssueSearchRowBasic::setReportedBy()
     * @uses IssueSearchRowBasic::setReproduce()
     * @uses IssueSearchRowBasic::setResolved()
     * @uses IssueSearchRowBasic::setResolvedBy()
     * @uses IssueSearchRowBasic::setReviewer()
     * @uses IssueSearchRowBasic::setSeverity()
     * @uses IssueSearchRowBasic::setSource()
     * @uses IssueSearchRowBasic::setTags()
     * @uses IssueSearchRowBasic::setType()
     * @uses IssueSearchRowBasic::setUserType()
     * @uses IssueSearchRowBasic::setVersionBroken()
     * @uses IssueSearchRowBasic::setVersionFixed()
     * @uses IssueSearchRowBasic::setVersionTarget()
     * @uses IssueSearchRowBasic::setCustomFieldList()
     * @param \StructType\SearchColumnLongField[] $ageInMonths
     * @param \StructType\SearchColumnSelectField[] $assigned
     * @param \StructType\SearchColumnSelectField[] $buildBroken
     * @param \StructType\SearchColumnSelectField[] $buildFixed
     * @param \StructType\SearchColumnSelectField[] $buildTarget
     * @param \StructType\SearchColumnLongField[] $caseCount
     * @param \StructType\SearchColumnStringField[] $caseNumber
     * @param \StructType\SearchColumnDateField[] $closedDate
     * @param \StructType\SearchColumnDateField[] $createdDate
     * @param \StructType\SearchColumnDateField[] $dateReleased
     * @param \StructType\SearchColumnSelectField[] $duplicateOf
     * @param \StructType\SearchColumnSelectField[] $employeeOrTeam
     * @param \StructType\SearchColumnEnumSelectField[] $eventStatus
     * @param \StructType\SearchColumnStringField[] $externalAbstract
     * @param \StructType\SearchColumnStringField[] $externalDetails
     * @param \StructType\SearchColumnStringField[] $externalFixedIn
     * @param \StructType\SearchColumnSelectField[] $externalId
     * @param \StructType\SearchColumnSelectField[] $externalStatus
     * @param \StructType\SearchColumnDateField[] $fixed
     * @param \StructType\SearchColumnSelectField[] $fixedBy
     * @param \StructType\SearchColumnSelectField[] $internalId
     * @param \StructType\SearchColumnBooleanField[] $isOwner
     * @param \StructType\SearchColumnBooleanField[] $isReviewed
     * @param \StructType\SearchColumnBooleanField[] $isShowStopper
     * @param \StructType\SearchColumnStringField[] $issueAbstract
     * @param \StructType\SearchColumnSelectField[] $issueStatus
     * @param \StructType\SearchColumnSelectField[] $item
     * @param \StructType\SearchColumnDateField[] $lastModifiedDate
     * @param \StructType\SearchColumnStringField[] $module
     * @param \StructType\SearchColumnStringField[] $number
     * @param \StructType\SearchColumnStringField[] $originalFixedIn
     * @param \StructType\SearchColumnSelectField[] $priority
     * @param \StructType\SearchColumnSelectField[] $product
     * @param \StructType\SearchColumnSelectField[] $productTeam
     * @param \StructType\SearchColumnSelectField[] $relatedIssue
     * @param \StructType\SearchColumnEnumSelectField[] $relationship
     * @param \StructType\SearchColumnStringField[] $relationshipComment
     * @param \StructType\SearchColumnSelectField[] $reportedBy
     * @param \StructType\SearchColumnSelectField[] $reproduce
     * @param \StructType\SearchColumnDateField[] $resolved
     * @param \StructType\SearchColumnSelectField[] $resolvedBy
     * @param \StructType\SearchColumnSelectField[] $reviewer
     * @param \StructType\SearchColumnSelectField[] $severity
     * @param \StructType\SearchColumnEnumSelectField[] $source
     * @param \StructType\SearchColumnSelectField[] $tags
     * @param \StructType\SearchColumnStringField[] $type
     * @param \StructType\SearchColumnSelectField[] $userType
     * @param \StructType\SearchColumnSelectField[] $versionBroken
     * @param \StructType\SearchColumnSelectField[] $versionFixed
     * @param \StructType\SearchColumnSelectField[] $versionTarget
     * @param \StructType\SearchColumnCustomFieldList $customFieldList
     */
    public function __construct(array $ageInMonths = array(), array $assigned = array(), array $buildBroken = array(), array $buildFixed = array(), array $buildTarget = array(), array $caseCount = array(), array $caseNumber = array(), array $closedDate = array(), array $createdDate = array(), array $dateReleased = array(), array $duplicateOf = array(), array $employeeOrTeam = array(), array $eventStatus = array(), array $externalAbstract = array(), array $externalDetails = array(), array $externalFixedIn = array(), array $externalId = array(), array $externalStatus = array(), array $fixed = array(), array $fixedBy = array(), array $internalId = array(), array $isOwner = array(), array $isReviewed = array(), array $isShowStopper = array(), array $issueAbstract = array(), array $issueStatus = array(), array $item = array(), array $lastModifiedDate = array(), array $module = array(), array $number = array(), array $originalFixedIn = array(), array $priority = array(), array $product = array(), array $productTeam = array(), array $relatedIssue = array(), array $relationship = array(), array $relationshipComment = array(), array $reportedBy = array(), array $reproduce = array(), array $resolved = array(), array $resolvedBy = array(), array $reviewer = array(), array $severity = array(), array $source = array(), array $tags = array(), array $type = array(), array $userType = array(), array $versionBroken = array(), array $versionFixed = array(), array $versionTarget = array(), \StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this
            ->setAgeInMonths($ageInMonths)
            ->setAssigned($assigned)
            ->setBuildBroken($buildBroken)
            ->setBuildFixed($buildFixed)
            ->setBuildTarget($buildTarget)
            ->setCaseCount($caseCount)
            ->setCaseNumber($caseNumber)
            ->setClosedDate($closedDate)
            ->setCreatedDate($createdDate)
            ->setDateReleased($dateReleased)
            ->setDuplicateOf($duplicateOf)
            ->setEmployeeOrTeam($employeeOrTeam)
            ->setEventStatus($eventStatus)
            ->setExternalAbstract($externalAbstract)
            ->setExternalDetails($externalDetails)
            ->setExternalFixedIn($externalFixedIn)
            ->setExternalId($externalId)
            ->setExternalStatus($externalStatus)
            ->setFixed($fixed)
            ->setFixedBy($fixedBy)
            ->setInternalId($internalId)
            ->setIsOwner($isOwner)
            ->setIsReviewed($isReviewed)
            ->setIsShowStopper($isShowStopper)
            ->setIssueAbstract($issueAbstract)
            ->setIssueStatus($issueStatus)
            ->setItem($item)
            ->setLastModifiedDate($lastModifiedDate)
            ->setModule($module)
            ->setNumber($number)
            ->setOriginalFixedIn($originalFixedIn)
            ->setPriority($priority)
            ->setProduct($product)
            ->setProductTeam($productTeam)
            ->setRelatedIssue($relatedIssue)
            ->setRelationship($relationship)
            ->setRelationshipComment($relationshipComment)
            ->setReportedBy($reportedBy)
            ->setReproduce($reproduce)
            ->setResolved($resolved)
            ->setResolvedBy($resolvedBy)
            ->setReviewer($reviewer)
            ->setSeverity($severity)
            ->setSource($source)
            ->setTags($tags)
            ->setType($type)
            ->setUserType($userType)
            ->setVersionBroken($versionBroken)
            ->setVersionFixed($versionFixed)
            ->setVersionTarget($versionTarget)
            ->setCustomFieldList($customFieldList);
    }
    /**
     * Get ageInMonths value
     * @return \StructType\SearchColumnLongField[]|null
     */
    public function getAgeInMonths()
    {
        return $this->ageInMonths;
    }
    /**
     * This method is responsible for validating the values passed to the setAgeInMonths method
     * This method is willingly generated in order to preserve the one-line inline validation within the setAgeInMonths method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateAgeInMonthsForArrayConstraintsFromSetAgeInMonths(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicAgeInMonthsItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicAgeInMonthsItem instanceof \StructType\SearchColumnLongField) {
                $invalidValues[] = is_object($issueSearchRowBasicAgeInMonthsItem) ? get_class($issueSearchRowBasicAgeInMonthsItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicAgeInMonthsItem), var_export($issueSearchRowBasicAgeInMonthsItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The ageInMonths property can only contain items of type \StructType\SearchColumnLongField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set ageInMonths value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnLongField[] $ageInMonths
     * @return \StructType\IssueSearchRowBasic
     */
    public function setAgeInMonths(array $ageInMonths = array())
    {
        // validation for constraint: array
        if ('' !== ($ageInMonthsArrayErrorMessage = self::validateAgeInMonthsForArrayConstraintsFromSetAgeInMonths($ageInMonths))) {
            throw new \InvalidArgumentException($ageInMonthsArrayErrorMessage, __LINE__);
        }
        $this->ageInMonths = $ageInMonths;
        return $this;
    }
    /**
     * Add item to ageInMonths value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnLongField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToAgeInMonths(\StructType\SearchColumnLongField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnLongField) {
            throw new \InvalidArgumentException(sprintf('The ageInMonths property can only contain items of type \StructType\SearchColumnLongField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->ageInMonths[] = $item;
        return $this;
    }
    /**
     * Get assigned value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getAssigned()
    {
        return $this->assigned;
    }
    /**
     * This method is responsible for validating the values passed to the setAssigned method
     * This method is willingly generated in order to preserve the one-line inline validation within the setAssigned method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateAssignedForArrayConstraintsFromSetAssigned(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicAssignedItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicAssignedItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicAssignedItem) ? get_class($issueSearchRowBasicAssignedItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicAssignedItem), var_export($issueSearchRowBasicAssignedItem, 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\IssueSearchRowBasic
     */
    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\IssueSearchRowBasic
     */
    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 buildBroken value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getBuildBroken()
    {
        return $this->buildBroken;
    }
    /**
     * This method is responsible for validating the values passed to the setBuildBroken method
     * This method is willingly generated in order to preserve the one-line inline validation within the setBuildBroken method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateBuildBrokenForArrayConstraintsFromSetBuildBroken(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicBuildBrokenItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicBuildBrokenItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicBuildBrokenItem) ? get_class($issueSearchRowBasicBuildBrokenItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicBuildBrokenItem), var_export($issueSearchRowBasicBuildBrokenItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The buildBroken 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 buildBroken value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $buildBroken
     * @return \StructType\IssueSearchRowBasic
     */
    public function setBuildBroken(array $buildBroken = array())
    {
        // validation for constraint: array
        if ('' !== ($buildBrokenArrayErrorMessage = self::validateBuildBrokenForArrayConstraintsFromSetBuildBroken($buildBroken))) {
            throw new \InvalidArgumentException($buildBrokenArrayErrorMessage, __LINE__);
        }
        $this->buildBroken = $buildBroken;
        return $this;
    }
    /**
     * Add item to buildBroken value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToBuildBroken(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The buildBroken 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->buildBroken[] = $item;
        return $this;
    }
    /**
     * Get buildFixed value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getBuildFixed()
    {
        return $this->buildFixed;
    }
    /**
     * This method is responsible for validating the values passed to the setBuildFixed method
     * This method is willingly generated in order to preserve the one-line inline validation within the setBuildFixed method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateBuildFixedForArrayConstraintsFromSetBuildFixed(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicBuildFixedItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicBuildFixedItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicBuildFixedItem) ? get_class($issueSearchRowBasicBuildFixedItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicBuildFixedItem), var_export($issueSearchRowBasicBuildFixedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The buildFixed 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 buildFixed value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $buildFixed
     * @return \StructType\IssueSearchRowBasic
     */
    public function setBuildFixed(array $buildFixed = array())
    {
        // validation for constraint: array
        if ('' !== ($buildFixedArrayErrorMessage = self::validateBuildFixedForArrayConstraintsFromSetBuildFixed($buildFixed))) {
            throw new \InvalidArgumentException($buildFixedArrayErrorMessage, __LINE__);
        }
        $this->buildFixed = $buildFixed;
        return $this;
    }
    /**
     * Add item to buildFixed value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToBuildFixed(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The buildFixed 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->buildFixed[] = $item;
        return $this;
    }
    /**
     * Get buildTarget value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getBuildTarget()
    {
        return $this->buildTarget;
    }
    /**
     * This method is responsible for validating the values passed to the setBuildTarget method
     * This method is willingly generated in order to preserve the one-line inline validation within the setBuildTarget method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateBuildTargetForArrayConstraintsFromSetBuildTarget(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicBuildTargetItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicBuildTargetItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicBuildTargetItem) ? get_class($issueSearchRowBasicBuildTargetItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicBuildTargetItem), var_export($issueSearchRowBasicBuildTargetItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The buildTarget 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 buildTarget value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $buildTarget
     * @return \StructType\IssueSearchRowBasic
     */
    public function setBuildTarget(array $buildTarget = array())
    {
        // validation for constraint: array
        if ('' !== ($buildTargetArrayErrorMessage = self::validateBuildTargetForArrayConstraintsFromSetBuildTarget($buildTarget))) {
            throw new \InvalidArgumentException($buildTargetArrayErrorMessage, __LINE__);
        }
        $this->buildTarget = $buildTarget;
        return $this;
    }
    /**
     * Add item to buildTarget value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToBuildTarget(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The buildTarget 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->buildTarget[] = $item;
        return $this;
    }
    /**
     * Get caseCount value
     * @return \StructType\SearchColumnLongField[]|null
     */
    public function getCaseCount()
    {
        return $this->caseCount;
    }
    /**
     * This method is responsible for validating the values passed to the setCaseCount method
     * This method is willingly generated in order to preserve the one-line inline validation within the setCaseCount method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateCaseCountForArrayConstraintsFromSetCaseCount(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicCaseCountItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicCaseCountItem instanceof \StructType\SearchColumnLongField) {
                $invalidValues[] = is_object($issueSearchRowBasicCaseCountItem) ? get_class($issueSearchRowBasicCaseCountItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicCaseCountItem), var_export($issueSearchRowBasicCaseCountItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The caseCount property can only contain items of type \StructType\SearchColumnLongField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set caseCount value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnLongField[] $caseCount
     * @return \StructType\IssueSearchRowBasic
     */
    public function setCaseCount(array $caseCount = array())
    {
        // validation for constraint: array
        if ('' !== ($caseCountArrayErrorMessage = self::validateCaseCountForArrayConstraintsFromSetCaseCount($caseCount))) {
            throw new \InvalidArgumentException($caseCountArrayErrorMessage, __LINE__);
        }
        $this->caseCount = $caseCount;
        return $this;
    }
    /**
     * Add item to caseCount value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnLongField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToCaseCount(\StructType\SearchColumnLongField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnLongField) {
            throw new \InvalidArgumentException(sprintf('The caseCount property can only contain items of type \StructType\SearchColumnLongField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->caseCount[] = $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 $issueSearchRowBasicCaseNumberItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicCaseNumberItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($issueSearchRowBasicCaseNumberItem) ? get_class($issueSearchRowBasicCaseNumberItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicCaseNumberItem), var_export($issueSearchRowBasicCaseNumberItem, 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\IssueSearchRowBasic
     */
    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\IssueSearchRowBasic
     */
    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 closedDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getClosedDate()
    {
        return $this->closedDate;
    }
    /**
     * This method is responsible for validating the values passed to the setClosedDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setClosedDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateClosedDateForArrayConstraintsFromSetClosedDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicClosedDateItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicClosedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($issueSearchRowBasicClosedDateItem) ? get_class($issueSearchRowBasicClosedDateItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicClosedDateItem), var_export($issueSearchRowBasicClosedDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The closedDate 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 closedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $closedDate
     * @return \StructType\IssueSearchRowBasic
     */
    public function setClosedDate(array $closedDate = array())
    {
        // validation for constraint: array
        if ('' !== ($closedDateArrayErrorMessage = self::validateClosedDateForArrayConstraintsFromSetClosedDate($closedDate))) {
            throw new \InvalidArgumentException($closedDateArrayErrorMessage, __LINE__);
        }
        $this->closedDate = $closedDate;
        return $this;
    }
    /**
     * Add item to closedDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToClosedDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The closedDate 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->closedDate[] = $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 $issueSearchRowBasicCreatedDateItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicCreatedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($issueSearchRowBasicCreatedDateItem) ? get_class($issueSearchRowBasicCreatedDateItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicCreatedDateItem), var_export($issueSearchRowBasicCreatedDateItem, 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\IssueSearchRowBasic
     */
    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\IssueSearchRowBasic
     */
    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 dateReleased value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getDateReleased()
    {
        return $this->dateReleased;
    }
    /**
     * This method is responsible for validating the values passed to the setDateReleased method
     * This method is willingly generated in order to preserve the one-line inline validation within the setDateReleased method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateDateReleasedForArrayConstraintsFromSetDateReleased(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicDateReleasedItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicDateReleasedItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($issueSearchRowBasicDateReleasedItem) ? get_class($issueSearchRowBasicDateReleasedItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicDateReleasedItem), var_export($issueSearchRowBasicDateReleasedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The dateReleased 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 dateReleased value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $dateReleased
     * @return \StructType\IssueSearchRowBasic
     */
    public function setDateReleased(array $dateReleased = array())
    {
        // validation for constraint: array
        if ('' !== ($dateReleasedArrayErrorMessage = self::validateDateReleasedForArrayConstraintsFromSetDateReleased($dateReleased))) {
            throw new \InvalidArgumentException($dateReleasedArrayErrorMessage, __LINE__);
        }
        $this->dateReleased = $dateReleased;
        return $this;
    }
    /**
     * Add item to dateReleased value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToDateReleased(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The dateReleased 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->dateReleased[] = $item;
        return $this;
    }
    /**
     * Get duplicateOf value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getDuplicateOf()
    {
        return $this->duplicateOf;
    }
    /**
     * This method is responsible for validating the values passed to the setDuplicateOf method
     * This method is willingly generated in order to preserve the one-line inline validation within the setDuplicateOf method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateDuplicateOfForArrayConstraintsFromSetDuplicateOf(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicDuplicateOfItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicDuplicateOfItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicDuplicateOfItem) ? get_class($issueSearchRowBasicDuplicateOfItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicDuplicateOfItem), var_export($issueSearchRowBasicDuplicateOfItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The duplicateOf 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 duplicateOf value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $duplicateOf
     * @return \StructType\IssueSearchRowBasic
     */
    public function setDuplicateOf(array $duplicateOf = array())
    {
        // validation for constraint: array
        if ('' !== ($duplicateOfArrayErrorMessage = self::validateDuplicateOfForArrayConstraintsFromSetDuplicateOf($duplicateOf))) {
            throw new \InvalidArgumentException($duplicateOfArrayErrorMessage, __LINE__);
        }
        $this->duplicateOf = $duplicateOf;
        return $this;
    }
    /**
     * Add item to duplicateOf value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToDuplicateOf(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The duplicateOf 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->duplicateOf[] = $item;
        return $this;
    }
    /**
     * Get employeeOrTeam value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getEmployeeOrTeam()
    {
        return $this->employeeOrTeam;
    }
    /**
     * This method is responsible for validating the values passed to the setEmployeeOrTeam method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEmployeeOrTeam method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEmployeeOrTeamForArrayConstraintsFromSetEmployeeOrTeam(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicEmployeeOrTeamItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicEmployeeOrTeamItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicEmployeeOrTeamItem) ? get_class($issueSearchRowBasicEmployeeOrTeamItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicEmployeeOrTeamItem), var_export($issueSearchRowBasicEmployeeOrTeamItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The employeeOrTeam 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 employeeOrTeam value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $employeeOrTeam
     * @return \StructType\IssueSearchRowBasic
     */
    public function setEmployeeOrTeam(array $employeeOrTeam = array())
    {
        // validation for constraint: array
        if ('' !== ($employeeOrTeamArrayErrorMessage = self::validateEmployeeOrTeamForArrayConstraintsFromSetEmployeeOrTeam($employeeOrTeam))) {
            throw new \InvalidArgumentException($employeeOrTeamArrayErrorMessage, __LINE__);
        }
        $this->employeeOrTeam = $employeeOrTeam;
        return $this;
    }
    /**
     * Add item to employeeOrTeam value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToEmployeeOrTeam(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The employeeOrTeam 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->employeeOrTeam[] = $item;
        return $this;
    }
    /**
     * Get eventStatus value
     * @return \StructType\SearchColumnEnumSelectField[]|null
     */
    public function getEventStatus()
    {
        return $this->eventStatus;
    }
    /**
     * This method is responsible for validating the values passed to the setEventStatus method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEventStatus method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEventStatusForArrayConstraintsFromSetEventStatus(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicEventStatusItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicEventStatusItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicEventStatusItem) ? get_class($issueSearchRowBasicEventStatusItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicEventStatusItem), var_export($issueSearchRowBasicEventStatusItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The eventStatus 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 eventStatus value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField[] $eventStatus
     * @return \StructType\IssueSearchRowBasic
     */
    public function setEventStatus(array $eventStatus = array())
    {
        // validation for constraint: array
        if ('' !== ($eventStatusArrayErrorMessage = self::validateEventStatusForArrayConstraintsFromSetEventStatus($eventStatus))) {
            throw new \InvalidArgumentException($eventStatusArrayErrorMessage, __LINE__);
        }
        $this->eventStatus = $eventStatus;
        return $this;
    }
    /**
     * Add item to eventStatus value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToEventStatus(\StructType\SearchColumnEnumSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnEnumSelectField) {
            throw new \InvalidArgumentException(sprintf('The eventStatus 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->eventStatus[] = $item;
        return $this;
    }
    /**
     * Get externalAbstract value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getExternalAbstract()
    {
        return $this->externalAbstract;
    }
    /**
     * This method is responsible for validating the values passed to the setExternalAbstract method
     * This method is willingly generated in order to preserve the one-line inline validation within the setExternalAbstract method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateExternalAbstractForArrayConstraintsFromSetExternalAbstract(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicExternalAbstractItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicExternalAbstractItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($issueSearchRowBasicExternalAbstractItem) ? get_class($issueSearchRowBasicExternalAbstractItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicExternalAbstractItem), var_export($issueSearchRowBasicExternalAbstractItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The externalAbstract 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 externalAbstract value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $externalAbstract
     * @return \StructType\IssueSearchRowBasic
     */
    public function setExternalAbstract(array $externalAbstract = array())
    {
        // validation for constraint: array
        if ('' !== ($externalAbstractArrayErrorMessage = self::validateExternalAbstractForArrayConstraintsFromSetExternalAbstract($externalAbstract))) {
            throw new \InvalidArgumentException($externalAbstractArrayErrorMessage, __LINE__);
        }
        $this->externalAbstract = $externalAbstract;
        return $this;
    }
    /**
     * Add item to externalAbstract value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToExternalAbstract(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The externalAbstract 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->externalAbstract[] = $item;
        return $this;
    }
    /**
     * Get externalDetails value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getExternalDetails()
    {
        return $this->externalDetails;
    }
    /**
     * This method is responsible for validating the values passed to the setExternalDetails method
     * This method is willingly generated in order to preserve the one-line inline validation within the setExternalDetails method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateExternalDetailsForArrayConstraintsFromSetExternalDetails(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicExternalDetailsItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicExternalDetailsItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($issueSearchRowBasicExternalDetailsItem) ? get_class($issueSearchRowBasicExternalDetailsItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicExternalDetailsItem), var_export($issueSearchRowBasicExternalDetailsItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The externalDetails 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 externalDetails value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $externalDetails
     * @return \StructType\IssueSearchRowBasic
     */
    public function setExternalDetails(array $externalDetails = array())
    {
        // validation for constraint: array
        if ('' !== ($externalDetailsArrayErrorMessage = self::validateExternalDetailsForArrayConstraintsFromSetExternalDetails($externalDetails))) {
            throw new \InvalidArgumentException($externalDetailsArrayErrorMessage, __LINE__);
        }
        $this->externalDetails = $externalDetails;
        return $this;
    }
    /**
     * Add item to externalDetails value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToExternalDetails(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The externalDetails 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->externalDetails[] = $item;
        return $this;
    }
    /**
     * Get externalFixedIn value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getExternalFixedIn()
    {
        return $this->externalFixedIn;
    }
    /**
     * This method is responsible for validating the values passed to the setExternalFixedIn method
     * This method is willingly generated in order to preserve the one-line inline validation within the setExternalFixedIn method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateExternalFixedInForArrayConstraintsFromSetExternalFixedIn(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicExternalFixedInItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicExternalFixedInItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($issueSearchRowBasicExternalFixedInItem) ? get_class($issueSearchRowBasicExternalFixedInItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicExternalFixedInItem), var_export($issueSearchRowBasicExternalFixedInItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The externalFixedIn 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 externalFixedIn value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $externalFixedIn
     * @return \StructType\IssueSearchRowBasic
     */
    public function setExternalFixedIn(array $externalFixedIn = array())
    {
        // validation for constraint: array
        if ('' !== ($externalFixedInArrayErrorMessage = self::validateExternalFixedInForArrayConstraintsFromSetExternalFixedIn($externalFixedIn))) {
            throw new \InvalidArgumentException($externalFixedInArrayErrorMessage, __LINE__);
        }
        $this->externalFixedIn = $externalFixedIn;
        return $this;
    }
    /**
     * Add item to externalFixedIn value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToExternalFixedIn(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The externalFixedIn 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->externalFixedIn[] = $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 $issueSearchRowBasicExternalIdItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicExternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicExternalIdItem) ? get_class($issueSearchRowBasicExternalIdItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicExternalIdItem), var_export($issueSearchRowBasicExternalIdItem, 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\IssueSearchRowBasic
     */
    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\IssueSearchRowBasic
     */
    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 externalStatus value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getExternalStatus()
    {
        return $this->externalStatus;
    }
    /**
     * This method is responsible for validating the values passed to the setExternalStatus method
     * This method is willingly generated in order to preserve the one-line inline validation within the setExternalStatus method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateExternalStatusForArrayConstraintsFromSetExternalStatus(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicExternalStatusItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicExternalStatusItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicExternalStatusItem) ? get_class($issueSearchRowBasicExternalStatusItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicExternalStatusItem), var_export($issueSearchRowBasicExternalStatusItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The externalStatus 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 externalStatus value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $externalStatus
     * @return \StructType\IssueSearchRowBasic
     */
    public function setExternalStatus(array $externalStatus = array())
    {
        // validation for constraint: array
        if ('' !== ($externalStatusArrayErrorMessage = self::validateExternalStatusForArrayConstraintsFromSetExternalStatus($externalStatus))) {
            throw new \InvalidArgumentException($externalStatusArrayErrorMessage, __LINE__);
        }
        $this->externalStatus = $externalStatus;
        return $this;
    }
    /**
     * Add item to externalStatus value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToExternalStatus(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The externalStatus 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->externalStatus[] = $item;
        return $this;
    }
    /**
     * Get fixed value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getFixed()
    {
        return $this->fixed;
    }
    /**
     * This method is responsible for validating the values passed to the setFixed method
     * This method is willingly generated in order to preserve the one-line inline validation within the setFixed method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateFixedForArrayConstraintsFromSetFixed(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicFixedItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicFixedItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($issueSearchRowBasicFixedItem) ? get_class($issueSearchRowBasicFixedItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicFixedItem), var_export($issueSearchRowBasicFixedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The fixed 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 fixed value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $fixed
     * @return \StructType\IssueSearchRowBasic
     */
    public function setFixed(array $fixed = array())
    {
        // validation for constraint: array
        if ('' !== ($fixedArrayErrorMessage = self::validateFixedForArrayConstraintsFromSetFixed($fixed))) {
            throw new \InvalidArgumentException($fixedArrayErrorMessage, __LINE__);
        }
        $this->fixed = $fixed;
        return $this;
    }
    /**
     * Add item to fixed value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToFixed(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The fixed 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->fixed[] = $item;
        return $this;
    }
    /**
     * Get fixedBy value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getFixedBy()
    {
        return $this->fixedBy;
    }
    /**
     * This method is responsible for validating the values passed to the setFixedBy method
     * This method is willingly generated in order to preserve the one-line inline validation within the setFixedBy method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateFixedByForArrayConstraintsFromSetFixedBy(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicFixedByItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicFixedByItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicFixedByItem) ? get_class($issueSearchRowBasicFixedByItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicFixedByItem), var_export($issueSearchRowBasicFixedByItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The fixedBy 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 fixedBy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $fixedBy
     * @return \StructType\IssueSearchRowBasic
     */
    public function setFixedBy(array $fixedBy = array())
    {
        // validation for constraint: array
        if ('' !== ($fixedByArrayErrorMessage = self::validateFixedByForArrayConstraintsFromSetFixedBy($fixedBy))) {
            throw new \InvalidArgumentException($fixedByArrayErrorMessage, __LINE__);
        }
        $this->fixedBy = $fixedBy;
        return $this;
    }
    /**
     * Add item to fixedBy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToFixedBy(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The fixedBy 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->fixedBy[] = $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 $issueSearchRowBasicInternalIdItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicInternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicInternalIdItem) ? get_class($issueSearchRowBasicInternalIdItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicInternalIdItem), var_export($issueSearchRowBasicInternalIdItem, 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\IssueSearchRowBasic
     */
    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\IssueSearchRowBasic
     */
    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 isOwner value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsOwner()
    {
        return $this->isOwner;
    }
    /**
     * This method is responsible for validating the values passed to the setIsOwner method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsOwner method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsOwnerForArrayConstraintsFromSetIsOwner(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicIsOwnerItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicIsOwnerItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($issueSearchRowBasicIsOwnerItem) ? get_class($issueSearchRowBasicIsOwnerItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicIsOwnerItem), var_export($issueSearchRowBasicIsOwnerItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isOwner 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 isOwner value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isOwner
     * @return \StructType\IssueSearchRowBasic
     */
    public function setIsOwner(array $isOwner = array())
    {
        // validation for constraint: array
        if ('' !== ($isOwnerArrayErrorMessage = self::validateIsOwnerForArrayConstraintsFromSetIsOwner($isOwner))) {
            throw new \InvalidArgumentException($isOwnerArrayErrorMessage, __LINE__);
        }
        $this->isOwner = $isOwner;
        return $this;
    }
    /**
     * Add item to isOwner value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToIsOwner(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isOwner 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->isOwner[] = $item;
        return $this;
    }
    /**
     * Get isReviewed value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsReviewed()
    {
        return $this->isReviewed;
    }
    /**
     * This method is responsible for validating the values passed to the setIsReviewed method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsReviewed method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsReviewedForArrayConstraintsFromSetIsReviewed(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicIsReviewedItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicIsReviewedItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($issueSearchRowBasicIsReviewedItem) ? get_class($issueSearchRowBasicIsReviewedItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicIsReviewedItem), var_export($issueSearchRowBasicIsReviewedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isReviewed 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 isReviewed value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isReviewed
     * @return \StructType\IssueSearchRowBasic
     */
    public function setIsReviewed(array $isReviewed = array())
    {
        // validation for constraint: array
        if ('' !== ($isReviewedArrayErrorMessage = self::validateIsReviewedForArrayConstraintsFromSetIsReviewed($isReviewed))) {
            throw new \InvalidArgumentException($isReviewedArrayErrorMessage, __LINE__);
        }
        $this->isReviewed = $isReviewed;
        return $this;
    }
    /**
     * Add item to isReviewed value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToIsReviewed(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isReviewed 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->isReviewed[] = $item;
        return $this;
    }
    /**
     * Get isShowStopper value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsShowStopper()
    {
        return $this->isShowStopper;
    }
    /**
     * This method is responsible for validating the values passed to the setIsShowStopper method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsShowStopper method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsShowStopperForArrayConstraintsFromSetIsShowStopper(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicIsShowStopperItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicIsShowStopperItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($issueSearchRowBasicIsShowStopperItem) ? get_class($issueSearchRowBasicIsShowStopperItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicIsShowStopperItem), var_export($issueSearchRowBasicIsShowStopperItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isShowStopper 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 isShowStopper value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isShowStopper
     * @return \StructType\IssueSearchRowBasic
     */
    public function setIsShowStopper(array $isShowStopper = array())
    {
        // validation for constraint: array
        if ('' !== ($isShowStopperArrayErrorMessage = self::validateIsShowStopperForArrayConstraintsFromSetIsShowStopper($isShowStopper))) {
            throw new \InvalidArgumentException($isShowStopperArrayErrorMessage, __LINE__);
        }
        $this->isShowStopper = $isShowStopper;
        return $this;
    }
    /**
     * Add item to isShowStopper value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToIsShowStopper(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isShowStopper 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->isShowStopper[] = $item;
        return $this;
    }
    /**
     * Get issueAbstract value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getIssueAbstract()
    {
        return $this->issueAbstract;
    }
    /**
     * This method is responsible for validating the values passed to the setIssueAbstract method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIssueAbstract method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIssueAbstractForArrayConstraintsFromSetIssueAbstract(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicIssueAbstractItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicIssueAbstractItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($issueSearchRowBasicIssueAbstractItem) ? get_class($issueSearchRowBasicIssueAbstractItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicIssueAbstractItem), var_export($issueSearchRowBasicIssueAbstractItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The issueAbstract 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 issueAbstract value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $issueAbstract
     * @return \StructType\IssueSearchRowBasic
     */
    public function setIssueAbstract(array $issueAbstract = array())
    {
        // validation for constraint: array
        if ('' !== ($issueAbstractArrayErrorMessage = self::validateIssueAbstractForArrayConstraintsFromSetIssueAbstract($issueAbstract))) {
            throw new \InvalidArgumentException($issueAbstractArrayErrorMessage, __LINE__);
        }
        $this->issueAbstract = $issueAbstract;
        return $this;
    }
    /**
     * Add item to issueAbstract value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToIssueAbstract(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The issueAbstract 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->issueAbstract[] = $item;
        return $this;
    }
    /**
     * Get issueStatus value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getIssueStatus()
    {
        return $this->issueStatus;
    }
    /**
     * This method is responsible for validating the values passed to the setIssueStatus method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIssueStatus method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIssueStatusForArrayConstraintsFromSetIssueStatus(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicIssueStatusItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicIssueStatusItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicIssueStatusItem) ? get_class($issueSearchRowBasicIssueStatusItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicIssueStatusItem), var_export($issueSearchRowBasicIssueStatusItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The issueStatus 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 issueStatus value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $issueStatus
     * @return \StructType\IssueSearchRowBasic
     */
    public function setIssueStatus(array $issueStatus = array())
    {
        // validation for constraint: array
        if ('' !== ($issueStatusArrayErrorMessage = self::validateIssueStatusForArrayConstraintsFromSetIssueStatus($issueStatus))) {
            throw new \InvalidArgumentException($issueStatusArrayErrorMessage, __LINE__);
        }
        $this->issueStatus = $issueStatus;
        return $this;
    }
    /**
     * Add item to issueStatus value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToIssueStatus(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The issueStatus 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->issueStatus[] = $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 $issueSearchRowBasicItemItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicItemItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicItemItem) ? get_class($issueSearchRowBasicItemItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicItemItem), var_export($issueSearchRowBasicItemItem, 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\IssueSearchRowBasic
     */
    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\IssueSearchRowBasic
     */
    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 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 $issueSearchRowBasicLastModifiedDateItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicLastModifiedDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($issueSearchRowBasicLastModifiedDateItem) ? get_class($issueSearchRowBasicLastModifiedDateItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicLastModifiedDateItem), var_export($issueSearchRowBasicLastModifiedDateItem, 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\IssueSearchRowBasic
     */
    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\IssueSearchRowBasic
     */
    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 module value
     * @return \StructType\SearchColumnStringField[]|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 $issueSearchRowBasicModuleItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicModuleItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($issueSearchRowBasicModuleItem) ? get_class($issueSearchRowBasicModuleItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicModuleItem), var_export($issueSearchRowBasicModuleItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The module 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 module value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $module
     * @return \StructType\IssueSearchRowBasic
     */
    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\SearchColumnStringField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToModule(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The module 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->module[] = $item;
        return $this;
    }
    /**
     * Get number value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getNumber()
    {
        return $this->number;
    }
    /**
     * This method is responsible for validating the values passed to the setNumber method
     * This method is willingly generated in order to preserve the one-line inline validation within the setNumber method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateNumberForArrayConstraintsFromSetNumber(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicNumberItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicNumberItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($issueSearchRowBasicNumberItem) ? get_class($issueSearchRowBasicNumberItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicNumberItem), var_export($issueSearchRowBasicNumberItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The number 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 number value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $number
     * @return \StructType\IssueSearchRowBasic
     */
    public function setNumber(array $number = array())
    {
        // validation for constraint: array
        if ('' !== ($numberArrayErrorMessage = self::validateNumberForArrayConstraintsFromSetNumber($number))) {
            throw new \InvalidArgumentException($numberArrayErrorMessage, __LINE__);
        }
        $this->number = $number;
        return $this;
    }
    /**
     * Add item to number value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToNumber(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The number 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->number[] = $item;
        return $this;
    }
    /**
     * Get originalFixedIn value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getOriginalFixedIn()
    {
        return $this->originalFixedIn;
    }
    /**
     * This method is responsible for validating the values passed to the setOriginalFixedIn method
     * This method is willingly generated in order to preserve the one-line inline validation within the setOriginalFixedIn method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateOriginalFixedInForArrayConstraintsFromSetOriginalFixedIn(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicOriginalFixedInItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicOriginalFixedInItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($issueSearchRowBasicOriginalFixedInItem) ? get_class($issueSearchRowBasicOriginalFixedInItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicOriginalFixedInItem), var_export($issueSearchRowBasicOriginalFixedInItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The originalFixedIn 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 originalFixedIn value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $originalFixedIn
     * @return \StructType\IssueSearchRowBasic
     */
    public function setOriginalFixedIn(array $originalFixedIn = array())
    {
        // validation for constraint: array
        if ('' !== ($originalFixedInArrayErrorMessage = self::validateOriginalFixedInForArrayConstraintsFromSetOriginalFixedIn($originalFixedIn))) {
            throw new \InvalidArgumentException($originalFixedInArrayErrorMessage, __LINE__);
        }
        $this->originalFixedIn = $originalFixedIn;
        return $this;
    }
    /**
     * Add item to originalFixedIn value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToOriginalFixedIn(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The originalFixedIn 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->originalFixedIn[] = $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 $issueSearchRowBasicPriorityItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicPriorityItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicPriorityItem) ? get_class($issueSearchRowBasicPriorityItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicPriorityItem), var_export($issueSearchRowBasicPriorityItem, 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\IssueSearchRowBasic
     */
    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\IssueSearchRowBasic
     */
    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 $issueSearchRowBasicProductItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicProductItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicProductItem) ? get_class($issueSearchRowBasicProductItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicProductItem), var_export($issueSearchRowBasicProductItem, 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\IssueSearchRowBasic
     */
    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\IssueSearchRowBasic
     */
    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 productTeam value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getProductTeam()
    {
        return $this->productTeam;
    }
    /**
     * This method is responsible for validating the values passed to the setProductTeam method
     * This method is willingly generated in order to preserve the one-line inline validation within the setProductTeam method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateProductTeamForArrayConstraintsFromSetProductTeam(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicProductTeamItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicProductTeamItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicProductTeamItem) ? get_class($issueSearchRowBasicProductTeamItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicProductTeamItem), var_export($issueSearchRowBasicProductTeamItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The productTeam 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 productTeam value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $productTeam
     * @return \StructType\IssueSearchRowBasic
     */
    public function setProductTeam(array $productTeam = array())
    {
        // validation for constraint: array
        if ('' !== ($productTeamArrayErrorMessage = self::validateProductTeamForArrayConstraintsFromSetProductTeam($productTeam))) {
            throw new \InvalidArgumentException($productTeamArrayErrorMessage, __LINE__);
        }
        $this->productTeam = $productTeam;
        return $this;
    }
    /**
     * Add item to productTeam value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToProductTeam(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The productTeam 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->productTeam[] = $item;
        return $this;
    }
    /**
     * Get relatedIssue value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getRelatedIssue()
    {
        return $this->relatedIssue;
    }
    /**
     * This method is responsible for validating the values passed to the setRelatedIssue method
     * This method is willingly generated in order to preserve the one-line inline validation within the setRelatedIssue method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateRelatedIssueForArrayConstraintsFromSetRelatedIssue(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicRelatedIssueItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicRelatedIssueItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicRelatedIssueItem) ? get_class($issueSearchRowBasicRelatedIssueItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicRelatedIssueItem), var_export($issueSearchRowBasicRelatedIssueItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The relatedIssue 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 relatedIssue value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $relatedIssue
     * @return \StructType\IssueSearchRowBasic
     */
    public function setRelatedIssue(array $relatedIssue = array())
    {
        // validation for constraint: array
        if ('' !== ($relatedIssueArrayErrorMessage = self::validateRelatedIssueForArrayConstraintsFromSetRelatedIssue($relatedIssue))) {
            throw new \InvalidArgumentException($relatedIssueArrayErrorMessage, __LINE__);
        }
        $this->relatedIssue = $relatedIssue;
        return $this;
    }
    /**
     * Add item to relatedIssue value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToRelatedIssue(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The relatedIssue 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->relatedIssue[] = $item;
        return $this;
    }
    /**
     * Get relationship value
     * @return \StructType\SearchColumnEnumSelectField[]|null
     */
    public function getRelationship()
    {
        return $this->relationship;
    }
    /**
     * This method is responsible for validating the values passed to the setRelationship method
     * This method is willingly generated in order to preserve the one-line inline validation within the setRelationship method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateRelationshipForArrayConstraintsFromSetRelationship(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicRelationshipItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicRelationshipItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicRelationshipItem) ? get_class($issueSearchRowBasicRelationshipItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicRelationshipItem), var_export($issueSearchRowBasicRelationshipItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The relationship 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 relationship value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField[] $relationship
     * @return \StructType\IssueSearchRowBasic
     */
    public function setRelationship(array $relationship = array())
    {
        // validation for constraint: array
        if ('' !== ($relationshipArrayErrorMessage = self::validateRelationshipForArrayConstraintsFromSetRelationship($relationship))) {
            throw new \InvalidArgumentException($relationshipArrayErrorMessage, __LINE__);
        }
        $this->relationship = $relationship;
        return $this;
    }
    /**
     * Add item to relationship value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToRelationship(\StructType\SearchColumnEnumSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnEnumSelectField) {
            throw new \InvalidArgumentException(sprintf('The relationship 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->relationship[] = $item;
        return $this;
    }
    /**
     * Get relationshipComment value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getRelationshipComment()
    {
        return $this->relationshipComment;
    }
    /**
     * This method is responsible for validating the values passed to the setRelationshipComment method
     * This method is willingly generated in order to preserve the one-line inline validation within the setRelationshipComment method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateRelationshipCommentForArrayConstraintsFromSetRelationshipComment(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicRelationshipCommentItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicRelationshipCommentItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($issueSearchRowBasicRelationshipCommentItem) ? get_class($issueSearchRowBasicRelationshipCommentItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicRelationshipCommentItem), var_export($issueSearchRowBasicRelationshipCommentItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The relationshipComment 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 relationshipComment value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $relationshipComment
     * @return \StructType\IssueSearchRowBasic
     */
    public function setRelationshipComment(array $relationshipComment = array())
    {
        // validation for constraint: array
        if ('' !== ($relationshipCommentArrayErrorMessage = self::validateRelationshipCommentForArrayConstraintsFromSetRelationshipComment($relationshipComment))) {
            throw new \InvalidArgumentException($relationshipCommentArrayErrorMessage, __LINE__);
        }
        $this->relationshipComment = $relationshipComment;
        return $this;
    }
    /**
     * Add item to relationshipComment value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToRelationshipComment(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The relationshipComment 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->relationshipComment[] = $item;
        return $this;
    }
    /**
     * Get reportedBy value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getReportedBy()
    {
        return $this->reportedBy;
    }
    /**
     * This method is responsible for validating the values passed to the setReportedBy method
     * This method is willingly generated in order to preserve the one-line inline validation within the setReportedBy method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateReportedByForArrayConstraintsFromSetReportedBy(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicReportedByItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicReportedByItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicReportedByItem) ? get_class($issueSearchRowBasicReportedByItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicReportedByItem), var_export($issueSearchRowBasicReportedByItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The reportedBy 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 reportedBy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $reportedBy
     * @return \StructType\IssueSearchRowBasic
     */
    public function setReportedBy(array $reportedBy = array())
    {
        // validation for constraint: array
        if ('' !== ($reportedByArrayErrorMessage = self::validateReportedByForArrayConstraintsFromSetReportedBy($reportedBy))) {
            throw new \InvalidArgumentException($reportedByArrayErrorMessage, __LINE__);
        }
        $this->reportedBy = $reportedBy;
        return $this;
    }
    /**
     * Add item to reportedBy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToReportedBy(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The reportedBy 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->reportedBy[] = $item;
        return $this;
    }
    /**
     * Get reproduce value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getReproduce()
    {
        return $this->reproduce;
    }
    /**
     * This method is responsible for validating the values passed to the setReproduce method
     * This method is willingly generated in order to preserve the one-line inline validation within the setReproduce method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateReproduceForArrayConstraintsFromSetReproduce(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicReproduceItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicReproduceItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicReproduceItem) ? get_class($issueSearchRowBasicReproduceItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicReproduceItem), var_export($issueSearchRowBasicReproduceItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The reproduce 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 reproduce value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $reproduce
     * @return \StructType\IssueSearchRowBasic
     */
    public function setReproduce(array $reproduce = array())
    {
        // validation for constraint: array
        if ('' !== ($reproduceArrayErrorMessage = self::validateReproduceForArrayConstraintsFromSetReproduce($reproduce))) {
            throw new \InvalidArgumentException($reproduceArrayErrorMessage, __LINE__);
        }
        $this->reproduce = $reproduce;
        return $this;
    }
    /**
     * Add item to reproduce value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToReproduce(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The reproduce 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->reproduce[] = $item;
        return $this;
    }
    /**
     * Get resolved value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getResolved()
    {
        return $this->resolved;
    }
    /**
     * This method is responsible for validating the values passed to the setResolved method
     * This method is willingly generated in order to preserve the one-line inline validation within the setResolved method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateResolvedForArrayConstraintsFromSetResolved(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicResolvedItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicResolvedItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($issueSearchRowBasicResolvedItem) ? get_class($issueSearchRowBasicResolvedItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicResolvedItem), var_export($issueSearchRowBasicResolvedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The resolved 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 resolved value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $resolved
     * @return \StructType\IssueSearchRowBasic
     */
    public function setResolved(array $resolved = array())
    {
        // validation for constraint: array
        if ('' !== ($resolvedArrayErrorMessage = self::validateResolvedForArrayConstraintsFromSetResolved($resolved))) {
            throw new \InvalidArgumentException($resolvedArrayErrorMessage, __LINE__);
        }
        $this->resolved = $resolved;
        return $this;
    }
    /**
     * Add item to resolved value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToResolved(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The resolved 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->resolved[] = $item;
        return $this;
    }
    /**
     * Get resolvedBy value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getResolvedBy()
    {
        return $this->resolvedBy;
    }
    /**
     * This method is responsible for validating the values passed to the setResolvedBy method
     * This method is willingly generated in order to preserve the one-line inline validation within the setResolvedBy method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateResolvedByForArrayConstraintsFromSetResolvedBy(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicResolvedByItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicResolvedByItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicResolvedByItem) ? get_class($issueSearchRowBasicResolvedByItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicResolvedByItem), var_export($issueSearchRowBasicResolvedByItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The resolvedBy 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 resolvedBy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $resolvedBy
     * @return \StructType\IssueSearchRowBasic
     */
    public function setResolvedBy(array $resolvedBy = array())
    {
        // validation for constraint: array
        if ('' !== ($resolvedByArrayErrorMessage = self::validateResolvedByForArrayConstraintsFromSetResolvedBy($resolvedBy))) {
            throw new \InvalidArgumentException($resolvedByArrayErrorMessage, __LINE__);
        }
        $this->resolvedBy = $resolvedBy;
        return $this;
    }
    /**
     * Add item to resolvedBy value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToResolvedBy(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The resolvedBy 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->resolvedBy[] = $item;
        return $this;
    }
    /**
     * Get reviewer value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getReviewer()
    {
        return $this->reviewer;
    }
    /**
     * This method is responsible for validating the values passed to the setReviewer method
     * This method is willingly generated in order to preserve the one-line inline validation within the setReviewer method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateReviewerForArrayConstraintsFromSetReviewer(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicReviewerItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicReviewerItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicReviewerItem) ? get_class($issueSearchRowBasicReviewerItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicReviewerItem), var_export($issueSearchRowBasicReviewerItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The reviewer 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 reviewer value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $reviewer
     * @return \StructType\IssueSearchRowBasic
     */
    public function setReviewer(array $reviewer = array())
    {
        // validation for constraint: array
        if ('' !== ($reviewerArrayErrorMessage = self::validateReviewerForArrayConstraintsFromSetReviewer($reviewer))) {
            throw new \InvalidArgumentException($reviewerArrayErrorMessage, __LINE__);
        }
        $this->reviewer = $reviewer;
        return $this;
    }
    /**
     * Add item to reviewer value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToReviewer(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The reviewer 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->reviewer[] = $item;
        return $this;
    }
    /**
     * Get severity value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getSeverity()
    {
        return $this->severity;
    }
    /**
     * This method is responsible for validating the values passed to the setSeverity method
     * This method is willingly generated in order to preserve the one-line inline validation within the setSeverity method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateSeverityForArrayConstraintsFromSetSeverity(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicSeverityItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicSeverityItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicSeverityItem) ? get_class($issueSearchRowBasicSeverityItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicSeverityItem), var_export($issueSearchRowBasicSeverityItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The severity 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 severity value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $severity
     * @return \StructType\IssueSearchRowBasic
     */
    public function setSeverity(array $severity = array())
    {
        // validation for constraint: array
        if ('' !== ($severityArrayErrorMessage = self::validateSeverityForArrayConstraintsFromSetSeverity($severity))) {
            throw new \InvalidArgumentException($severityArrayErrorMessage, __LINE__);
        }
        $this->severity = $severity;
        return $this;
    }
    /**
     * Add item to severity value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToSeverity(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The severity 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->severity[] = $item;
        return $this;
    }
    /**
     * Get source value
     * @return \StructType\SearchColumnEnumSelectField[]|null
     */
    public function getSource()
    {
        return $this->source;
    }
    /**
     * This method is responsible for validating the values passed to the setSource method
     * This method is willingly generated in order to preserve the one-line inline validation within the setSource method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateSourceForArrayConstraintsFromSetSource(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicSourceItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicSourceItem instanceof \StructType\SearchColumnEnumSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicSourceItem) ? get_class($issueSearchRowBasicSourceItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicSourceItem), var_export($issueSearchRowBasicSourceItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The source 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 source value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField[] $source
     * @return \StructType\IssueSearchRowBasic
     */
    public function setSource(array $source = array())
    {
        // validation for constraint: array
        if ('' !== ($sourceArrayErrorMessage = self::validateSourceForArrayConstraintsFromSetSource($source))) {
            throw new \InvalidArgumentException($sourceArrayErrorMessage, __LINE__);
        }
        $this->source = $source;
        return $this;
    }
    /**
     * Add item to source value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnEnumSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToSource(\StructType\SearchColumnEnumSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnEnumSelectField) {
            throw new \InvalidArgumentException(sprintf('The source 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->source[] = $item;
        return $this;
    }
    /**
     * Get tags value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getTags()
    {
        return $this->tags;
    }
    /**
     * This method is responsible for validating the values passed to the setTags method
     * This method is willingly generated in order to preserve the one-line inline validation within the setTags method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateTagsForArrayConstraintsFromSetTags(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicTagsItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicTagsItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicTagsItem) ? get_class($issueSearchRowBasicTagsItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicTagsItem), var_export($issueSearchRowBasicTagsItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The tags 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 tags value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $tags
     * @return \StructType\IssueSearchRowBasic
     */
    public function setTags(array $tags = array())
    {
        // validation for constraint: array
        if ('' !== ($tagsArrayErrorMessage = self::validateTagsForArrayConstraintsFromSetTags($tags))) {
            throw new \InvalidArgumentException($tagsArrayErrorMessage, __LINE__);
        }
        $this->tags = $tags;
        return $this;
    }
    /**
     * Add item to tags value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToTags(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The tags 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->tags[] = $item;
        return $this;
    }
    /**
     * Get type value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getType()
    {
        return $this->type;
    }
    /**
     * This method is responsible for validating the values passed to the setType method
     * This method is willingly generated in order to preserve the one-line inline validation within the setType method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateTypeForArrayConstraintsFromSetType(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicTypeItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicTypeItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($issueSearchRowBasicTypeItem) ? get_class($issueSearchRowBasicTypeItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicTypeItem), var_export($issueSearchRowBasicTypeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The type 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 type value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $type
     * @return \StructType\IssueSearchRowBasic
     */
    public function setType(array $type = array())
    {
        // validation for constraint: array
        if ('' !== ($typeArrayErrorMessage = self::validateTypeForArrayConstraintsFromSetType($type))) {
            throw new \InvalidArgumentException($typeArrayErrorMessage, __LINE__);
        }
        $this->type = $type;
        return $this;
    }
    /**
     * Add item to type value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToType(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The type 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->type[] = $item;
        return $this;
    }
    /**
     * Get userType value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getUserType()
    {
        return $this->userType;
    }
    /**
     * This method is responsible for validating the values passed to the setUserType method
     * This method is willingly generated in order to preserve the one-line inline validation within the setUserType method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateUserTypeForArrayConstraintsFromSetUserType(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicUserTypeItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicUserTypeItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicUserTypeItem) ? get_class($issueSearchRowBasicUserTypeItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicUserTypeItem), var_export($issueSearchRowBasicUserTypeItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The userType 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 userType value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $userType
     * @return \StructType\IssueSearchRowBasic
     */
    public function setUserType(array $userType = array())
    {
        // validation for constraint: array
        if ('' !== ($userTypeArrayErrorMessage = self::validateUserTypeForArrayConstraintsFromSetUserType($userType))) {
            throw new \InvalidArgumentException($userTypeArrayErrorMessage, __LINE__);
        }
        $this->userType = $userType;
        return $this;
    }
    /**
     * Add item to userType value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToUserType(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The userType 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->userType[] = $item;
        return $this;
    }
    /**
     * Get versionBroken value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getVersionBroken()
    {
        return $this->versionBroken;
    }
    /**
     * This method is responsible for validating the values passed to the setVersionBroken method
     * This method is willingly generated in order to preserve the one-line inline validation within the setVersionBroken method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateVersionBrokenForArrayConstraintsFromSetVersionBroken(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicVersionBrokenItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicVersionBrokenItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicVersionBrokenItem) ? get_class($issueSearchRowBasicVersionBrokenItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicVersionBrokenItem), var_export($issueSearchRowBasicVersionBrokenItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The versionBroken 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 versionBroken value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $versionBroken
     * @return \StructType\IssueSearchRowBasic
     */
    public function setVersionBroken(array $versionBroken = array())
    {
        // validation for constraint: array
        if ('' !== ($versionBrokenArrayErrorMessage = self::validateVersionBrokenForArrayConstraintsFromSetVersionBroken($versionBroken))) {
            throw new \InvalidArgumentException($versionBrokenArrayErrorMessage, __LINE__);
        }
        $this->versionBroken = $versionBroken;
        return $this;
    }
    /**
     * Add item to versionBroken value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToVersionBroken(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The versionBroken 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->versionBroken[] = $item;
        return $this;
    }
    /**
     * Get versionFixed value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getVersionFixed()
    {
        return $this->versionFixed;
    }
    /**
     * This method is responsible for validating the values passed to the setVersionFixed method
     * This method is willingly generated in order to preserve the one-line inline validation within the setVersionFixed method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateVersionFixedForArrayConstraintsFromSetVersionFixed(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicVersionFixedItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicVersionFixedItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicVersionFixedItem) ? get_class($issueSearchRowBasicVersionFixedItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicVersionFixedItem), var_export($issueSearchRowBasicVersionFixedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The versionFixed 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 versionFixed value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $versionFixed
     * @return \StructType\IssueSearchRowBasic
     */
    public function setVersionFixed(array $versionFixed = array())
    {
        // validation for constraint: array
        if ('' !== ($versionFixedArrayErrorMessage = self::validateVersionFixedForArrayConstraintsFromSetVersionFixed($versionFixed))) {
            throw new \InvalidArgumentException($versionFixedArrayErrorMessage, __LINE__);
        }
        $this->versionFixed = $versionFixed;
        return $this;
    }
    /**
     * Add item to versionFixed value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToVersionFixed(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The versionFixed 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->versionFixed[] = $item;
        return $this;
    }
    /**
     * Get versionTarget value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getVersionTarget()
    {
        return $this->versionTarget;
    }
    /**
     * This method is responsible for validating the values passed to the setVersionTarget method
     * This method is willingly generated in order to preserve the one-line inline validation within the setVersionTarget method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateVersionTargetForArrayConstraintsFromSetVersionTarget(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $issueSearchRowBasicVersionTargetItem) {
            // validation for constraint: itemType
            if (!$issueSearchRowBasicVersionTargetItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($issueSearchRowBasicVersionTargetItem) ? get_class($issueSearchRowBasicVersionTargetItem) : sprintf('%s(%s)', gettype($issueSearchRowBasicVersionTargetItem), var_export($issueSearchRowBasicVersionTargetItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The versionTarget 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 versionTarget value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $versionTarget
     * @return \StructType\IssueSearchRowBasic
     */
    public function setVersionTarget(array $versionTarget = array())
    {
        // validation for constraint: array
        if ('' !== ($versionTargetArrayErrorMessage = self::validateVersionTargetForArrayConstraintsFromSetVersionTarget($versionTarget))) {
            throw new \InvalidArgumentException($versionTargetArrayErrorMessage, __LINE__);
        }
        $this->versionTarget = $versionTarget;
        return $this;
    }
    /**
     * Add item to versionTarget value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\IssueSearchRowBasic
     */
    public function addToVersionTarget(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The versionTarget 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->versionTarget[] = $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\IssueSearchRowBasic
     */
    public function setCustomFieldList(\StructType\SearchColumnCustomFieldList $customFieldList = null)
    {
        $this->customFieldList = $customFieldList;
        return $this;
    }
}
