<?php

namespace StructType;

use \WsdlToPhp\PackageBase\AbstractStructBase;

/**
 * This class stands for AccountingPeriodSearchRowBasic StructType
 * @subpackage Structs
 */
class AccountingPeriodSearchRowBasic extends SearchRowBasic
{
    /**
     * The allLocked
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $allLocked;
    /**
     * The allowNonGLChanges
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $allowNonGLChanges;
    /**
     * The apLocked
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $apLocked;
    /**
     * The arLocked
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $arLocked;
    /**
     * The closed
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $closed;
    /**
     * The closedOnDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $closedOnDate;
    /**
     * The endDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $endDate;
    /**
     * The internalId
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $internalId;
    /**
     * The isAdjust
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isAdjust;
    /**
     * The isInactive
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isInactive;
    /**
     * The isQuarter
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isQuarter;
    /**
     * The isYear
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $isYear;
    /**
     * The parent
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnSelectField[]
     */
    public $parent;
    /**
     * The payrollLocked
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnBooleanField[]
     */
    public $payrollLocked;
    /**
     * The periodName
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnStringField[]
     */
    public $periodName;
    /**
     * The startDate
     * Meta information extracted from the WSDL
     * - maxOccurs: unbounded
     * - minOccurs: 0
     * @var \StructType\SearchColumnDateField[]
     */
    public $startDate;
    /**
     * Constructor method for AccountingPeriodSearchRowBasic
     * @uses AccountingPeriodSearchRowBasic::setAllLocked()
     * @uses AccountingPeriodSearchRowBasic::setAllowNonGLChanges()
     * @uses AccountingPeriodSearchRowBasic::setApLocked()
     * @uses AccountingPeriodSearchRowBasic::setArLocked()
     * @uses AccountingPeriodSearchRowBasic::setClosed()
     * @uses AccountingPeriodSearchRowBasic::setClosedOnDate()
     * @uses AccountingPeriodSearchRowBasic::setEndDate()
     * @uses AccountingPeriodSearchRowBasic::setInternalId()
     * @uses AccountingPeriodSearchRowBasic::setIsAdjust()
     * @uses AccountingPeriodSearchRowBasic::setIsInactive()
     * @uses AccountingPeriodSearchRowBasic::setIsQuarter()
     * @uses AccountingPeriodSearchRowBasic::setIsYear()
     * @uses AccountingPeriodSearchRowBasic::setParent()
     * @uses AccountingPeriodSearchRowBasic::setPayrollLocked()
     * @uses AccountingPeriodSearchRowBasic::setPeriodName()
     * @uses AccountingPeriodSearchRowBasic::setStartDate()
     * @param \StructType\SearchColumnBooleanField[] $allLocked
     * @param \StructType\SearchColumnBooleanField[] $allowNonGLChanges
     * @param \StructType\SearchColumnBooleanField[] $apLocked
     * @param \StructType\SearchColumnBooleanField[] $arLocked
     * @param \StructType\SearchColumnBooleanField[] $closed
     * @param \StructType\SearchColumnDateField[] $closedOnDate
     * @param \StructType\SearchColumnDateField[] $endDate
     * @param \StructType\SearchColumnSelectField[] $internalId
     * @param \StructType\SearchColumnBooleanField[] $isAdjust
     * @param \StructType\SearchColumnBooleanField[] $isInactive
     * @param \StructType\SearchColumnBooleanField[] $isQuarter
     * @param \StructType\SearchColumnBooleanField[] $isYear
     * @param \StructType\SearchColumnSelectField[] $parent
     * @param \StructType\SearchColumnBooleanField[] $payrollLocked
     * @param \StructType\SearchColumnStringField[] $periodName
     * @param \StructType\SearchColumnDateField[] $startDate
     */
    public function __construct(array $allLocked = array(), array $allowNonGLChanges = array(), array $apLocked = array(), array $arLocked = array(), array $closed = array(), array $closedOnDate = array(), array $endDate = array(), array $internalId = array(), array $isAdjust = array(), array $isInactive = array(), array $isQuarter = array(), array $isYear = array(), array $parent = array(), array $payrollLocked = array(), array $periodName = array(), array $startDate = array())
    {
        $this
            ->setAllLocked($allLocked)
            ->setAllowNonGLChanges($allowNonGLChanges)
            ->setApLocked($apLocked)
            ->setArLocked($arLocked)
            ->setClosed($closed)
            ->setClosedOnDate($closedOnDate)
            ->setEndDate($endDate)
            ->setInternalId($internalId)
            ->setIsAdjust($isAdjust)
            ->setIsInactive($isInactive)
            ->setIsQuarter($isQuarter)
            ->setIsYear($isYear)
            ->setParent($parent)
            ->setPayrollLocked($payrollLocked)
            ->setPeriodName($periodName)
            ->setStartDate($startDate);
    }
    /**
     * Get allLocked value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getAllLocked()
    {
        return $this->allLocked;
    }
    /**
     * This method is responsible for validating the values passed to the setAllLocked method
     * This method is willingly generated in order to preserve the one-line inline validation within the setAllLocked method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateAllLockedForArrayConstraintsFromSetAllLocked(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicAllLockedItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicAllLockedItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicAllLockedItem) ? get_class($accountingPeriodSearchRowBasicAllLockedItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicAllLockedItem), var_export($accountingPeriodSearchRowBasicAllLockedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The allLocked 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 allLocked value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $allLocked
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setAllLocked(array $allLocked = array())
    {
        // validation for constraint: array
        if ('' !== ($allLockedArrayErrorMessage = self::validateAllLockedForArrayConstraintsFromSetAllLocked($allLocked))) {
            throw new \InvalidArgumentException($allLockedArrayErrorMessage, __LINE__);
        }
        $this->allLocked = $allLocked;
        return $this;
    }
    /**
     * Add item to allLocked value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToAllLocked(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The allLocked 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->allLocked[] = $item;
        return $this;
    }
    /**
     * Get allowNonGLChanges value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getAllowNonGLChanges()
    {
        return $this->allowNonGLChanges;
    }
    /**
     * This method is responsible for validating the values passed to the setAllowNonGLChanges method
     * This method is willingly generated in order to preserve the one-line inline validation within the setAllowNonGLChanges method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateAllowNonGLChangesForArrayConstraintsFromSetAllowNonGLChanges(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicAllowNonGLChangesItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicAllowNonGLChangesItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicAllowNonGLChangesItem) ? get_class($accountingPeriodSearchRowBasicAllowNonGLChangesItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicAllowNonGLChangesItem), var_export($accountingPeriodSearchRowBasicAllowNonGLChangesItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The allowNonGLChanges 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 allowNonGLChanges value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $allowNonGLChanges
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setAllowNonGLChanges(array $allowNonGLChanges = array())
    {
        // validation for constraint: array
        if ('' !== ($allowNonGLChangesArrayErrorMessage = self::validateAllowNonGLChangesForArrayConstraintsFromSetAllowNonGLChanges($allowNonGLChanges))) {
            throw new \InvalidArgumentException($allowNonGLChangesArrayErrorMessage, __LINE__);
        }
        $this->allowNonGLChanges = $allowNonGLChanges;
        return $this;
    }
    /**
     * Add item to allowNonGLChanges value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToAllowNonGLChanges(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The allowNonGLChanges 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->allowNonGLChanges[] = $item;
        return $this;
    }
    /**
     * Get apLocked value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getApLocked()
    {
        return $this->apLocked;
    }
    /**
     * This method is responsible for validating the values passed to the setApLocked method
     * This method is willingly generated in order to preserve the one-line inline validation within the setApLocked method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateApLockedForArrayConstraintsFromSetApLocked(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicApLockedItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicApLockedItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicApLockedItem) ? get_class($accountingPeriodSearchRowBasicApLockedItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicApLockedItem), var_export($accountingPeriodSearchRowBasicApLockedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The apLocked 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 apLocked value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $apLocked
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setApLocked(array $apLocked = array())
    {
        // validation for constraint: array
        if ('' !== ($apLockedArrayErrorMessage = self::validateApLockedForArrayConstraintsFromSetApLocked($apLocked))) {
            throw new \InvalidArgumentException($apLockedArrayErrorMessage, __LINE__);
        }
        $this->apLocked = $apLocked;
        return $this;
    }
    /**
     * Add item to apLocked value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToApLocked(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The apLocked 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->apLocked[] = $item;
        return $this;
    }
    /**
     * Get arLocked value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getArLocked()
    {
        return $this->arLocked;
    }
    /**
     * This method is responsible for validating the values passed to the setArLocked method
     * This method is willingly generated in order to preserve the one-line inline validation within the setArLocked method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateArLockedForArrayConstraintsFromSetArLocked(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicArLockedItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicArLockedItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicArLockedItem) ? get_class($accountingPeriodSearchRowBasicArLockedItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicArLockedItem), var_export($accountingPeriodSearchRowBasicArLockedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The arLocked 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 arLocked value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $arLocked
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setArLocked(array $arLocked = array())
    {
        // validation for constraint: array
        if ('' !== ($arLockedArrayErrorMessage = self::validateArLockedForArrayConstraintsFromSetArLocked($arLocked))) {
            throw new \InvalidArgumentException($arLockedArrayErrorMessage, __LINE__);
        }
        $this->arLocked = $arLocked;
        return $this;
    }
    /**
     * Add item to arLocked value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToArLocked(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The arLocked 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->arLocked[] = $item;
        return $this;
    }
    /**
     * Get closed value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getClosed()
    {
        return $this->closed;
    }
    /**
     * This method is responsible for validating the values passed to the setClosed method
     * This method is willingly generated in order to preserve the one-line inline validation within the setClosed method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateClosedForArrayConstraintsFromSetClosed(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicClosedItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicClosedItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicClosedItem) ? get_class($accountingPeriodSearchRowBasicClosedItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicClosedItem), var_export($accountingPeriodSearchRowBasicClosedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The closed 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 closed value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $closed
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setClosed(array $closed = array())
    {
        // validation for constraint: array
        if ('' !== ($closedArrayErrorMessage = self::validateClosedForArrayConstraintsFromSetClosed($closed))) {
            throw new \InvalidArgumentException($closedArrayErrorMessage, __LINE__);
        }
        $this->closed = $closed;
        return $this;
    }
    /**
     * Add item to closed value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToClosed(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The closed 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->closed[] = $item;
        return $this;
    }
    /**
     * Get closedOnDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getClosedOnDate()
    {
        return $this->closedOnDate;
    }
    /**
     * This method is responsible for validating the values passed to the setClosedOnDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setClosedOnDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateClosedOnDateForArrayConstraintsFromSetClosedOnDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicClosedOnDateItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicClosedOnDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicClosedOnDateItem) ? get_class($accountingPeriodSearchRowBasicClosedOnDateItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicClosedOnDateItem), var_export($accountingPeriodSearchRowBasicClosedOnDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The closedOnDate 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 closedOnDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $closedOnDate
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setClosedOnDate(array $closedOnDate = array())
    {
        // validation for constraint: array
        if ('' !== ($closedOnDateArrayErrorMessage = self::validateClosedOnDateForArrayConstraintsFromSetClosedOnDate($closedOnDate))) {
            throw new \InvalidArgumentException($closedOnDateArrayErrorMessage, __LINE__);
        }
        $this->closedOnDate = $closedOnDate;
        return $this;
    }
    /**
     * Add item to closedOnDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToClosedOnDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The closedOnDate 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->closedOnDate[] = $item;
        return $this;
    }
    /**
     * Get endDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getEndDate()
    {
        return $this->endDate;
    }
    /**
     * This method is responsible for validating the values passed to the setEndDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setEndDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateEndDateForArrayConstraintsFromSetEndDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicEndDateItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicEndDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicEndDateItem) ? get_class($accountingPeriodSearchRowBasicEndDateItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicEndDateItem), var_export($accountingPeriodSearchRowBasicEndDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The endDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set endDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $endDate
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setEndDate(array $endDate = array())
    {
        // validation for constraint: array
        if ('' !== ($endDateArrayErrorMessage = self::validateEndDateForArrayConstraintsFromSetEndDate($endDate))) {
            throw new \InvalidArgumentException($endDateArrayErrorMessage, __LINE__);
        }
        $this->endDate = $endDate;
        return $this;
    }
    /**
     * Add item to endDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToEndDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The endDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->endDate[] = $item;
        return $this;
    }
    /**
     * Get 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 $accountingPeriodSearchRowBasicInternalIdItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicInternalIdItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicInternalIdItem) ? get_class($accountingPeriodSearchRowBasicInternalIdItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicInternalIdItem), var_export($accountingPeriodSearchRowBasicInternalIdItem, 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\AccountingPeriodSearchRowBasic
     */
    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\AccountingPeriodSearchRowBasic
     */
    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 isAdjust value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsAdjust()
    {
        return $this->isAdjust;
    }
    /**
     * This method is responsible for validating the values passed to the setIsAdjust method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsAdjust method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsAdjustForArrayConstraintsFromSetIsAdjust(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicIsAdjustItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicIsAdjustItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicIsAdjustItem) ? get_class($accountingPeriodSearchRowBasicIsAdjustItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicIsAdjustItem), var_export($accountingPeriodSearchRowBasicIsAdjustItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isAdjust 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 isAdjust value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isAdjust
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setIsAdjust(array $isAdjust = array())
    {
        // validation for constraint: array
        if ('' !== ($isAdjustArrayErrorMessage = self::validateIsAdjustForArrayConstraintsFromSetIsAdjust($isAdjust))) {
            throw new \InvalidArgumentException($isAdjustArrayErrorMessage, __LINE__);
        }
        $this->isAdjust = $isAdjust;
        return $this;
    }
    /**
     * Add item to isAdjust value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToIsAdjust(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isAdjust 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->isAdjust[] = $item;
        return $this;
    }
    /**
     * Get isInactive value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsInactive()
    {
        return $this->isInactive;
    }
    /**
     * This method is responsible for validating the values passed to the setIsInactive method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsInactive method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsInactiveForArrayConstraintsFromSetIsInactive(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicIsInactiveItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicIsInactiveItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicIsInactiveItem) ? get_class($accountingPeriodSearchRowBasicIsInactiveItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicIsInactiveItem), var_export($accountingPeriodSearchRowBasicIsInactiveItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isInactive property can only contain items of type \StructType\SearchColumnBooleanField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set isInactive value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isInactive
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setIsInactive(array $isInactive = array())
    {
        // validation for constraint: array
        if ('' !== ($isInactiveArrayErrorMessage = self::validateIsInactiveForArrayConstraintsFromSetIsInactive($isInactive))) {
            throw new \InvalidArgumentException($isInactiveArrayErrorMessage, __LINE__);
        }
        $this->isInactive = $isInactive;
        return $this;
    }
    /**
     * Add item to isInactive value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToIsInactive(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isInactive property can only contain items of type \StructType\SearchColumnBooleanField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->isInactive[] = $item;
        return $this;
    }
    /**
     * Get isQuarter value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsQuarter()
    {
        return $this->isQuarter;
    }
    /**
     * This method is responsible for validating the values passed to the setIsQuarter method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsQuarter method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsQuarterForArrayConstraintsFromSetIsQuarter(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicIsQuarterItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicIsQuarterItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicIsQuarterItem) ? get_class($accountingPeriodSearchRowBasicIsQuarterItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicIsQuarterItem), var_export($accountingPeriodSearchRowBasicIsQuarterItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isQuarter 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 isQuarter value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isQuarter
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setIsQuarter(array $isQuarter = array())
    {
        // validation for constraint: array
        if ('' !== ($isQuarterArrayErrorMessage = self::validateIsQuarterForArrayConstraintsFromSetIsQuarter($isQuarter))) {
            throw new \InvalidArgumentException($isQuarterArrayErrorMessage, __LINE__);
        }
        $this->isQuarter = $isQuarter;
        return $this;
    }
    /**
     * Add item to isQuarter value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToIsQuarter(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isQuarter 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->isQuarter[] = $item;
        return $this;
    }
    /**
     * Get isYear value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getIsYear()
    {
        return $this->isYear;
    }
    /**
     * This method is responsible for validating the values passed to the setIsYear method
     * This method is willingly generated in order to preserve the one-line inline validation within the setIsYear method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateIsYearForArrayConstraintsFromSetIsYear(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicIsYearItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicIsYearItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicIsYearItem) ? get_class($accountingPeriodSearchRowBasicIsYearItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicIsYearItem), var_export($accountingPeriodSearchRowBasicIsYearItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The isYear 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 isYear value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $isYear
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setIsYear(array $isYear = array())
    {
        // validation for constraint: array
        if ('' !== ($isYearArrayErrorMessage = self::validateIsYearForArrayConstraintsFromSetIsYear($isYear))) {
            throw new \InvalidArgumentException($isYearArrayErrorMessage, __LINE__);
        }
        $this->isYear = $isYear;
        return $this;
    }
    /**
     * Add item to isYear value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToIsYear(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The isYear 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->isYear[] = $item;
        return $this;
    }
    /**
     * Get parent value
     * @return \StructType\SearchColumnSelectField[]|null
     */
    public function getParent()
    {
        return $this->parent;
    }
    /**
     * This method is responsible for validating the values passed to the setParent method
     * This method is willingly generated in order to preserve the one-line inline validation within the setParent method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateParentForArrayConstraintsFromSetParent(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicParentItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicParentItem instanceof \StructType\SearchColumnSelectField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicParentItem) ? get_class($accountingPeriodSearchRowBasicParentItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicParentItem), var_export($accountingPeriodSearchRowBasicParentItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The parent 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 parent value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField[] $parent
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setParent(array $parent = array())
    {
        // validation for constraint: array
        if ('' !== ($parentArrayErrorMessage = self::validateParentForArrayConstraintsFromSetParent($parent))) {
            throw new \InvalidArgumentException($parentArrayErrorMessage, __LINE__);
        }
        $this->parent = $parent;
        return $this;
    }
    /**
     * Add item to parent value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnSelectField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToParent(\StructType\SearchColumnSelectField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnSelectField) {
            throw new \InvalidArgumentException(sprintf('The parent 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->parent[] = $item;
        return $this;
    }
    /**
     * Get payrollLocked value
     * @return \StructType\SearchColumnBooleanField[]|null
     */
    public function getPayrollLocked()
    {
        return $this->payrollLocked;
    }
    /**
     * This method is responsible for validating the values passed to the setPayrollLocked method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPayrollLocked method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePayrollLockedForArrayConstraintsFromSetPayrollLocked(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicPayrollLockedItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicPayrollLockedItem instanceof \StructType\SearchColumnBooleanField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicPayrollLockedItem) ? get_class($accountingPeriodSearchRowBasicPayrollLockedItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicPayrollLockedItem), var_export($accountingPeriodSearchRowBasicPayrollLockedItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The payrollLocked 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 payrollLocked value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField[] $payrollLocked
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setPayrollLocked(array $payrollLocked = array())
    {
        // validation for constraint: array
        if ('' !== ($payrollLockedArrayErrorMessage = self::validatePayrollLockedForArrayConstraintsFromSetPayrollLocked($payrollLocked))) {
            throw new \InvalidArgumentException($payrollLockedArrayErrorMessage, __LINE__);
        }
        $this->payrollLocked = $payrollLocked;
        return $this;
    }
    /**
     * Add item to payrollLocked value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnBooleanField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToPayrollLocked(\StructType\SearchColumnBooleanField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnBooleanField) {
            throw new \InvalidArgumentException(sprintf('The payrollLocked 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->payrollLocked[] = $item;
        return $this;
    }
    /**
     * Get periodName value
     * @return \StructType\SearchColumnStringField[]|null
     */
    public function getPeriodName()
    {
        return $this->periodName;
    }
    /**
     * This method is responsible for validating the values passed to the setPeriodName method
     * This method is willingly generated in order to preserve the one-line inline validation within the setPeriodName method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validatePeriodNameForArrayConstraintsFromSetPeriodName(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicPeriodNameItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicPeriodNameItem instanceof \StructType\SearchColumnStringField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicPeriodNameItem) ? get_class($accountingPeriodSearchRowBasicPeriodNameItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicPeriodNameItem), var_export($accountingPeriodSearchRowBasicPeriodNameItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The periodName 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 periodName value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField[] $periodName
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setPeriodName(array $periodName = array())
    {
        // validation for constraint: array
        if ('' !== ($periodNameArrayErrorMessage = self::validatePeriodNameForArrayConstraintsFromSetPeriodName($periodName))) {
            throw new \InvalidArgumentException($periodNameArrayErrorMessage, __LINE__);
        }
        $this->periodName = $periodName;
        return $this;
    }
    /**
     * Add item to periodName value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnStringField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToPeriodName(\StructType\SearchColumnStringField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnStringField) {
            throw new \InvalidArgumentException(sprintf('The periodName 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->periodName[] = $item;
        return $this;
    }
    /**
     * Get startDate value
     * @return \StructType\SearchColumnDateField[]|null
     */
    public function getStartDate()
    {
        return $this->startDate;
    }
    /**
     * This method is responsible for validating the values passed to the setStartDate method
     * This method is willingly generated in order to preserve the one-line inline validation within the setStartDate method
     * @param array $values
     * @return string A non-empty message if the values does not match the validation rules
     */
    public static function validateStartDateForArrayConstraintsFromSetStartDate(array $values = array())
    {
        $message = '';
        $invalidValues = [];
        foreach ($values as $accountingPeriodSearchRowBasicStartDateItem) {
            // validation for constraint: itemType
            if (!$accountingPeriodSearchRowBasicStartDateItem instanceof \StructType\SearchColumnDateField) {
                $invalidValues[] = is_object($accountingPeriodSearchRowBasicStartDateItem) ? get_class($accountingPeriodSearchRowBasicStartDateItem) : sprintf('%s(%s)', gettype($accountingPeriodSearchRowBasicStartDateItem), var_export($accountingPeriodSearchRowBasicStartDateItem, true));
            }
        }
        if (!empty($invalidValues)) {
            $message = sprintf('The startDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($invalidValues) ? get_class($invalidValues) : (is_array($invalidValues) ? implode(', ', $invalidValues) : gettype($invalidValues)));
        }
        unset($invalidValues);
        return $message;
    }
    /**
     * Set startDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField[] $startDate
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function setStartDate(array $startDate = array())
    {
        // validation for constraint: array
        if ('' !== ($startDateArrayErrorMessage = self::validateStartDateForArrayConstraintsFromSetStartDate($startDate))) {
            throw new \InvalidArgumentException($startDateArrayErrorMessage, __LINE__);
        }
        $this->startDate = $startDate;
        return $this;
    }
    /**
     * Add item to startDate value
     * @throws \InvalidArgumentException
     * @param \StructType\SearchColumnDateField $item
     * @return \StructType\AccountingPeriodSearchRowBasic
     */
    public function addToStartDate(\StructType\SearchColumnDateField $item)
    {
        // validation for constraint: itemType
        if (!$item instanceof \StructType\SearchColumnDateField) {
            throw new \InvalidArgumentException(sprintf('The startDate property can only contain items of type \StructType\SearchColumnDateField, %s given', is_object($item) ? get_class($item) : (is_array($item) ? implode(', ', $item) : gettype($item))), __LINE__);
        }
        $this->startDate[] = $item;
        return $this;
    }
}
