Code Duplication - Gueststream-Inc/iqware - Measure and Improve Code Quality continuously with Scrutinizer



namespace Gueststream\PMS\IQWare\API;

class ArrayOfActivityUnit implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var ActivityUnit[] $ActivityUnit
     */
    protected $ActivityUnit = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return ActivityUnit[]
     */
    public function getActivityUnit()
    {
        return $this->ActivityUnit;
    }

    /**
     * @param ActivityUnit[] $ActivityUnit
     * @return \Gueststream\PMS\IQWare\API\ArrayOfActivityUnit
     */
    public function setActivityUnit(array $ActivityUnit = null)
    {
        $this->ActivityUnit = $ActivityUnit;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->ActivityUnit[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return ActivityUnit
     */
    public function offsetGet($offset)
    {
        return $this->ActivityUnit[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param ActivityUnit $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->ActivityUnit[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->ActivityUnit[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return ActivityUnit Return the current element
     */
    public function current()
    {
        return current($this->ActivityUnit);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->ActivityUnit);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->ActivityUnit);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->ActivityUnit);
    }

    /**
     * Countable implementation
     *
     * @return ActivityUnit Return count of elements
     */
    public function count()
    {
        return count($this->ActivityUnit);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfActivityUnitAvail implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var ActivityUnitAvail[] $ActivityUnitAvail
     */
    protected $ActivityUnitAvail = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return ActivityUnitAvail[]
     */
    public function getActivityUnitAvail()
    {
        return $this->ActivityUnitAvail;
    }

    /**
     * @param ActivityUnitAvail[] $ActivityUnitAvail
     * @return \Gueststream\PMS\IQWare\API\ArrayOfActivityUnitAvail
     */
    public function setActivityUnitAvail(array $ActivityUnitAvail = null)
    {
        $this->ActivityUnitAvail = $ActivityUnitAvail;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->ActivityUnitAvail[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return ActivityUnitAvail
     */
    public function offsetGet($offset)
    {
        return $this->ActivityUnitAvail[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param ActivityUnitAvail $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->ActivityUnitAvail[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->ActivityUnitAvail[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return ActivityUnitAvail Return the current element
     */
    public function current()
    {
        return current($this->ActivityUnitAvail);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->ActivityUnitAvail);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->ActivityUnitAvail);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->ActivityUnitAvail);
    }

    /**
     * Countable implementation
     *
     * @return ActivityUnitAvail Return count of elements
     */
    public function count()
    {
        return count($this->ActivityUnitAvail);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfApplicableSpecialOffersRBO implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var ApplicableSpecialOffersRBO[] $ApplicableSpecialOffersRBO
     */
    protected $ApplicableSpecialOffersRBO = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return ApplicableSpecialOffersRBO[]
     */
    public function getApplicableSpecialOffersRBO()
    {
        return $this->ApplicableSpecialOffersRBO;
    }

    /**
     * @param ApplicableSpecialOffersRBO[] $ApplicableSpecialOffersRBO
     * @return \Gueststream\PMS\IQWare\API\ArrayOfApplicableSpecialOffersRBO
     */
    public function setApplicableSpecialOffersRBO(array $ApplicableSpecialOffersRBO = null)
    {
        $this->ApplicableSpecialOffersRBO = $ApplicableSpecialOffersRBO;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->ApplicableSpecialOffersRBO[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return ApplicableSpecialOffersRBO
     */
    public function offsetGet($offset)
    {
        return $this->ApplicableSpecialOffersRBO[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param ApplicableSpecialOffersRBO $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->ApplicableSpecialOffersRBO[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->ApplicableSpecialOffersRBO[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return ApplicableSpecialOffersRBO Return the current element
     */
    public function current()
    {
        return current($this->ApplicableSpecialOffersRBO);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->ApplicableSpecialOffersRBO);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->ApplicableSpecialOffersRBO);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->ApplicableSpecialOffersRBO);
    }

    /**
     * Countable implementation
     *
     * @return ApplicableSpecialOffersRBO Return count of elements
     */
    public function count()
    {
        return count($this->ApplicableSpecialOffersRBO);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfArrivalAndDepartureTimeSeason implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var ArrivalAndDepartureTimeSeason[] $ArrivalAndDepartureTimeSeason
     */
    protected $ArrivalAndDepartureTimeSeason = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return ArrivalAndDepartureTimeSeason[]
     */
    public function getArrivalAndDepartureTimeSeason()
    {
        return $this->ArrivalAndDepartureTimeSeason;
    }

    /**
     * @param ArrivalAndDepartureTimeSeason[] $ArrivalAndDepartureTimeSeason
     * @return \Gueststream\PMS\IQWare\API\ArrayOfArrivalAndDepartureTimeSeason
     */
    public function setArrivalAndDepartureTimeSeason(array $ArrivalAndDepartureTimeSeason = null)
    {
        $this->ArrivalAndDepartureTimeSeason = $ArrivalAndDepartureTimeSeason;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->ArrivalAndDepartureTimeSeason[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return ArrivalAndDepartureTimeSeason
     */
    public function offsetGet($offset)
    {
        return $this->ArrivalAndDepartureTimeSeason[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param ArrivalAndDepartureTimeSeason $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->ArrivalAndDepartureTimeSeason[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->ArrivalAndDepartureTimeSeason[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return ArrivalAndDepartureTimeSeason Return the current element
     */
    public function current()
    {
        return current($this->ArrivalAndDepartureTimeSeason);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->ArrivalAndDepartureTimeSeason);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->ArrivalAndDepartureTimeSeason);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->ArrivalAndDepartureTimeSeason);
    }

    /**
     * Countable implementation
     *
     * @return ArrivalAndDepartureTimeSeason Return count of elements
     */
    public function count()
    {
        return count($this->ArrivalAndDepartureTimeSeason);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfAvailabilityOverview implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var AvailabilityOverview[] $AvailabilityOverview
     */
    protected $AvailabilityOverview = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return AvailabilityOverview[]
     */
    public function getAvailabilityOverview()
    {
        return $this->AvailabilityOverview;
    }

    /**
     * @param AvailabilityOverview[] $AvailabilityOverview
     * @return \Gueststream\PMS\IQWare\API\ArrayOfAvailabilityOverview
     */
    public function setAvailabilityOverview(array $AvailabilityOverview = null)
    {
        $this->AvailabilityOverview = $AvailabilityOverview;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->AvailabilityOverview[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return AvailabilityOverview
     */
    public function offsetGet($offset)
    {
        return $this->AvailabilityOverview[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param AvailabilityOverview $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->AvailabilityOverview[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->AvailabilityOverview[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return AvailabilityOverview Return the current element
     */
    public function current()
    {
        return current($this->AvailabilityOverview);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->AvailabilityOverview);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->AvailabilityOverview);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->AvailabilityOverview);
    }

    /**
     * Countable implementation
     *
     * @return AvailabilityOverview Return count of elements
     */
    public function count()
    {
        return count($this->AvailabilityOverview);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfAvailableRoom implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var AvailableRoom[] $AvailableRoom
     */
    protected $AvailableRoom = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return AvailableRoom[]
     */
    public function getAvailableRoom()
    {
        return $this->AvailableRoom;
    }

    /**
     * @param AvailableRoom[] $AvailableRoom
     * @return \Gueststream\PMS\IQWare\API\ArrayOfAvailableRoom
     */
    public function setAvailableRoom(array $AvailableRoom = null)
    {
        $this->AvailableRoom = $AvailableRoom;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->AvailableRoom[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return AvailableRoom
     */
    public function offsetGet($offset)
    {
        return $this->AvailableRoom[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param AvailableRoom $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->AvailableRoom[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->AvailableRoom[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return AvailableRoom Return the current element
     */
    public function current()
    {
        return current($this->AvailableRoom);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->AvailableRoom);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->AvailableRoom);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->AvailableRoom);
    }

    /**
     * Countable implementation
     *
     * @return AvailableRoom Return count of elements
     */
    public function count()
    {
        return count($this->AvailableRoom);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfAvailableSuite implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var AvailableSuite[] $AvailableSuite
     */
    protected $AvailableSuite = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return AvailableSuite[]
     */
    public function getAvailableSuite()
    {
        return $this->AvailableSuite;
    }

    /**
     * @param AvailableSuite[] $AvailableSuite
     * @return \Gueststream\PMS\IQWare\API\ArrayOfAvailableSuite
     */
    public function setAvailableSuite(array $AvailableSuite = null)
    {
        $this->AvailableSuite = $AvailableSuite;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->AvailableSuite[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return AvailableSuite
     */
    public function offsetGet($offset)
    {
        return $this->AvailableSuite[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param AvailableSuite $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->AvailableSuite[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->AvailableSuite[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return AvailableSuite Return the current element
     */
    public function current()
    {
        return current($this->AvailableSuite);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->AvailableSuite);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->AvailableSuite);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->AvailableSuite);
    }

    /**
     * Countable implementation
     *
     * @return AvailableSuite Return count of elements
     */
    public function count()
    {
        return count($this->AvailableSuite);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfB2BAnywhere implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var B2BAnywhere[] $B2BAnywhere
     */
    protected $B2BAnywhere = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return B2BAnywhere[]
     */
    public function getB2BAnywhere()
    {
        return $this->B2BAnywhere;
    }

    /**
     * @param B2BAnywhere[] $B2BAnywhere
     * @return \Gueststream\PMS\IQWare\API\ArrayOfB2BAnywhere
     */
    public function setB2BAnywhere(array $B2BAnywhere = null)
    {
        $this->B2BAnywhere = $B2BAnywhere;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->B2BAnywhere[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return B2BAnywhere
     */
    public function offsetGet($offset)
    {
        return $this->B2BAnywhere[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param B2BAnywhere $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->B2BAnywhere[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->B2BAnywhere[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return B2BAnywhere Return the current element
     */
    public function current()
    {
        return current($this->B2BAnywhere);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->B2BAnywhere);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->B2BAnywhere);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->B2BAnywhere);
    }

    /**
     * Countable implementation
     *
     * @return B2BAnywhere Return count of elements
     */
    public function count()
    {
        return count($this->B2BAnywhere);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfBeachChairSite implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var BeachChairSite[] $BeachChairSite
     */
    protected $BeachChairSite = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return BeachChairSite[]
     */
    public function getBeachChairSite()
    {
        return $this->BeachChairSite;
    }

    /**
     * @param BeachChairSite[] $BeachChairSite
     * @return \Gueststream\PMS\IQWare\API\ArrayOfBeachChairSite
     */
    public function setBeachChairSite(array $BeachChairSite = null)
    {
        $this->BeachChairSite = $BeachChairSite;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->BeachChairSite[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return BeachChairSite
     */
    public function offsetGet($offset)
    {
        return $this->BeachChairSite[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param BeachChairSite $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->BeachChairSite[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->BeachChairSite[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return BeachChairSite Return the current element
     */
    public function current()
    {
        return current($this->BeachChairSite);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->BeachChairSite);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->BeachChairSite);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->BeachChairSite);
    }

    /**
     * Countable implementation
     *
     * @return BeachChairSite Return count of elements
     */
    public function count()
    {
        return count($this->BeachChairSite);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfBedding implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var Bedding[] $Bedding
     */
    protected $Bedding = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return Bedding[]
     */
    public function getBedding()
    {
        return $this->Bedding;
    }

    /**
     * @param Bedding[] $Bedding
     * @return \Gueststream\PMS\IQWare\API\ArrayOfBedding
     */
    public function setBedding(array $Bedding = null)
    {
        $this->Bedding = $Bedding;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->Bedding[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return Bedding
     */
    public function offsetGet($offset)
    {
        return $this->Bedding[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param Bedding $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->Bedding[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->Bedding[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return Bedding Return the current element
     */
    public function current()
    {
        return current($this->Bedding);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->Bedding);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->Bedding);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->Bedding);
    }

    /**
     * Countable implementation
     *
     * @return Bedding Return count of elements
     */
    public function count()
    {
        return count($this->Bedding);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfBreakdownByDay implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var BreakdownByDay[] $BreakdownByDay
     */
    protected $BreakdownByDay = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return BreakdownByDay[]
     */
    public function getBreakdownByDay()
    {
        return $this->BreakdownByDay;
    }

    /**
     * @param BreakdownByDay[] $BreakdownByDay
     * @return \Gueststream\PMS\IQWare\API\ArrayOfBreakdownByDay
     */
    public function setBreakdownByDay(array $BreakdownByDay = null)
    {
        $this->BreakdownByDay = $BreakdownByDay;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->BreakdownByDay[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return BreakdownByDay
     */
    public function offsetGet($offset)
    {
        return $this->BreakdownByDay[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param BreakdownByDay $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->BreakdownByDay[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->BreakdownByDay[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return BreakdownByDay Return the current element
     */
    public function current()
    {
        return current($this->BreakdownByDay);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->BreakdownByDay);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->BreakdownByDay);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->BreakdownByDay);
    }

    /**
     * Countable implementation
     *
     * @return BreakdownByDay Return count of elements
     */
    public function count()
    {
        return count($this->BreakdownByDay);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCancellationReason implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var CancellationReason[] $CancellationReason
     */
    protected $CancellationReason = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return CancellationReason[]
     */
    public function getCancellationReason()
    {
        return $this->CancellationReason;
    }

    /**
     * @param CancellationReason[] $CancellationReason
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCancellationReason
     */
    public function setCancellationReason(array $CancellationReason = null)
    {
        $this->CancellationReason = $CancellationReason;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->CancellationReason[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return CancellationReason
     */
    public function offsetGet($offset)
    {
        return $this->CancellationReason[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param CancellationReason $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->CancellationReason[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->CancellationReason[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return CancellationReason Return the current element
     */
    public function current()
    {
        return current($this->CancellationReason);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->CancellationReason);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->CancellationReason);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->CancellationReason);
    }

    /**
     * Countable implementation
     *
     * @return CancellationReason Return count of elements
     */
    public function count()
    {
        return count($this->CancellationReason);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCComments implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cComments[] $cComments
     */
    protected $cComments = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cComments[]
     */
    public function getCComments()
    {
        return $this->cComments;
    }

    /**
     * @param cComments[] $cComments
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCComments
     */
    public function setCComments(array $cComments = null)
    {
        $this->cComments = $cComments;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cComments[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cComments
     */
    public function offsetGet($offset)
    {
        return $this->cComments[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cComments $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cComments[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cComments[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cComments Return the current element
     */
    public function current()
    {
        return current($this->cComments);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cComments);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cComments);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cComments);
    }

    /**
     * Countable implementation
     *
     * @return cComments Return count of elements
     */
    public function count()
    {
        return count($this->cComments);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCCreditCard implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cCreditCard[] $cCreditCard
     */
    protected $cCreditCard = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cCreditCard[]
     */
    public function getCCreditCard()
    {
        return $this->cCreditCard;
    }

    /**
     * @param cCreditCard[] $cCreditCard
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCCreditCard
     */
    public function setCCreditCard(array $cCreditCard = null)
    {
        $this->cCreditCard = $cCreditCard;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cCreditCard[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cCreditCard
     */
    public function offsetGet($offset)
    {
        return $this->cCreditCard[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cCreditCard $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cCreditCard[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cCreditCard[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cCreditCard Return the current element
     */
    public function current()
    {
        return current($this->cCreditCard);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cCreditCard);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cCreditCard);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cCreditCard);
    }

    /**
     * Countable implementation
     *
     * @return cCreditCard Return count of elements
     */
    public function count()
    {
        return count($this->cCreditCard);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCElement implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cElement[] $cElement
     */
    protected $cElement = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cElement[]
     */
    public function getCElement()
    {
        return $this->cElement;
    }

    /**
     * @param cElement[] $cElement
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCElement
     */
    public function setCElement(array $cElement = null)
    {
        $this->cElement = $cElement;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cElement[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cElement
     */
    public function offsetGet($offset)
    {
        return $this->cElement[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cElement $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cElement[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cElement[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cElement Return the current element
     */
    public function current()
    {
        return current($this->cElement);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cElement);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cElement);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cElement);
    }

    /**
     * Countable implementation
     *
     * @return cElement Return count of elements
     */
    public function count()
    {
        return count($this->cElement);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCFitMember implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cFitMember[] $cFitMember
     */
    protected $cFitMember = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cFitMember[]
     */
    public function getCFitMember()
    {
        return $this->cFitMember;
    }

    /**
     * @param cFitMember[] $cFitMember
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCFitMember
     */
    public function setCFitMember(array $cFitMember = null)
    {
        $this->cFitMember = $cFitMember;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cFitMember[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cFitMember
     */
    public function offsetGet($offset)
    {
        return $this->cFitMember[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cFitMember $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cFitMember[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cFitMember[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cFitMember Return the current element
     */
    public function current()
    {
        return current($this->cFitMember);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cFitMember);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cFitMember);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cFitMember);
    }

    /**
     * Countable implementation
     *
     * @return cFitMember Return count of elements
     */
    public function count()
    {
        return count($this->cFitMember);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCFolioDist implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cFolioDist[] $cFolioDist
     */
    protected $cFolioDist = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cFolioDist[]
     */
    public function getCFolioDist()
    {
        return $this->cFolioDist;
    }

    /**
     * @param cFolioDist[] $cFolioDist
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCFolioDist
     */
    public function setCFolioDist(array $cFolioDist = null)
    {
        $this->cFolioDist = $cFolioDist;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cFolioDist[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cFolioDist
     */
    public function offsetGet($offset)
    {
        return $this->cFolioDist[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cFolioDist $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cFolioDist[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cFolioDist[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cFolioDist Return the current element
     */
    public function current()
    {
        return current($this->cFolioDist);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cFolioDist);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cFolioDist);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cFolioDist);
    }

    /**
     * Countable implementation
     *
     * @return cFolioDist Return count of elements
     */
    public function count()
    {
        return count($this->cFolioDist);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCGiftCertificateIncentivePeriod implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cGiftCertificateIncentivePeriod[] $cGiftCertificateIncentivePeriod
     */
    protected $cGiftCertificateIncentivePeriod = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cGiftCertificateIncentivePeriod[]
     */
    public function getCGiftCertificateIncentivePeriod()
    {
        return $this->cGiftCertificateIncentivePeriod;
    }

    /**
     * @param cGiftCertificateIncentivePeriod[] $cGiftCertificateIncentivePeriod
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCGiftCertificateIncentivePeriod
     */
    public function setCGiftCertificateIncentivePeriod(array $cGiftCertificateIncentivePeriod = null)
    {
        $this->cGiftCertificateIncentivePeriod = $cGiftCertificateIncentivePeriod;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cGiftCertificateIncentivePeriod[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cGiftCertificateIncentivePeriod
     */
    public function offsetGet($offset)
    {
        return $this->cGiftCertificateIncentivePeriod[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cGiftCertificateIncentivePeriod $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cGiftCertificateIncentivePeriod[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cGiftCertificateIncentivePeriod[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cGiftCertificateIncentivePeriod Return the current element
     */
    public function current()
    {
        return current($this->cGiftCertificateIncentivePeriod);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cGiftCertificateIncentivePeriod);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cGiftCertificateIncentivePeriod);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cGiftCertificateIncentivePeriod);
    }

    /**
     * Countable implementation
     *
     * @return cGiftCertificateIncentivePeriod Return count of elements
     */
    public function count()
    {
        return count($this->cGiftCertificateIncentivePeriod);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCGolfItems implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cGolfItems[] $cGolfItems
     */
    protected $cGolfItems = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cGolfItems[]
     */
    public function getCGolfItems()
    {
        return $this->cGolfItems;
    }

    /**
     * @param cGolfItems[] $cGolfItems
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCGolfItems
     */
    public function setCGolfItems(array $cGolfItems = null)
    {
        $this->cGolfItems = $cGolfItems;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cGolfItems[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cGolfItems
     */
    public function offsetGet($offset)
    {
        return $this->cGolfItems[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cGolfItems $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cGolfItems[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cGolfItems[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cGolfItems Return the current element
     */
    public function current()
    {
        return current($this->cGolfItems);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cGolfItems);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cGolfItems);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cGolfItems);
    }

    /**
     * Countable implementation
     *
     * @return cGolfItems Return count of elements
     */
    public function count()
    {
        return count($this->cGolfItems);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCManualRateDaily implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cManualRateDaily[] $cManualRateDaily
     */
    protected $cManualRateDaily = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cManualRateDaily[]
     */
    public function getCManualRateDaily()
    {
        return $this->cManualRateDaily;
    }

    /**
     * @param cManualRateDaily[] $cManualRateDaily
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCManualRateDaily
     */
    public function setCManualRateDaily(array $cManualRateDaily = null)
    {
        $this->cManualRateDaily = $cManualRateDaily;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cManualRateDaily[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cManualRateDaily
     */
    public function offsetGet($offset)
    {
        return $this->cManualRateDaily[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cManualRateDaily $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cManualRateDaily[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cManualRateDaily[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cManualRateDaily Return the current element
     */
    public function current()
    {
        return current($this->cManualRateDaily);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cManualRateDaily);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cManualRateDaily);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cManualRateDaily);
    }

    /**
     * Countable implementation
     *
     * @return cManualRateDaily Return count of elements
     */
    public function count()
    {
        return count($this->cManualRateDaily);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCPersonCountDaily implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cPersonCountDaily[] $cPersonCountDaily
     */
    protected $cPersonCountDaily = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cPersonCountDaily[]
     */
    public function getCPersonCountDaily()
    {
        return $this->cPersonCountDaily;
    }

    /**
     * @param cPersonCountDaily[] $cPersonCountDaily
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCPersonCountDaily
     */
    public function setCPersonCountDaily(array $cPersonCountDaily = null)
    {
        $this->cPersonCountDaily = $cPersonCountDaily;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cPersonCountDaily[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cPersonCountDaily
     */
    public function offsetGet($offset)
    {
        return $this->cPersonCountDaily[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cPersonCountDaily $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cPersonCountDaily[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cPersonCountDaily[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cPersonCountDaily Return the current element
     */
    public function current()
    {
        return current($this->cPersonCountDaily);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cPersonCountDaily);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cPersonCountDaily);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cPersonCountDaily);
    }

    /**
     * Countable implementation
     *
     * @return cPersonCountDaily Return count of elements
     */
    public function count()
    {
        return count($this->cPersonCountDaily);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCRateDaily implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cRateDaily[] $cRateDaily
     */
    protected $cRateDaily = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cRateDaily[]
     */
    public function getCRateDaily()
    {
        return $this->cRateDaily;
    }

    /**
     * @param cRateDaily[] $cRateDaily
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCRateDaily
     */
    public function setCRateDaily(array $cRateDaily = null)
    {
        $this->cRateDaily = $cRateDaily;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cRateDaily[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cRateDaily
     */
    public function offsetGet($offset)
    {
        return $this->cRateDaily[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cRateDaily $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cRateDaily[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cRateDaily[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cRateDaily Return the current element
     */
    public function current()
    {
        return current($this->cRateDaily);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cRateDaily);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cRateDaily);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cRateDaily);
    }

    /**
     * Countable implementation
     *
     * @return cRateDaily Return count of elements
     */
    public function count()
    {
        return count($this->cRateDaily);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCreditCardTypes implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var CreditCardTypes[] $CreditCardTypes
     */
    protected $CreditCardTypes = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return CreditCardTypes[]
     */
    public function getCreditCardTypes()
    {
        return $this->CreditCardTypes;
    }

    /**
     * @param CreditCardTypes[] $CreditCardTypes
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCreditCardTypes
     */
    public function setCreditCardTypes(array $CreditCardTypes = null)
    {
        $this->CreditCardTypes = $CreditCardTypes;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->CreditCardTypes[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return CreditCardTypes
     */
    public function offsetGet($offset)
    {
        return $this->CreditCardTypes[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param CreditCardTypes $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->CreditCardTypes[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->CreditCardTypes[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return CreditCardTypes Return the current element
     */
    public function current()
    {
        return current($this->CreditCardTypes);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->CreditCardTypes);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->CreditCardTypes);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->CreditCardTypes);
    }

    /**
     * Countable implementation
     *
     * @return CreditCardTypes Return count of elements
     */
    public function count()
    {
        return count($this->CreditCardTypes);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCreditLimit implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var CreditLimit[] $CreditLimit
     */
    protected $CreditLimit = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return CreditLimit[]
     */
    public function getCreditLimit()
    {
        return $this->CreditLimit;
    }

    /**
     * @param CreditLimit[] $CreditLimit
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCreditLimit
     */
    public function setCreditLimit(array $CreditLimit = null)
    {
        $this->CreditLimit = $CreditLimit;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->CreditLimit[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return CreditLimit
     */
    public function offsetGet($offset)
    {
        return $this->CreditLimit[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param CreditLimit $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->CreditLimit[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->CreditLimit[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return CreditLimit Return the current element
     */
    public function current()
    {
        return current($this->CreditLimit);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->CreditLimit);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->CreditLimit);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->CreditLimit);
    }

    /**
     * Countable implementation
     *
     * @return CreditLimit Return count of elements
     */
    public function count()
    {
        return count($this->CreditLimit);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCServiceChargeALaCarte implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cServiceChargeALaCarte[] $cServiceChargeALaCarte
     */
    protected $cServiceChargeALaCarte = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cServiceChargeALaCarte[]
     */
    public function getCServiceChargeALaCarte()
    {
        return $this->cServiceChargeALaCarte;
    }

    /**
     * @param cServiceChargeALaCarte[] $cServiceChargeALaCarte
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCServiceChargeALaCarte
     */
    public function setCServiceChargeALaCarte(array $cServiceChargeALaCarte = null)
    {
        $this->cServiceChargeALaCarte = $cServiceChargeALaCarte;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cServiceChargeALaCarte[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cServiceChargeALaCarte
     */
    public function offsetGet($offset)
    {
        return $this->cServiceChargeALaCarte[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cServiceChargeALaCarte $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cServiceChargeALaCarte[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cServiceChargeALaCarte[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cServiceChargeALaCarte Return the current element
     */
    public function current()
    {
        return current($this->cServiceChargeALaCarte);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cServiceChargeALaCarte);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cServiceChargeALaCarte);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cServiceChargeALaCarte);
    }

    /**
     * Countable implementation
     *
     * @return cServiceChargeALaCarte Return count of elements
     */
    public function count()
    {
        return count($this->cServiceChargeALaCarte);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCTelephone implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cTelephone[] $cTelephone
     */
    protected $cTelephone = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cTelephone[]
     */
    public function getCTelephone()
    {
        return $this->cTelephone;
    }

    /**
     * @param cTelephone[] $cTelephone
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCTelephone
     */
    public function setCTelephone(array $cTelephone = null)
    {
        $this->cTelephone = $cTelephone;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cTelephone[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cTelephone
     */
    public function offsetGet($offset)
    {
        return $this->cTelephone[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cTelephone $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cTelephone[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cTelephone[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cTelephone Return the current element
     */
    public function current()
    {
        return current($this->cTelephone);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cTelephone);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cTelephone);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cTelephone);
    }

    /**
     * Countable implementation
     *
     * @return cTelephone Return count of elements
     */
    public function count()
    {
        return count($this->cTelephone);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfCTransfer implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var cTransfer[] $cTransfer
     */
    protected $cTransfer = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return cTransfer[]
     */
    public function getCTransfer()
    {
        return $this->cTransfer;
    }

    /**
     * @param cTransfer[] $cTransfer
     * @return \Gueststream\PMS\IQWare\API\ArrayOfCTransfer
     */
    public function setCTransfer(array $cTransfer = null)
    {
        $this->cTransfer = $cTransfer;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->cTransfer[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return cTransfer
     */
    public function offsetGet($offset)
    {
        return $this->cTransfer[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param cTransfer $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->cTransfer[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->cTransfer[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return cTransfer Return the current element
     */
    public function current()
    {
        return current($this->cTransfer);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->cTransfer);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->cTransfer);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->cTransfer);
    }

    /**
     * Countable implementation
     *
     * @return cTransfer Return count of elements
     */
    public function count()
    {
        return count($this->cTransfer);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfDailyBreakdown implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var DailyBreakdown[] $DailyBreakdown
     */
    protected $DailyBreakdown = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return DailyBreakdown[]
     */
    public function getDailyBreakdown()
    {
        return $this->DailyBreakdown;
    }

    /**
     * @param DailyBreakdown[] $DailyBreakdown
     * @return \Gueststream\PMS\IQWare\API\ArrayOfDailyBreakdown
     */
    public function setDailyBreakdown(array $DailyBreakdown = null)
    {
        $this->DailyBreakdown = $DailyBreakdown;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->DailyBreakdown[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return DailyBreakdown
     */
    public function offsetGet($offset)
    {
        return $this->DailyBreakdown[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param DailyBreakdown $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->DailyBreakdown[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->DailyBreakdown[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return DailyBreakdown Return the current element
     */
    public function current()
    {
        return current($this->DailyBreakdown);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->DailyBreakdown);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->DailyBreakdown);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->DailyBreakdown);
    }

    /**
     * Countable implementation
     *
     * @return DailyBreakdown Return count of elements
     */
    public function count()
    {
        return count($this->DailyBreakdown);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfDailyEvaluation implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var DailyEvaluation[] $DailyEvaluation
     */
    protected $DailyEvaluation = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return DailyEvaluation[]
     */
    public function getDailyEvaluation()
    {
        return $this->DailyEvaluation;
    }

    /**
     * @param DailyEvaluation[] $DailyEvaluation
     * @return \Gueststream\PMS\IQWare\API\ArrayOfDailyEvaluation
     */
    public function setDailyEvaluation(array $DailyEvaluation = null)
    {
        $this->DailyEvaluation = $DailyEvaluation;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->DailyEvaluation[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return DailyEvaluation
     */
    public function offsetGet($offset)
    {
        return $this->DailyEvaluation[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param DailyEvaluation $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->DailyEvaluation[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->DailyEvaluation[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return DailyEvaluation Return the current element
     */
    public function current()
    {
        return current($this->DailyEvaluation);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->DailyEvaluation);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->DailyEvaluation);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->DailyEvaluation);
    }

    /**
     * Countable implementation
     *
     * @return DailyEvaluation Return count of elements
     */
    public function count()
    {
        return count($this->DailyEvaluation);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfDailyOccupancy implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var DailyOccupancy[] $DailyOccupancy
     */
    protected $DailyOccupancy = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return DailyOccupancy[]
     */
    public function getDailyOccupancy()
    {
        return $this->DailyOccupancy;
    }

    /**
     * @param DailyOccupancy[] $DailyOccupancy
     * @return \Gueststream\PMS\IQWare\API\ArrayOfDailyOccupancy
     */
    public function setDailyOccupancy(array $DailyOccupancy = null)
    {
        $this->DailyOccupancy = $DailyOccupancy;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->DailyOccupancy[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return DailyOccupancy
     */
    public function offsetGet($offset)
    {
        return $this->DailyOccupancy[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param DailyOccupancy $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->DailyOccupancy[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->DailyOccupancy[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return DailyOccupancy Return the current element
     */
    public function current()
    {
        return current($this->DailyOccupancy);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->DailyOccupancy);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->DailyOccupancy);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->DailyOccupancy);
    }

    /**
     * Countable implementation
     *
     * @return DailyOccupancy Return count of elements
     */
    public function count()
    {
        return count($this->DailyOccupancy);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfDataSet implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var DataSet[] $DataSet
     */
    protected $DataSet = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return DataSet[]
     */
    public function getDataSet()
    {
        return $this->DataSet;
    }

    /**
     * @param DataSet[] $DataSet
     * @return \Gueststream\PMS\IQWare\API\ArrayOfDataSet
     */
    public function setDataSet(array $DataSet = null)
    {
        $this->DataSet = $DataSet;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->DataSet[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return DataSet
     */
    public function offsetGet($offset)
    {
        return $this->DataSet[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param DataSet $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->DataSet[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->DataSet[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return DataSet Return the current element
     */
    public function current()
    {
        return current($this->DataSet);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->DataSet);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->DataSet);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->DataSet);
    }

    /**
     * Countable implementation
     *
     * @return DataSet Return count of elements
     */
    public function count()
    {
        return count($this->DataSet);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfDateTime implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var dateTime[] $dateTime
     */
    protected $dateTime = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return dateTime[]
     */
    public function getDateTime()
    {
        return $this->dateTime;
    }

    /**
     * @param dateTime[] $dateTime
     * @return \Gueststream\PMS\IQWare\API\ArrayOfDateTime
     */
    public function setDateTime(array $dateTime = null)
    {
        $this->dateTime = $dateTime;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->dateTime[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return dateTime
     */
    public function offsetGet($offset)
    {
        return $this->dateTime[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param dateTime $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->dateTime[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->dateTime[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return dateTime Return the current element
     */
    public function current()
    {
        return current($this->dateTime);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->dateTime);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->dateTime);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->dateTime);
    }

    /**
     * Countable implementation
     *
     * @return dateTime Return count of elements
     */
    public function count()
    {
        return count($this->dateTime);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfDetail implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var Detail[] $Detail
     */
    protected $Detail = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return Detail[]
     */
    public function getDetail()
    {
        return $this->Detail;
    }

    /**
     * @param Detail[] $Detail
     * @return \Gueststream\PMS\IQWare\API\ArrayOfDetail
     */
    public function setDetail(array $Detail = null)
    {
        $this->Detail = $Detail;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->Detail[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return Detail
     */
    public function offsetGet($offset)
    {
        return $this->Detail[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param Detail $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->Detail[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->Detail[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return Detail Return the current element
     */
    public function current()
    {
        return current($this->Detail);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->Detail);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->Detail);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->Detail);
    }

    /**
     * Countable implementation
     *
     * @return Detail Return count of elements
     */
    public function count()
    {
        return count($this->Detail);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfDetails implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var Details[] $Details
     */
    protected $Details = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return Details[]
     */
    public function getDetails()
    {
        return $this->Details;
    }

    /**
     * @param Details[] $Details
     * @return \Gueststream\PMS\IQWare\API\ArrayOfDetails
     */
    public function setDetails(array $Details = null)
    {
        $this->Details = $Details;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->Details[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return Details
     */
    public function offsetGet($offset)
    {
        return $this->Details[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param Details $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->Details[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->Details[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return Details Return the current element
     */
    public function current()
    {
        return current($this->Details);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->Details);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->Details);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->Details);
    }

    /**
     * Countable implementation
     *
     * @return Details Return count of elements
     */
    public function count()
    {
        return count($this->Details);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfElements implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var Elements[] $Elements
     */
    protected $Elements = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return Elements[]
     */
    public function getElements()
    {
        return $this->Elements;
    }

    /**
     * @param Elements[] $Elements
     * @return \Gueststream\PMS\IQWare\API\ArrayOfElements
     */
    public function setElements(array $Elements = null)
    {
        $this->Elements = $Elements;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->Elements[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return Elements
     */
    public function offsetGet($offset)
    {
        return $this->Elements[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param Elements $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->Elements[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->Elements[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return Elements Return the current element
     */
    public function current()
    {
        return current($this->Elements);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->Elements);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->Elements);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->Elements);
    }

    /**
     * Countable implementation
     *
     * @return Elements Return count of elements
     */
    public function count()
    {
        return count($this->Elements);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfEvaluation implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var Evaluation[] $Evaluation
     */
    protected $Evaluation = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return Evaluation[]
     */
    public function getEvaluation()
    {
        return $this->Evaluation;
    }

    /**
     * @param Evaluation[] $Evaluation
     * @return \Gueststream\PMS\IQWare\API\ArrayOfEvaluation
     */
    public function setEvaluation(array $Evaluation = null)
    {
        $this->Evaluation = $Evaluation;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->Evaluation[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return Evaluation
     */
    public function offsetGet($offset)
    {
        return $this->Evaluation[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param Evaluation $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->Evaluation[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->Evaluation[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return Evaluation Return the current element
     */
    public function current()
    {
        return current($this->Evaluation);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->Evaluation);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->Evaluation);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->Evaluation);
    }

    /**
     * Countable implementation
     *
     * @return Evaluation Return count of elements
     */
    public function count()
    {
        return count($this->Evaluation);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfEvaluationResult implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var EvaluationResult[] $EvaluationResult
     */
    protected $EvaluationResult = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return EvaluationResult[]
     */
    public function getEvaluationResult()
    {
        return $this->EvaluationResult;
    }

    /**
     * @param EvaluationResult[] $EvaluationResult
     * @return \Gueststream\PMS\IQWare\API\ArrayOfEvaluationResult
     */
    public function setEvaluationResult(array $EvaluationResult = null)
    {
        $this->EvaluationResult = $EvaluationResult;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->EvaluationResult[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return EvaluationResult
     */
    public function offsetGet($offset)
    {
        return $this->EvaluationResult[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param EvaluationResult $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->EvaluationResult[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->EvaluationResult[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return EvaluationResult Return the current element
     */
    public function current()
    {
        return current($this->EvaluationResult);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->EvaluationResult);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->EvaluationResult);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->EvaluationResult);
    }

    /**
     * Countable implementation
     *
     * @return EvaluationResult Return count of elements
     */
    public function count()
    {
        return count($this->EvaluationResult);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfExportedRate implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var ExportedRate[] $ExportedRate
     */
    protected $ExportedRate = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return ExportedRate[]
     */
    public function getExportedRate()
    {
        return $this->ExportedRate;
    }

    /**
     * @param ExportedRate[] $ExportedRate
     * @return \Gueststream\PMS\IQWare\API\ArrayOfExportedRate
     */
    public function setExportedRate(array $ExportedRate = null)
    {
        $this->ExportedRate = $ExportedRate;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->ExportedRate[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return ExportedRate
     */
    public function offsetGet($offset)
    {
        return $this->ExportedRate[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param ExportedRate $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->ExportedRate[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->ExportedRate[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return ExportedRate Return the current element
     */
    public function current()
    {
        return current($this->ExportedRate);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->ExportedRate);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->ExportedRate);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->ExportedRate);
    }

    /**
     * Countable implementation
     *
     * @return ExportedRate Return count of elements
     */
    public function count()
    {
        return count($this->ExportedRate);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfGDSListing implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var GDSListing[] $GDSListing
     */
    protected $GDSListing = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return GDSListing[]
     */
    public function getGDSListing()
    {
        return $this->GDSListing;
    }

    /**
     * @param GDSListing[] $GDSListing
     * @return \Gueststream\PMS\IQWare\API\ArrayOfGDSListing
     */
    public function setGDSListing(array $GDSListing = null)
    {
        $this->GDSListing = $GDSListing;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->GDSListing[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return GDSListing
     */
    public function offsetGet($offset)
    {
        return $this->GDSListing[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param GDSListing $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->GDSListing[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->GDSListing[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return GDSListing Return the current element
     */
    public function current()
    {
        return current($this->GDSListing);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->GDSListing);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->GDSListing);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->GDSListing);
    }

    /**
     * Countable implementation
     *
     * @return GDSListing Return count of elements
     */
    public function count()
    {
        return count($this->GDSListing);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfGlobalAccess implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var GlobalAccess[] $GlobalAccess
     */
    protected $GlobalAccess = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return GlobalAccess[]
     */
    public function getGlobalAccess()
    {
        return $this->GlobalAccess;
    }

    /**
     * @param GlobalAccess[] $GlobalAccess
     * @return \Gueststream\PMS\IQWare\API\ArrayOfGlobalAccess
     */
    public function setGlobalAccess(array $GlobalAccess = null)
    {
        $this->GlobalAccess = $GlobalAccess;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->GlobalAccess[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return GlobalAccess
     */
    public function offsetGet($offset)
    {
        return $this->GlobalAccess[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param GlobalAccess $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->GlobalAccess[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->GlobalAccess[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return GlobalAccess Return the current element
     */
    public function current()
    {
        return current($this->GlobalAccess);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->GlobalAccess);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->GlobalAccess);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->GlobalAccess);
    }

    /**
     * Countable implementation
     *
     * @return GlobalAccess Return count of elements
     */
    public function count()
    {
        return count($this->GlobalAccess);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfGroupValues implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var GroupValues[] $GroupValues
     */
    protected $GroupValues = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return GroupValues[]
     */
    public function getGroupValues()
    {
        return $this->GroupValues;
    }

    /**
     * @param GroupValues[] $GroupValues
     * @return \Gueststream\PMS\IQWare\API\ArrayOfGroupValues
     */
    public function setGroupValues(array $GroupValues = null)
    {
        $this->GroupValues = $GroupValues;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->GroupValues[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return GroupValues
     */
    public function offsetGet($offset)
    {
        return $this->GroupValues[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param GroupValues $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->GroupValues[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->GroupValues[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return GroupValues Return the current element
     */
    public function current()
    {
        return current($this->GroupValues);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->GroupValues);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->GroupValues);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->GroupValues);
    }

    /**
     * Countable implementation
     *
     * @return GroupValues Return count of elements
     */
    public function count()
    {
        return count($this->GroupValues);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfInfosBilling implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var InfosBilling[] $InfosBilling
     */
    protected $InfosBilling = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return InfosBilling[]
     */
    public function getInfosBilling()
    {
        return $this->InfosBilling;
    }

    /**
     * @param InfosBilling[] $InfosBilling
     * @return \Gueststream\PMS\IQWare\API\ArrayOfInfosBilling
     */
    public function setInfosBilling(array $InfosBilling = null)
    {
        $this->InfosBilling = $InfosBilling;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->InfosBilling[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return InfosBilling
     */
    public function offsetGet($offset)
    {
        return $this->InfosBilling[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param InfosBilling $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->InfosBilling[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->InfosBilling[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return InfosBilling Return the current element
     */
    public function current()
    {
        return current($this->InfosBilling);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->InfosBilling);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->InfosBilling);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->InfosBilling);
    }

    /**
     * Countable implementation
     *
     * @return InfosBilling Return count of elements
     */
    public function count()
    {
        return count($this->InfosBilling);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfInt implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var int[] $int
     */
    protected $int = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return int[]
     */
    public function getInt()
    {
        return $this->int;
    }

    /**
     * @param int[] $int
     * @return \Gueststream\PMS\IQWare\API\ArrayOfInt
     */
    public function setInt(array $int = null)
    {
        $this->int = $int;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->int[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return int
     */
    public function offsetGet($offset)
    {
        return $this->int[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param int $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->int[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->int[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return int Return the current element
     */
    public function current()
    {
        return current($this->int);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->int);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->int);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->int);
    }

    /**
     * Countable implementation
     *
     * @return int Return count of elements
     */
    public function count()
    {
        return count($this->int);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfIQImage implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var IQImage[] $IQImage
     */
    protected $IQImage = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return IQImage[]
     */
    public function getIQImage()
    {
        return $this->IQImage;
    }

    /**
     * @param IQImage[] $IQImage
     * @return \Gueststream\PMS\IQWare\API\ArrayOfIQImage
     */
    public function setIQImage(array $IQImage = null)
    {
        $this->IQImage = $IQImage;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->IQImage[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return IQImage
     */
    public function offsetGet($offset)
    {
        return $this->IQImage[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param IQImage $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->IQImage[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->IQImage[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return IQImage Return the current element
     */
    public function current()
    {
        return current($this->IQImage);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->IQImage);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->IQImage);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->IQImage);
    }

    /**
     * Countable implementation
     *
     * @return IQImage Return count of elements
     */
    public function count()
    {
        return count($this->IQImage);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfLanguage implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var Language[] $Language
     */
    protected $Language = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return Language[]
     */
    public function getLanguage()
    {
        return $this->Language;
    }

    /**
     * @param Language[] $Language
     * @return \Gueststream\PMS\IQWare\API\ArrayOfLanguage
     */
    public function setLanguage(array $Language = null)
    {
        $this->Language = $Language;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->Language[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return Language
     */
    public function offsetGet($offset)
    {
        return $this->Language[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param Language $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->Language[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->Language[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return Language Return the current element
     */
    public function current()
    {
        return current($this->Language);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->Language);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->Language);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->Language);
    }

    /**
     * Countable implementation
     *
     * @return Language Return count of elements
     */
    public function count()
    {
        return count($this->Language);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfMarkupItem implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var MarkupItem[] $MarkupItem
     */
    protected $MarkupItem = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return MarkupItem[]
     */
    public function getMarkupItem()
    {
        return $this->MarkupItem;
    }

    /**
     * @param MarkupItem[] $MarkupItem
     * @return \Gueststream\PMS\IQWare\API\ArrayOfMarkupItem
     */
    public function setMarkupItem(array $MarkupItem = null)
    {
        $this->MarkupItem = $MarkupItem;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->MarkupItem[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return MarkupItem
     */
    public function offsetGet($offset)
    {
        return $this->MarkupItem[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param MarkupItem $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->MarkupItem[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->MarkupItem[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return MarkupItem Return the current element
     */
    public function current()
    {
        return current($this->MarkupItem);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->MarkupItem);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->MarkupItem);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->MarkupItem);
    }

    /**
     * Countable implementation
     *
     * @return MarkupItem Return count of elements
     */
    public function count()
    {
        return count($this->MarkupItem);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfMemberLanguage implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var MemberLanguage[] $MemberLanguage
     */
    protected $MemberLanguage = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return MemberLanguage[]
     */
    public function getMemberLanguage()
    {
        return $this->MemberLanguage;
    }

    /**
     * @param MemberLanguage[] $MemberLanguage
     * @return \Gueststream\PMS\IQWare\API\ArrayOfMemberLanguage
     */
    public function setMemberLanguage(array $MemberLanguage = null)
    {
        $this->MemberLanguage = $MemberLanguage;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->MemberLanguage[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return MemberLanguage
     */
    public function offsetGet($offset)
    {
        return $this->MemberLanguage[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param MemberLanguage $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->MemberLanguage[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->MemberLanguage[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return MemberLanguage Return the current element
     */
    public function current()
    {
        return current($this->MemberLanguage);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->MemberLanguage);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->MemberLanguage);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->MemberLanguage);
    }

    /**
     * Countable implementation
     *
     * @return MemberLanguage Return count of elements
     */
    public function count()
    {
        return count($this->MemberLanguage);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfMemberReservation implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var MemberReservation[] $MemberReservation
     */
    protected $MemberReservation = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return MemberReservation[]
     */
    public function getMemberReservation()
    {
        return $this->MemberReservation;
    }

    /**
     * @param MemberReservation[] $MemberReservation
     * @return \Gueststream\PMS\IQWare\API\ArrayOfMemberReservation
     */
    public function setMemberReservation(array $MemberReservation = null)
    {
        $this->MemberReservation = $MemberReservation;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->MemberReservation[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return MemberReservation
     */
    public function offsetGet($offset)
    {
        return $this->MemberReservation[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param MemberReservation $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->MemberReservation[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->MemberReservation[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return MemberReservation Return the current element
     */
    public function current()
    {
        return current($this->MemberReservation);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->MemberReservation);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->MemberReservation);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->MemberReservation);
    }

    /**
     * Countable implementation
     *
     * @return MemberReservation Return count of elements
     */
    public function count()
    {
        return count($this->MemberReservation);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfNationality implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var Nationality[] $Nationality
     */
    protected $Nationality = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return Nationality[]
     */
    public function getNationality()
    {
        return $this->Nationality;
    }

    /**
     * @param Nationality[] $Nationality
     * @return \Gueststream\PMS\IQWare\API\ArrayOfNationality
     */
    public function setNationality(array $Nationality = null)
    {
        $this->Nationality = $Nationality;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->Nationality[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return Nationality
     */
    public function offsetGet($offset)
    {
        return $this->Nationality[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param Nationality $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->Nationality[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->Nationality[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return Nationality Return the current element
     */
    public function current()
    {
        return current($this->Nationality);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->Nationality);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->Nationality);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->Nationality);
    }

    /**
     * Countable implementation
     *
     * @return Nationality Return count of elements
     */
    public function count()
    {
        return count($this->Nationality);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfOaccAddress implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var oaccAddress[] $oaccAddress
     */
    protected $oaccAddress = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return oaccAddress[]
     */
    public function getOaccAddress()
    {
        return $this->oaccAddress;
    }

    /**
     * @param oaccAddress[] $oaccAddress
     * @return \Gueststream\PMS\IQWare\API\ArrayOfOaccAddress
     */
    public function setOaccAddress(array $oaccAddress = null)
    {
        $this->oaccAddress = $oaccAddress;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->oaccAddress[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return oaccAddress
     */
    public function offsetGet($offset)
    {
        return $this->oaccAddress[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param oaccAddress $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->oaccAddress[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->oaccAddress[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return oaccAddress Return the current element
     */
    public function current()
    {
        return current($this->oaccAddress);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->oaccAddress);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->oaccAddress);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->oaccAddress);
    }

    /**
     * Countable implementation
     *
     * @return oaccAddress Return count of elements
     */
    public function count()
    {
        return count($this->oaccAddress);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfOaccTelephone implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var OaccTelephone[] $oaccTelephone
     */
    protected $oaccTelephone = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return OaccTelephone[]
     */
    public function getOaccTelephone()
    {
        return $this->oaccTelephone;
    }

    /**
     * @param OaccTelephone[] $oaccTelephone
     *
*@return \Gueststream\PMS\IQWare\API\ArrayOfOaccTelephone
     */
    public function setOaccTelephone(array $oaccTelephone = null)
    {
        $this->oaccTelephone = $oaccTelephone;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->oaccTelephone[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     *
*@return OaccTelephone
     */
    public function offsetGet($offset)
    {
        return $this->oaccTelephone[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param OaccTelephone $value The value to set
     *
*@return void
     */
    public function offsetSet($offset, $value)
    {
        $this->oaccTelephone[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->oaccTelephone[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return OaccTelephone Return the current element
     */
    public function current()
    {
        return current($this->oaccTelephone);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->oaccTelephone);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->oaccTelephone);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->oaccTelephone);
    }

    /**
     * Countable implementation
     *
     * @return OaccTelephone Return count of elements
     */
    public function count()
    {
        return count($this->oaccTelephone);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfOwnerInvoiceInfo implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var OwnerInvoiceInfo[] $OwnerInvoiceInfo
     */
    protected $OwnerInvoiceInfo = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return OwnerInvoiceInfo[]
     */
    public function getOwnerInvoiceInfo()
    {
        return $this->OwnerInvoiceInfo;
    }

    /**
     * @param OwnerInvoiceInfo[] $OwnerInvoiceInfo
     * @return \Gueststream\PMS\IQWare\API\ArrayOfOwnerInvoiceInfo
     */
    public function setOwnerInvoiceInfo(array $OwnerInvoiceInfo = null)
    {
        $this->OwnerInvoiceInfo = $OwnerInvoiceInfo;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->OwnerInvoiceInfo[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return OwnerInvoiceInfo
     */
    public function offsetGet($offset)
    {
        return $this->OwnerInvoiceInfo[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param OwnerInvoiceInfo $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->OwnerInvoiceInfo[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->OwnerInvoiceInfo[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return OwnerInvoiceInfo Return the current element
     */
    public function current()
    {
        return current($this->OwnerInvoiceInfo);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->OwnerInvoiceInfo);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->OwnerInvoiceInfo);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->OwnerInvoiceInfo);
    }

    /**
     * Countable implementation
     *
     * @return OwnerInvoiceInfo Return count of elements
     */
    public function count()
    {
        return count($this->OwnerInvoiceInfo);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRateCode implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RateCode[] $RateCode
     */
    protected $RateCode = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RateCode[]
     */
    public function getRateCode()
    {
        return $this->RateCode;
    }

    /**
     * @param RateCode[] $RateCode
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRateCode
     */
    public function setRateCode(array $RateCode = null)
    {
        $this->RateCode = $RateCode;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RateCode[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RateCode
     */
    public function offsetGet($offset)
    {
        return $this->RateCode[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RateCode $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RateCode[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RateCode[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RateCode Return the current element
     */
    public function current()
    {
        return current($this->RateCode);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RateCode);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RateCode);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RateCode);
    }

    /**
     * Countable implementation
     *
     * @return RateCode Return count of elements
     */
    public function count()
    {
        return count($this->RateCode);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRateReason implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RateReason[] $RateReason
     */
    protected $RateReason = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RateReason[]
     */
    public function getRateReason()
    {
        return $this->RateReason;
    }

    /**
     * @param RateReason[] $RateReason
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRateReason
     */
    public function setRateReason(array $RateReason = null)
    {
        $this->RateReason = $RateReason;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RateReason[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RateReason
     */
    public function offsetGet($offset)
    {
        return $this->RateReason[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RateReason $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RateReason[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RateReason[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RateReason Return the current element
     */
    public function current()
    {
        return current($this->RateReason);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RateReason);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RateReason);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RateReason);
    }

    /**
     * Countable implementation
     *
     * @return RateReason Return count of elements
     */
    public function count()
    {
        return count($this->RateReason);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRatesDetails implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RatesDetails[] $RatesDetails
     */
    protected $RatesDetails = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RatesDetails[]
     */
    public function getRatesDetails()
    {
        return $this->RatesDetails;
    }

    /**
     * @param RatesDetails[] $RatesDetails
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRatesDetails
     */
    public function setRatesDetails(array $RatesDetails = null)
    {
        $this->RatesDetails = $RatesDetails;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RatesDetails[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RatesDetails
     */
    public function offsetGet($offset)
    {
        return $this->RatesDetails[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RatesDetails $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RatesDetails[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RatesDetails[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RatesDetails Return the current element
     */
    public function current()
    {
        return current($this->RatesDetails);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RatesDetails);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RatesDetails);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RatesDetails);
    }

    /**
     * Countable implementation
     *
     * @return RatesDetails Return count of elements
     */
    public function count()
    {
        return count($this->RatesDetails);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRateSpecialValidPeriod implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RateSpecialValidPeriod[] $RateSpecialValidPeriod
     */
    protected $RateSpecialValidPeriod = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RateSpecialValidPeriod[]
     */
    public function getRateSpecialValidPeriod()
    {
        return $this->RateSpecialValidPeriod;
    }

    /**
     * @param RateSpecialValidPeriod[] $RateSpecialValidPeriod
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRateSpecialValidPeriod
     */
    public function setRateSpecialValidPeriod(array $RateSpecialValidPeriod = null)
    {
        $this->RateSpecialValidPeriod = $RateSpecialValidPeriod;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RateSpecialValidPeriod[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RateSpecialValidPeriod
     */
    public function offsetGet($offset)
    {
        return $this->RateSpecialValidPeriod[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RateSpecialValidPeriod $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RateSpecialValidPeriod[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RateSpecialValidPeriod[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RateSpecialValidPeriod Return the current element
     */
    public function current()
    {
        return current($this->RateSpecialValidPeriod);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RateSpecialValidPeriod);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RateSpecialValidPeriod);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RateSpecialValidPeriod);
    }

    /**
     * Countable implementation
     *
     * @return RateSpecialValidPeriod Return count of elements
     */
    public function count()
    {
        return count($this->RateSpecialValidPeriod);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRefusal implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var Refusal[] $Refusal
     */
    protected $Refusal = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return Refusal[]
     */
    public function getRefusal()
    {
        return $this->Refusal;
    }

    /**
     * @param Refusal[] $Refusal
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRefusal
     */
    public function setRefusal(array $Refusal = null)
    {
        $this->Refusal = $Refusal;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->Refusal[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return Refusal
     */
    public function offsetGet($offset)
    {
        return $this->Refusal[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param Refusal $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->Refusal[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->Refusal[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return Refusal Return the current element
     */
    public function current()
    {
        return current($this->Refusal);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->Refusal);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->Refusal);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->Refusal);
    }

    /**
     * Countable implementation
     *
     * @return Refusal Return count of elements
     */
    public function count()
    {
        return count($this->Refusal);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomAttribute implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomAttribute[] $RoomAttribute
     */
    protected $RoomAttribute = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomAttribute[]
     */
    public function getRoomAttribute()
    {
        return $this->RoomAttribute;
    }

    /**
     * @param RoomAttribute[] $RoomAttribute
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomAttribute
     */
    public function setRoomAttribute(array $RoomAttribute = null)
    {
        $this->RoomAttribute = $RoomAttribute;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomAttribute[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomAttribute
     */
    public function offsetGet($offset)
    {
        return $this->RoomAttribute[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomAttribute $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomAttribute[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomAttribute[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomAttribute Return the current element
     */
    public function current()
    {
        return current($this->RoomAttribute);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomAttribute);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomAttribute);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomAttribute);
    }

    /**
     * Countable implementation
     *
     * @return RoomAttribute Return count of elements
     */
    public function count()
    {
        return count($this->RoomAttribute);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomAttributGrouping implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomAttributGrouping[] $RoomAttributGrouping
     */
    protected $RoomAttributGrouping = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomAttributGrouping[]
     */
    public function getRoomAttributGrouping()
    {
        return $this->RoomAttributGrouping;
    }

    /**
     * @param RoomAttributGrouping[] $RoomAttributGrouping
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomAttributGrouping
     */
    public function setRoomAttributGrouping(array $RoomAttributGrouping = null)
    {
        $this->RoomAttributGrouping = $RoomAttributGrouping;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomAttributGrouping[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomAttributGrouping
     */
    public function offsetGet($offset)
    {
        return $this->RoomAttributGrouping[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomAttributGrouping $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomAttributGrouping[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomAttributGrouping[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomAttributGrouping Return the current element
     */
    public function current()
    {
        return current($this->RoomAttributGrouping);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomAttributGrouping);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomAttributGrouping);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomAttributGrouping);
    }

    /**
     * Countable implementation
     *
     * @return RoomAttributGrouping Return count of elements
     */
    public function count()
    {
        return count($this->RoomAttributGrouping);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomAvailabilityForStay implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomAvailabilityForStay[] $RoomAvailabilityForStay
     */
    protected $RoomAvailabilityForStay = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomAvailabilityForStay[]
     */
    public function getRoomAvailabilityForStay()
    {
        return $this->RoomAvailabilityForStay;
    }

    /**
     * @param RoomAvailabilityForStay[] $RoomAvailabilityForStay
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomAvailabilityForStay
     */
    public function setRoomAvailabilityForStay(array $RoomAvailabilityForStay = null)
    {
        $this->RoomAvailabilityForStay = $RoomAvailabilityForStay;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomAvailabilityForStay[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomAvailabilityForStay
     */
    public function offsetGet($offset)
    {
        return $this->RoomAvailabilityForStay[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomAvailabilityForStay $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomAvailabilityForStay[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomAvailabilityForStay[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomAvailabilityForStay Return the current element
     */
    public function current()
    {
        return current($this->RoomAvailabilityForStay);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomAvailabilityForStay);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomAvailabilityForStay);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomAvailabilityForStay);
    }

    /**
     * Countable implementation
     *
     * @return RoomAvailabilityForStay Return count of elements
     */
    public function count()
    {
        return count($this->RoomAvailabilityForStay);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomCalendar implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomCalendar[] $RoomCalendar
     */
    protected $RoomCalendar = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomCalendar[]
     */
    public function getRoomCalendar()
    {
        return $this->RoomCalendar;
    }

    /**
     * @param RoomCalendar[] $RoomCalendar
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomCalendar
     */
    public function setRoomCalendar(array $RoomCalendar = null)
    {
        $this->RoomCalendar = $RoomCalendar;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomCalendar[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomCalendar
     */
    public function offsetGet($offset)
    {
        return $this->RoomCalendar[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomCalendar $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomCalendar[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomCalendar[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomCalendar Return the current element
     */
    public function current()
    {
        return current($this->RoomCalendar);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomCalendar);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomCalendar);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomCalendar);
    }

    /**
     * Countable implementation
     *
     * @return RoomCalendar Return count of elements
     */
    public function count()
    {
        return count($this->RoomCalendar);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomCalendarBreakdown implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomCalendarBreakdown[] $RoomCalendarBreakdown
     */
    protected $RoomCalendarBreakdown = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomCalendarBreakdown[]
     */
    public function getRoomCalendarBreakdown()
    {
        return $this->RoomCalendarBreakdown;
    }

    /**
     * @param RoomCalendarBreakdown[] $RoomCalendarBreakdown
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomCalendarBreakdown
     */
    public function setRoomCalendarBreakdown(array $RoomCalendarBreakdown = null)
    {
        $this->RoomCalendarBreakdown = $RoomCalendarBreakdown;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomCalendarBreakdown[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomCalendarBreakdown
     */
    public function offsetGet($offset)
    {
        return $this->RoomCalendarBreakdown[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomCalendarBreakdown $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomCalendarBreakdown[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomCalendarBreakdown[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomCalendarBreakdown Return the current element
     */
    public function current()
    {
        return current($this->RoomCalendarBreakdown);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomCalendarBreakdown);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomCalendarBreakdown);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomCalendarBreakdown);
    }

    /**
     * Countable implementation
     *
     * @return RoomCalendarBreakdown Return count of elements
     */
    public function count()
    {
        return count($this->RoomCalendarBreakdown);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomDayAvailability implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomDayAvailability[] $RoomDayAvailability
     */
    protected $RoomDayAvailability = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomDayAvailability[]
     */
    public function getRoomDayAvailability()
    {
        return $this->RoomDayAvailability;
    }

    /**
     * @param RoomDayAvailability[] $RoomDayAvailability
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomDayAvailability
     */
    public function setRoomDayAvailability(array $RoomDayAvailability = null)
    {
        $this->RoomDayAvailability = $RoomDayAvailability;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomDayAvailability[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomDayAvailability
     */
    public function offsetGet($offset)
    {
        return $this->RoomDayAvailability[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomDayAvailability $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomDayAvailability[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomDayAvailability[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomDayAvailability Return the current element
     */
    public function current()
    {
        return current($this->RoomDayAvailability);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomDayAvailability);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomDayAvailability);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomDayAvailability);
    }

    /**
     * Countable implementation
     *
     * @return RoomDayAvailability Return count of elements
     */
    public function count()
    {
        return count($this->RoomDayAvailability);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomInventory implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomInventory[] $RoomInventory
     */
    protected $RoomInventory = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomInventory[]
     */
    public function getRoomInventory()
    {
        return $this->RoomInventory;
    }

    /**
     * @param RoomInventory[] $RoomInventory
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomInventory
     */
    public function setRoomInventory(array $RoomInventory = null)
    {
        $this->RoomInventory = $RoomInventory;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomInventory[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomInventory
     */
    public function offsetGet($offset)
    {
        return $this->RoomInventory[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomInventory $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomInventory[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomInventory[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomInventory Return the current element
     */
    public function current()
    {
        return current($this->RoomInventory);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomInventory);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomInventory);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomInventory);
    }

    /**
     * Countable implementation
     *
     * @return RoomInventory Return count of elements
     */
    public function count()
    {
        return count($this->RoomInventory);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomLocation implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomLocation[] $RoomLocation
     */
    protected $RoomLocation = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomLocation[]
     */
    public function getRoomLocation()
    {
        return $this->RoomLocation;
    }

    /**
     * @param RoomLocation[] $RoomLocation
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomLocation
     */
    public function setRoomLocation(array $RoomLocation = null)
    {
        $this->RoomLocation = $RoomLocation;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomLocation[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomLocation
     */
    public function offsetGet($offset)
    {
        return $this->RoomLocation[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomLocation $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomLocation[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomLocation[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomLocation Return the current element
     */
    public function current()
    {
        return current($this->RoomLocation);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomLocation);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomLocation);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomLocation);
    }

    /**
     * Countable implementation
     *
     * @return RoomLocation Return count of elements
     */
    public function count()
    {
        return count($this->RoomLocation);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomLocationGrouping implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomLocationGrouping[] $RoomLocationGrouping
     */
    protected $RoomLocationGrouping = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomLocationGrouping[]
     */
    public function getRoomLocationGrouping()
    {
        return $this->RoomLocationGrouping;
    }

    /**
     * @param RoomLocationGrouping[] $RoomLocationGrouping
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomLocationGrouping
     */
    public function setRoomLocationGrouping(array $RoomLocationGrouping = null)
    {
        $this->RoomLocationGrouping = $RoomLocationGrouping;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomLocationGrouping[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomLocationGrouping
     */
    public function offsetGet($offset)
    {
        return $this->RoomLocationGrouping[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomLocationGrouping $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomLocationGrouping[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomLocationGrouping[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomLocationGrouping Return the current element
     */
    public function current()
    {
        return current($this->RoomLocationGrouping);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomLocationGrouping);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomLocationGrouping);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomLocationGrouping);
    }

    /**
     * Countable implementation
     *
     * @return RoomLocationGrouping Return count of elements
     */
    public function count()
    {
        return count($this->RoomLocationGrouping);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomSpecification implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomSpecification[] $RoomSpecification
     */
    protected $RoomSpecification = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomSpecification[]
     */
    public function getRoomSpecification()
    {
        return $this->RoomSpecification;
    }

    /**
     * @param RoomSpecification[] $RoomSpecification
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomSpecification
     */
    public function setRoomSpecification(array $RoomSpecification = null)
    {
        $this->RoomSpecification = $RoomSpecification;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomSpecification[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomSpecification
     */
    public function offsetGet($offset)
    {
        return $this->RoomSpecification[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomSpecification $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomSpecification[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomSpecification[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomSpecification Return the current element
     */
    public function current()
    {
        return current($this->RoomSpecification);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomSpecification);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomSpecification);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomSpecification);
    }

    /**
     * Countable implementation
     *
     * @return RoomSpecification Return count of elements
     */
    public function count()
    {
        return count($this->RoomSpecification);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomType implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomType[] $RoomType
     */
    protected $RoomType = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomType[]
     */
    public function getRoomType()
    {
        return $this->RoomType;
    }

    /**
     * @param RoomType[] $RoomType
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomType
     */
    public function setRoomType(array $RoomType = null)
    {
        $this->RoomType = $RoomType;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomType[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomType
     */
    public function offsetGet($offset)
    {
        return $this->RoomType[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomType $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomType[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomType[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomType Return the current element
     */
    public function current()
    {
        return current($this->RoomType);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomType);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomType);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomType);
    }

    /**
     * Countable implementation
     *
     * @return RoomType Return count of elements
     */
    public function count()
    {
        return count($this->RoomType);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomTypeAvailability implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomTypeAvailability[] $RoomTypeAvailability
     */
    protected $RoomTypeAvailability = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomTypeAvailability[]
     */
    public function getRoomTypeAvailability()
    {
        return $this->RoomTypeAvailability;
    }

    /**
     * @param RoomTypeAvailability[] $RoomTypeAvailability
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomTypeAvailability
     */
    public function setRoomTypeAvailability(array $RoomTypeAvailability = null)
    {
        $this->RoomTypeAvailability = $RoomTypeAvailability;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomTypeAvailability[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomTypeAvailability
     */
    public function offsetGet($offset)
    {
        return $this->RoomTypeAvailability[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomTypeAvailability $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomTypeAvailability[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomTypeAvailability[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomTypeAvailability Return the current element
     */
    public function current()
    {
        return current($this->RoomTypeAvailability);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomTypeAvailability);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomTypeAvailability);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomTypeAvailability);
    }

    /**
     * Countable implementation
     *
     * @return RoomTypeAvailability Return count of elements
     */
    public function count()
    {
        return count($this->RoomTypeAvailability);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomTypeBreakdown implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomTypeBreakdown[] $RoomTypeBreakdown
     */
    protected $RoomTypeBreakdown = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomTypeBreakdown[]
     */
    public function getRoomTypeBreakdown()
    {
        return $this->RoomTypeBreakdown;
    }

    /**
     * @param RoomTypeBreakdown[] $RoomTypeBreakdown
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomTypeBreakdown
     */
    public function setRoomTypeBreakdown(array $RoomTypeBreakdown = null)
    {
        $this->RoomTypeBreakdown = $RoomTypeBreakdown;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomTypeBreakdown[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomTypeBreakdown
     */
    public function offsetGet($offset)
    {
        return $this->RoomTypeBreakdown[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomTypeBreakdown $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomTypeBreakdown[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomTypeBreakdown[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomTypeBreakdown Return the current element
     */
    public function current()
    {
        return current($this->RoomTypeBreakdown);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomTypeBreakdown);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomTypeBreakdown);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomTypeBreakdown);
    }

    /**
     * Countable implementation
     *
     * @return RoomTypeBreakdown Return count of elements
     */
    public function count()
    {
        return count($this->RoomTypeBreakdown);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomTypeBuildingsAndPL implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomTypeBuildingsAndPL[] $RoomTypeBuildingsAndPL
     */
    protected $RoomTypeBuildingsAndPL = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomTypeBuildingsAndPL[]
     */
    public function getRoomTypeBuildingsAndPL()
    {
        return $this->RoomTypeBuildingsAndPL;
    }

    /**
     * @param RoomTypeBuildingsAndPL[] $RoomTypeBuildingsAndPL
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomTypeBuildingsAndPL
     */
    public function setRoomTypeBuildingsAndPL(array $RoomTypeBuildingsAndPL = null)
    {
        $this->RoomTypeBuildingsAndPL = $RoomTypeBuildingsAndPL;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomTypeBuildingsAndPL[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomTypeBuildingsAndPL
     */
    public function offsetGet($offset)
    {
        return $this->RoomTypeBuildingsAndPL[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomTypeBuildingsAndPL $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomTypeBuildingsAndPL[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomTypeBuildingsAndPL[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomTypeBuildingsAndPL Return the current element
     */
    public function current()
    {
        return current($this->RoomTypeBuildingsAndPL);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomTypeBuildingsAndPL);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomTypeBuildingsAndPL);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomTypeBuildingsAndPL);
    }

    /**
     * Countable implementation
     *
     * @return RoomTypeBuildingsAndPL Return count of elements
     */
    public function count()
    {
        return count($this->RoomTypeBuildingsAndPL);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomTypeCluster implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomTypeCluster[] $RoomTypeCluster
     */
    protected $RoomTypeCluster = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomTypeCluster[]
     */
    public function getRoomTypeCluster()
    {
        return $this->RoomTypeCluster;
    }

    /**
     * @param RoomTypeCluster[] $RoomTypeCluster
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomTypeCluster
     */
    public function setRoomTypeCluster(array $RoomTypeCluster = null)
    {
        $this->RoomTypeCluster = $RoomTypeCluster;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomTypeCluster[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomTypeCluster
     */
    public function offsetGet($offset)
    {
        return $this->RoomTypeCluster[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomTypeCluster $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomTypeCluster[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomTypeCluster[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomTypeCluster Return the current element
     */
    public function current()
    {
        return current($this->RoomTypeCluster);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomTypeCluster);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomTypeCluster);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomTypeCluster);
    }

    /**
     * Countable implementation
     *
     * @return RoomTypeCluster Return count of elements
     */
    public function count()
    {
        return count($this->RoomTypeCluster);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfRoomTypeClusterResult implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var RoomTypeClusterResult[] $RoomTypeClusterResult
     */
    protected $RoomTypeClusterResult = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return RoomTypeClusterResult[]
     */
    public function getRoomTypeClusterResult()
    {
        return $this->RoomTypeClusterResult;
    }

    /**
     * @param RoomTypeClusterResult[] $RoomTypeClusterResult
     * @return \Gueststream\PMS\IQWare\API\ArrayOfRoomTypeClusterResult
     */
    public function setRoomTypeClusterResult(array $RoomTypeClusterResult = null)
    {
        $this->RoomTypeClusterResult = $RoomTypeClusterResult;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->RoomTypeClusterResult[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return RoomTypeClusterResult
     */
    public function offsetGet($offset)
    {
        return $this->RoomTypeClusterResult[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param RoomTypeClusterResult $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->RoomTypeClusterResult[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->RoomTypeClusterResult[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return RoomTypeClusterResult Return the current element
     */
    public function current()
    {
        return current($this->RoomTypeClusterResult);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->RoomTypeClusterResult);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->RoomTypeClusterResult);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->RoomTypeClusterResult);
    }

    /**
     * Countable implementation
     *
     * @return RoomTypeClusterResult Return count of elements
     */
    public function count()
    {
        return count($this->RoomTypeClusterResult);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfSBDSummary implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var SBDSummary[] $SBDSummary
     */
    protected $SBDSummary = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return SBDSummary[]
     */
    public function getSBDSummary()
    {
        return $this->SBDSummary;
    }

    /**
     * @param SBDSummary[] $SBDSummary
     * @return \Gueststream\PMS\IQWare\API\ArrayOfSBDSummary
     */
    public function setSBDSummary(array $SBDSummary = null)
    {
        $this->SBDSummary = $SBDSummary;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->SBDSummary[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return SBDSummary
     */
    public function offsetGet($offset)
    {
        return $this->SBDSummary[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param SBDSummary $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->SBDSummary[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->SBDSummary[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return SBDSummary Return the current element
     */
    public function current()
    {
        return current($this->SBDSummary);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->SBDSummary);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->SBDSummary);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->SBDSummary);
    }

    /**
     * Countable implementation
     *
     * @return SBDSummary Return count of elements
     */
    public function count()
    {
        return count($this->SBDSummary);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfServiceCharge implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var ServiceCharge[] $ServiceCharge
     */
    protected $ServiceCharge = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return ServiceCharge[]
     */
    public function getServiceCharge()
    {
        return $this->ServiceCharge;
    }

    /**
     * @param ServiceCharge[] $ServiceCharge
     * @return \Gueststream\PMS\IQWare\API\ArrayOfServiceCharge
     */
    public function setServiceCharge(array $ServiceCharge = null)
    {
        $this->ServiceCharge = $ServiceCharge;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->ServiceCharge[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return ServiceCharge
     */
    public function offsetGet($offset)
    {
        return $this->ServiceCharge[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param ServiceCharge $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->ServiceCharge[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->ServiceCharge[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return ServiceCharge Return the current element
     */
    public function current()
    {
        return current($this->ServiceCharge);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->ServiceCharge);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->ServiceCharge);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->ServiceCharge);
    }

    /**
     * Countable implementation
     *
     * @return ServiceCharge Return count of elements
     */
    public function count()
    {
        return count($this->ServiceCharge);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfShort implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var short[] $short
     */
    protected $short = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return short[]
     */
    public function getShort()
    {
        return $this->short;
    }

    /**
     * @param short[] $short
     * @return \Gueststream\PMS\IQWare\API\ArrayOfShort
     */
    public function setShort(array $short = null)
    {
        $this->short = $short;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->short[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return short
     */
    public function offsetGet($offset)
    {
        return $this->short[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param short $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->short[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->short[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return short Return the current element
     */
    public function current()
    {
        return current($this->short);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->short);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->short);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->short);
    }

    /**
     * Countable implementation
     *
     * @return short Return count of elements
     */
    public function count()
    {
        return count($this->short);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfSpecialData implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var SpecialData[] $SpecialData
     */
    protected $SpecialData = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return SpecialData[]
     */
    public function getSpecialData()
    {
        return $this->SpecialData;
    }

    /**
     * @param SpecialData[] $SpecialData
     * @return \Gueststream\PMS\IQWare\API\ArrayOfSpecialData
     */
    public function setSpecialData(array $SpecialData = null)
    {
        $this->SpecialData = $SpecialData;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->SpecialData[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return SpecialData
     */
    public function offsetGet($offset)
    {
        return $this->SpecialData[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param SpecialData $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->SpecialData[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->SpecialData[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return SpecialData Return the current element
     */
    public function current()
    {
        return current($this->SpecialData);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->SpecialData);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->SpecialData);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->SpecialData);
    }

    /**
     * Countable implementation
     *
     * @return SpecialData Return count of elements
     */
    public function count()
    {
        return count($this->SpecialData);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfSpecialOfferByDay implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var SpecialOfferByDay[] $SpecialOfferByDay
     */
    protected $SpecialOfferByDay = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return SpecialOfferByDay[]
     */
    public function getSpecialOfferByDay()
    {
        return $this->SpecialOfferByDay;
    }

    /**
     * @param SpecialOfferByDay[] $SpecialOfferByDay
     * @return \Gueststream\PMS\IQWare\API\ArrayOfSpecialOfferByDay
     */
    public function setSpecialOfferByDay(array $SpecialOfferByDay = null)
    {
        $this->SpecialOfferByDay = $SpecialOfferByDay;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->SpecialOfferByDay[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return SpecialOfferByDay
     */
    public function offsetGet($offset)
    {
        return $this->SpecialOfferByDay[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param SpecialOfferByDay $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->SpecialOfferByDay[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->SpecialOfferByDay[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return SpecialOfferByDay Return the current element
     */
    public function current()
    {
        return current($this->SpecialOfferByDay);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->SpecialOfferByDay);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->SpecialOfferByDay);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->SpecialOfferByDay);
    }

    /**
     * Countable implementation
     *
     * @return SpecialOfferByDay Return count of elements
     */
    public function count()
    {
        return count($this->SpecialOfferByDay);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfSpecialOffers implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var SpecialOffers[] $SpecialOffers
     */
    protected $SpecialOffers = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return SpecialOffers[]
     */
    public function getSpecialOffers()
    {
        return $this->SpecialOffers;
    }

    /**
     * @param SpecialOffers[] $SpecialOffers
     * @return \Gueststream\PMS\IQWare\API\ArrayOfSpecialOffers
     */
    public function setSpecialOffers(array $SpecialOffers = null)
    {
        $this->SpecialOffers = $SpecialOffers;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->SpecialOffers[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return SpecialOffers
     */
    public function offsetGet($offset)
    {
        return $this->SpecialOffers[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param SpecialOffers $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->SpecialOffers[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->SpecialOffers[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return SpecialOffers Return the current element
     */
    public function current()
    {
        return current($this->SpecialOffers);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->SpecialOffers);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->SpecialOffers);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->SpecialOffers);
    }

    /**
     * Countable implementation
     *
     * @return SpecialOffers Return count of elements
     */
    public function count()
    {
        return count($this->SpecialOffers);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfSpecificDayOccupancyValue implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var SpecificDayOccupancyValue[] $SpecificDayOccupancyValue
     */
    protected $SpecificDayOccupancyValue = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return SpecificDayOccupancyValue[]
     */
    public function getSpecificDayOccupancyValue()
    {
        return $this->SpecificDayOccupancyValue;
    }

    /**
     * @param SpecificDayOccupancyValue[] $SpecificDayOccupancyValue
     * @return \Gueststream\PMS\IQWare\API\ArrayOfSpecificDayOccupancyValue
     */
    public function setSpecificDayOccupancyValue(array $SpecificDayOccupancyValue = null)
    {
        $this->SpecificDayOccupancyValue = $SpecificDayOccupancyValue;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->SpecificDayOccupancyValue[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return SpecificDayOccupancyValue
     */
    public function offsetGet($offset)
    {
        return $this->SpecificDayOccupancyValue[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param SpecificDayOccupancyValue $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->SpecificDayOccupancyValue[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->SpecificDayOccupancyValue[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return SpecificDayOccupancyValue Return the current element
     */
    public function current()
    {
        return current($this->SpecificDayOccupancyValue);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->SpecificDayOccupancyValue);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->SpecificDayOccupancyValue);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->SpecificDayOccupancyValue);
    }

    /**
     * Countable implementation
     *
     * @return SpecificDayOccupancyValue Return count of elements
     */
    public function count()
    {
        return count($this->SpecificDayOccupancyValue);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfStayByNightValue implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var StayByNightValue[] $StayByNightValue
     */
    protected $StayByNightValue = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return StayByNightValue[]
     */
    public function getStayByNightValue()
    {
        return $this->StayByNightValue;
    }

    /**
     * @param StayByNightValue[] $StayByNightValue
     * @return \Gueststream\PMS\IQWare\API\ArrayOfStayByNightValue
     */
    public function setStayByNightValue(array $StayByNightValue = null)
    {
        $this->StayByNightValue = $StayByNightValue;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->StayByNightValue[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return StayByNightValue
     */
    public function offsetGet($offset)
    {
        return $this->StayByNightValue[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param StayByNightValue $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->StayByNightValue[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->StayByNightValue[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return StayByNightValue Return the current element
     */
    public function current()
    {
        return current($this->StayByNightValue);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->StayByNightValue);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->StayByNightValue);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->StayByNightValue);
    }

    /**
     * Countable implementation
     *
     * @return StayByNightValue Return count of elements
     */
    public function count()
    {
        return count($this->StayByNightValue);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfStayDailyValue implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var StayDailyValue[] $StayDailyValue
     */
    protected $StayDailyValue = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return StayDailyValue[]
     */
    public function getStayDailyValue()
    {
        return $this->StayDailyValue;
    }

    /**
     * @param StayDailyValue[] $StayDailyValue
     * @return \Gueststream\PMS\IQWare\API\ArrayOfStayDailyValue
     */
    public function setStayDailyValue(array $StayDailyValue = null)
    {
        $this->StayDailyValue = $StayDailyValue;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->StayDailyValue[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return StayDailyValue
     */
    public function offsetGet($offset)
    {
        return $this->StayDailyValue[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param StayDailyValue $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->StayDailyValue[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->StayDailyValue[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return StayDailyValue Return the current element
     */
    public function current()
    {
        return current($this->StayDailyValue);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->StayDailyValue);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->StayDailyValue);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->StayDailyValue);
    }

    /**
     * Countable implementation
     *
     * @return StayDailyValue Return count of elements
     */
    public function count()
    {
        return count($this->StayDailyValue);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfStayValue implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var StayValue[] $StayValue
     */
    protected $StayValue = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return StayValue[]
     */
    public function getStayValue()
    {
        return $this->StayValue;
    }

    /**
     * @param StayValue[] $StayValue
     * @return \Gueststream\PMS\IQWare\API\ArrayOfStayValue
     */
    public function setStayValue(array $StayValue = null)
    {
        $this->StayValue = $StayValue;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->StayValue[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return StayValue
     */
    public function offsetGet($offset)
    {
        return $this->StayValue[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param StayValue $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->StayValue[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->StayValue[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return StayValue Return the current element
     */
    public function current()
    {
        return current($this->StayValue);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->StayValue);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->StayValue);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->StayValue);
    }

    /**
     * Countable implementation
     *
     * @return StayValue Return count of elements
     */
    public function count()
    {
        return count($this->StayValue);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfStayValue3 implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var StayValue3[] $StayValue3
     */
    protected $StayValue3 = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return StayValue3[]
     */
    public function getStayValue3()
    {
        return $this->StayValue3;
    }

    /**
     * @param StayValue3[] $StayValue3
     * @return \Gueststream\PMS\IQWare\API\ArrayOfStayValue3
     */
    public function setStayValue3(array $StayValue3 = null)
    {
        $this->StayValue3 = $StayValue3;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->StayValue3[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return StayValue3
     */
    public function offsetGet($offset)
    {
        return $this->StayValue3[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param StayValue3 $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->StayValue3[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->StayValue3[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return StayValue3 Return the current element
     */
    public function current()
    {
        return current($this->StayValue3);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->StayValue3);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->StayValue3);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->StayValue3);
    }

    /**
     * Countable implementation
     *
     * @return StayValue3 Return count of elements
     */
    public function count()
    {
        return count($this->StayValue3);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfSuiteInventory implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var SuiteInventory[] $SuiteInventory
     */
    protected $SuiteInventory = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return SuiteInventory[]
     */
    public function getSuiteInventory()
    {
        return $this->SuiteInventory;
    }

    /**
     * @param SuiteInventory[] $SuiteInventory
     * @return \Gueststream\PMS\IQWare\API\ArrayOfSuiteInventory
     */
    public function setSuiteInventory(array $SuiteInventory = null)
    {
        $this->SuiteInventory = $SuiteInventory;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->SuiteInventory[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return SuiteInventory
     */
    public function offsetGet($offset)
    {
        return $this->SuiteInventory[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param SuiteInventory $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->SuiteInventory[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->SuiteInventory[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return SuiteInventory Return the current element
     */
    public function current()
    {
        return current($this->SuiteInventory);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->SuiteInventory);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->SuiteInventory);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->SuiteInventory);
    }

    /**
     * Countable implementation
     *
     * @return SuiteInventory Return count of elements
     */
    public function count()
    {
        return count($this->SuiteInventory);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfSuiteItems implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var SuiteItems[] $SuiteItems
     */
    protected $SuiteItems = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return SuiteItems[]
     */
    public function getSuiteItems()
    {
        return $this->SuiteItems;
    }

    /**
     * @param SuiteItems[] $SuiteItems
     * @return \Gueststream\PMS\IQWare\API\ArrayOfSuiteItems
     */
    public function setSuiteItems(array $SuiteItems = null)
    {
        $this->SuiteItems = $SuiteItems;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->SuiteItems[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return SuiteItems
     */
    public function offsetGet($offset)
    {
        return $this->SuiteItems[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param SuiteItems $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->SuiteItems[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->SuiteItems[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return SuiteItems Return the current element
     */
    public function current()
    {
        return current($this->SuiteItems);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->SuiteItems);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->SuiteItems);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->SuiteItems);
    }

    /**
     * Countable implementation
     *
     * @return SuiteItems Return count of elements
     */
    public function count()
    {
        return count($this->SuiteItems);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfSuitesSpecification implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var SuitesSpecification[] $SuitesSpecification
     */
    protected $SuitesSpecification = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return SuitesSpecification[]
     */
    public function getSuitesSpecification()
    {
        return $this->SuitesSpecification;
    }

    /**
     * @param SuitesSpecification[] $SuitesSpecification
     * @return \Gueststream\PMS\IQWare\API\ArrayOfSuitesSpecification
     */
    public function setSuitesSpecification(array $SuitesSpecification = null)
    {
        $this->SuitesSpecification = $SuitesSpecification;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->SuitesSpecification[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return SuitesSpecification
     */
    public function offsetGet($offset)
    {
        return $this->SuitesSpecification[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param SuitesSpecification $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->SuitesSpecification[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->SuitesSpecification[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return SuitesSpecification Return the current element
     */
    public function current()
    {
        return current($this->SuitesSpecification);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->SuitesSpecification);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->SuitesSpecification);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->SuitesSpecification);
    }

    /**
     * Countable implementation
     *
     * @return SuitesSpecification Return count of elements
     */
    public function count()
    {
        return count($this->SuitesSpecification);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfSummaryItem implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var SummaryItem[] $SummaryItem
     */
    protected $SummaryItem = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return SummaryItem[]
     */
    public function getSummaryItem()
    {
        return $this->SummaryItem;
    }

    /**
     * @param SummaryItem[] $SummaryItem
     * @return \Gueststream\PMS\IQWare\API\ArrayOfSummaryItem
     */
    public function setSummaryItem(array $SummaryItem = null)
    {
        $this->SummaryItem = $SummaryItem;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->SummaryItem[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return SummaryItem
     */
    public function offsetGet($offset)
    {
        return $this->SummaryItem[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param SummaryItem $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->SummaryItem[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->SummaryItem[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return SummaryItem Return the current element
     */
    public function current()
    {
        return current($this->SummaryItem);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->SummaryItem);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->SummaryItem);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->SummaryItem);
    }

    /**
     * Countable implementation
     *
     * @return SummaryItem Return count of elements
     */
    public function count()
    {
        return count($this->SummaryItem);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfUnitAvailabilityCalendar implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var UnitAvailabilityCalendar[] $UnitAvailabilityCalendar
     */
    protected $UnitAvailabilityCalendar = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return UnitAvailabilityCalendar[]
     */
    public function getUnitAvailabilityCalendar()
    {
        return $this->UnitAvailabilityCalendar;
    }

    /**
     * @param UnitAvailabilityCalendar[] $UnitAvailabilityCalendar
     * @return \Gueststream\PMS\IQWare\API\ArrayOfUnitAvailabilityCalendar
     */
    public function setUnitAvailabilityCalendar(array $UnitAvailabilityCalendar = null)
    {
        $this->UnitAvailabilityCalendar = $UnitAvailabilityCalendar;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->UnitAvailabilityCalendar[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return UnitAvailabilityCalendar
     */
    public function offsetGet($offset)
    {
        return $this->UnitAvailabilityCalendar[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param UnitAvailabilityCalendar $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->UnitAvailabilityCalendar[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->UnitAvailabilityCalendar[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return UnitAvailabilityCalendar Return the current element
     */
    public function current()
    {
        return current($this->UnitAvailabilityCalendar);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->UnitAvailabilityCalendar);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->UnitAvailabilityCalendar);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->UnitAvailabilityCalendar);
    }

    /**
     * Countable implementation
     *
     * @return UnitAvailabilityCalendar Return count of elements
     */
    public function count()
    {
        return count($this->UnitAvailabilityCalendar);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfUnitAvailable implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var UnitAvailable[] $UnitAvailable
     */
    protected $UnitAvailable = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return UnitAvailable[]
     */
    public function getUnitAvailable()
    {
        return $this->UnitAvailable;
    }

    /**
     * @param UnitAvailable[] $UnitAvailable
     * @return \Gueststream\PMS\IQWare\API\ArrayOfUnitAvailable
     */
    public function setUnitAvailable(array $UnitAvailable = null)
    {
        $this->UnitAvailable = $UnitAvailable;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->UnitAvailable[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return UnitAvailable
     */
    public function offsetGet($offset)
    {
        return $this->UnitAvailable[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param UnitAvailable $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->UnitAvailable[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->UnitAvailable[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return UnitAvailable Return the current element
     */
    public function current()
    {
        return current($this->UnitAvailable);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->UnitAvailable);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->UnitAvailable);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->UnitAvailable);
    }

    /**
     * Countable implementation
     *
     * @return UnitAvailable Return count of elements
     */
    public function count()
    {
        return count($this->UnitAvailable);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfUnitDate implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var UnitDate[] $UnitDate
     */
    protected $UnitDate = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return UnitDate[]
     */
    public function getUnitDate()
    {
        return $this->UnitDate;
    }

    /**
     * @param UnitDate[] $UnitDate
     * @return \Gueststream\PMS\IQWare\API\ArrayOfUnitDate
     */
    public function setUnitDate(array $UnitDate = null)
    {
        $this->UnitDate = $UnitDate;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->UnitDate[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return UnitDate
     */
    public function offsetGet($offset)
    {
        return $this->UnitDate[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param UnitDate $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->UnitDate[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->UnitDate[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return UnitDate Return the current element
     */
    public function current()
    {
        return current($this->UnitDate);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->UnitDate);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->UnitDate);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->UnitDate);
    }

    /**
     * Countable implementation
     *
     * @return UnitDate Return count of elements
     */
    public function count()
    {
        return count($this->UnitDate);
    }
}




namespace Gueststream\PMS\IQWare\API;

class ArrayOfUnitReservation implements \ArrayAccess, \Iterator, \Countable
{

    /**
     * @var UnitReservation[] $UnitReservation
     */
    protected $UnitReservation = null;

    
    public function __construct()
    {
    
    }

    /**
     * @return UnitReservation[]
     */
    public function getUnitReservation()
    {
        return $this->UnitReservation;
    }

    /**
     * @param UnitReservation[] $UnitReservation
     * @return \Gueststream\PMS\IQWare\API\ArrayOfUnitReservation
     */
    public function setUnitReservation(array $UnitReservation = null)
    {
        $this->UnitReservation = $UnitReservation;
        return $this;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset An offset to check for
     * @return boolean true on success or false on failure
     */
    public function offsetExists($offset)
    {
        return isset($this->UnitReservation[$offset]);
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to retrieve
     * @return UnitReservation
     */
    public function offsetGet($offset)
    {
        return $this->UnitReservation[$offset];
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to assign the value to
     * @param UnitReservation $value The value to set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->UnitReservation[$offset] = $value;
    }

    /**
     * ArrayAccess implementation
     *
     * @param mixed $offset The offset to unset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->UnitReservation[$offset]);
    }

    /**
     * Iterator implementation
     *
     * @return UnitReservation Return the current element
     */
    public function current()
    {
        return current($this->UnitReservation);
    }

    /**
     * Iterator implementation
     * Move forward to next element
     *
     * @return void
     */
    public function next()
    {
        next($this->UnitReservation);
    }

    /**
     * Iterator implementation
     *
     * @return string|null Return the key of the current element or null
     */
    public function key()
    {
        return key($this->UnitReservation);
    }

    /**
     * Iterator implementation
     *
     * @return boolean Return the validity of the current position
     */
    public function valid()
    {
        return $this->key() !== null;
    }

    /**
     * Iterator implementation
     * Rewind the Iterator to the first element
     *
     * @return void
     */
    public function rewind()
    {
        reset($this->UnitReservation);
    }

    /**
     * Countable implementation
     *
     * @return UnitReservation Return count of elements
     */
    public function count()
    {
        return count($this->UnitReservation);
    }
}


		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfActivityUnit implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var ActivityUnit[] $ActivityUnit
10		*/
11		protected $ActivityUnit = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return ActivityUnit[]
21		*/
22		public function getActivityUnit()
23		{
24		return $this->ActivityUnit;
25		}
26
27		/**
28		* @param ActivityUnit[] $ActivityUnit
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfActivityUnit
30		*/
31		public function setActivityUnit(array $ActivityUnit = null)
32		{
33		$this->ActivityUnit = $ActivityUnit;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->ActivityUnit[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return ActivityUnit
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->ActivityUnit[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param ActivityUnit $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->ActivityUnit[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->ActivityUnit[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return ActivityUnit Return the current element
86		*/
87		public function current()
88		{
89		return current($this->ActivityUnit);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->ActivityUnit);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->ActivityUnit);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->ActivityUnit);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return ActivityUnit Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->ActivityUnit);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfActivityUnitAvail implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var ActivityUnitAvail[] $ActivityUnitAvail
10		*/
11		protected $ActivityUnitAvail = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return ActivityUnitAvail[]
21		*/
22		public function getActivityUnitAvail()
23		{
24		return $this->ActivityUnitAvail;
25		}
26
27		/**
28		* @param ActivityUnitAvail[] $ActivityUnitAvail
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfActivityUnitAvail
30		*/
31		public function setActivityUnitAvail(array $ActivityUnitAvail = null)
32		{
33		$this->ActivityUnitAvail = $ActivityUnitAvail;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->ActivityUnitAvail[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return ActivityUnitAvail
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->ActivityUnitAvail[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param ActivityUnitAvail $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->ActivityUnitAvail[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->ActivityUnitAvail[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return ActivityUnitAvail Return the current element
86		*/
87		public function current()
88		{
89		return current($this->ActivityUnitAvail);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->ActivityUnitAvail);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->ActivityUnitAvail);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->ActivityUnitAvail);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return ActivityUnitAvail Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->ActivityUnitAvail);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfApplicableSpecialOffersRBO implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var ApplicableSpecialOffersRBO[] $ApplicableSpecialOffersRBO
10		*/
11		protected $ApplicableSpecialOffersRBO = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return ApplicableSpecialOffersRBO[]
21		*/
22		public function getApplicableSpecialOffersRBO()
23		{
24		return $this->ApplicableSpecialOffersRBO;
25		}
26
27		/**
28		* @param ApplicableSpecialOffersRBO[] $ApplicableSpecialOffersRBO
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfApplicableSpecialOffersRBO
30		*/
31		public function setApplicableSpecialOffersRBO(array $ApplicableSpecialOffersRBO = null)
32		{
33		$this->ApplicableSpecialOffersRBO = $ApplicableSpecialOffersRBO;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->ApplicableSpecialOffersRBO[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return ApplicableSpecialOffersRBO
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->ApplicableSpecialOffersRBO[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param ApplicableSpecialOffersRBO $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->ApplicableSpecialOffersRBO[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->ApplicableSpecialOffersRBO[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return ApplicableSpecialOffersRBO Return the current element
86		*/
87		public function current()
88		{
89		return current($this->ApplicableSpecialOffersRBO);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->ApplicableSpecialOffersRBO);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->ApplicableSpecialOffersRBO);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->ApplicableSpecialOffersRBO);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return ApplicableSpecialOffersRBO Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->ApplicableSpecialOffersRBO);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfArrivalAndDepartureTimeSeason implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var ArrivalAndDepartureTimeSeason[] $ArrivalAndDepartureTimeSeason
10		*/
11		protected $ArrivalAndDepartureTimeSeason = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return ArrivalAndDepartureTimeSeason[]
21		*/
22		public function getArrivalAndDepartureTimeSeason()
23		{
24		return $this->ArrivalAndDepartureTimeSeason;
25		}
26
27		/**
28		* @param ArrivalAndDepartureTimeSeason[] $ArrivalAndDepartureTimeSeason
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfArrivalAndDepartureTimeSeason
30		*/
31		public function setArrivalAndDepartureTimeSeason(array $ArrivalAndDepartureTimeSeason = null)
32		{
33		$this->ArrivalAndDepartureTimeSeason = $ArrivalAndDepartureTimeSeason;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->ArrivalAndDepartureTimeSeason[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return ArrivalAndDepartureTimeSeason
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->ArrivalAndDepartureTimeSeason[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param ArrivalAndDepartureTimeSeason $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->ArrivalAndDepartureTimeSeason[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->ArrivalAndDepartureTimeSeason[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return ArrivalAndDepartureTimeSeason Return the current element
86		*/
87		public function current()
88		{
89		return current($this->ArrivalAndDepartureTimeSeason);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->ArrivalAndDepartureTimeSeason);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->ArrivalAndDepartureTimeSeason);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->ArrivalAndDepartureTimeSeason);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return ArrivalAndDepartureTimeSeason Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->ArrivalAndDepartureTimeSeason);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfAvailabilityOverview implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var AvailabilityOverview[] $AvailabilityOverview
10		*/
11		protected $AvailabilityOverview = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return AvailabilityOverview[]
21		*/
22		public function getAvailabilityOverview()
23		{
24		return $this->AvailabilityOverview;
25		}
26
27		/**
28		* @param AvailabilityOverview[] $AvailabilityOverview
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfAvailabilityOverview
30		*/
31		public function setAvailabilityOverview(array $AvailabilityOverview = null)
32		{
33		$this->AvailabilityOverview = $AvailabilityOverview;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->AvailabilityOverview[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return AvailabilityOverview
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->AvailabilityOverview[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param AvailabilityOverview $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->AvailabilityOverview[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->AvailabilityOverview[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return AvailabilityOverview Return the current element
86		*/
87		public function current()
88		{
89		return current($this->AvailabilityOverview);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->AvailabilityOverview);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->AvailabilityOverview);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->AvailabilityOverview);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return AvailabilityOverview Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->AvailabilityOverview);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfAvailableRoom implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var AvailableRoom[] $AvailableRoom
10		*/
11		protected $AvailableRoom = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return AvailableRoom[]
21		*/
22		public function getAvailableRoom()
23		{
24		return $this->AvailableRoom;
25		}
26
27		/**
28		* @param AvailableRoom[] $AvailableRoom
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfAvailableRoom
30		*/
31		public function setAvailableRoom(array $AvailableRoom = null)
32		{
33		$this->AvailableRoom = $AvailableRoom;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->AvailableRoom[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return AvailableRoom
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->AvailableRoom[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param AvailableRoom $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->AvailableRoom[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->AvailableRoom[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return AvailableRoom Return the current element
86		*/
87		public function current()
88		{
89		return current($this->AvailableRoom);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->AvailableRoom);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->AvailableRoom);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->AvailableRoom);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return AvailableRoom Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->AvailableRoom);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfAvailableSuite implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var AvailableSuite[] $AvailableSuite
10		*/
11		protected $AvailableSuite = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return AvailableSuite[]
21		*/
22		public function getAvailableSuite()
23		{
24		return $this->AvailableSuite;
25		}
26
27		/**
28		* @param AvailableSuite[] $AvailableSuite
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfAvailableSuite
30		*/
31		public function setAvailableSuite(array $AvailableSuite = null)
32		{
33		$this->AvailableSuite = $AvailableSuite;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->AvailableSuite[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return AvailableSuite
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->AvailableSuite[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param AvailableSuite $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->AvailableSuite[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->AvailableSuite[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return AvailableSuite Return the current element
86		*/
87		public function current()
88		{
89		return current($this->AvailableSuite);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->AvailableSuite);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->AvailableSuite);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->AvailableSuite);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return AvailableSuite Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->AvailableSuite);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfB2BAnywhere implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var B2BAnywhere[] $B2BAnywhere
10		*/
11		protected $B2BAnywhere = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return B2BAnywhere[]
21		*/
22		public function getB2BAnywhere()
23		{
24		return $this->B2BAnywhere;
25		}
26
27		/**
28		* @param B2BAnywhere[] $B2BAnywhere
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfB2BAnywhere
30		*/
31		public function setB2BAnywhere(array $B2BAnywhere = null)
32		{
33		$this->B2BAnywhere = $B2BAnywhere;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->B2BAnywhere[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return B2BAnywhere
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->B2BAnywhere[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param B2BAnywhere $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->B2BAnywhere[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->B2BAnywhere[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return B2BAnywhere Return the current element
86		*/
87		public function current()
88		{
89		return current($this->B2BAnywhere);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->B2BAnywhere);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->B2BAnywhere);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->B2BAnywhere);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return B2BAnywhere Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->B2BAnywhere);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfBeachChairSite implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var BeachChairSite[] $BeachChairSite
10		*/
11		protected $BeachChairSite = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return BeachChairSite[]
21		*/
22		public function getBeachChairSite()
23		{
24		return $this->BeachChairSite;
25		}
26
27		/**
28		* @param BeachChairSite[] $BeachChairSite
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfBeachChairSite
30		*/
31		public function setBeachChairSite(array $BeachChairSite = null)
32		{
33		$this->BeachChairSite = $BeachChairSite;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->BeachChairSite[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return BeachChairSite
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->BeachChairSite[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param BeachChairSite $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->BeachChairSite[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->BeachChairSite[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return BeachChairSite Return the current element
86		*/
87		public function current()
88		{
89		return current($this->BeachChairSite);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->BeachChairSite);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->BeachChairSite);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->BeachChairSite);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return BeachChairSite Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->BeachChairSite);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfBedding implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var Bedding[] $Bedding
10		*/
11		protected $Bedding = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return Bedding[]
21		*/
22		public function getBedding()
23		{
24		return $this->Bedding;
25		}
26
27		/**
28		* @param Bedding[] $Bedding
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfBedding
30		*/
31		public function setBedding(array $Bedding = null)
32		{
33		$this->Bedding = $Bedding;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->Bedding[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return Bedding
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->Bedding[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param Bedding $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->Bedding[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->Bedding[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return Bedding Return the current element
86		*/
87		public function current()
88		{
89		return current($this->Bedding);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->Bedding);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->Bedding);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->Bedding);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return Bedding Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->Bedding);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfBreakdownByDay implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var BreakdownByDay[] $BreakdownByDay
10		*/
11		protected $BreakdownByDay = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return BreakdownByDay[]
21		*/
22		public function getBreakdownByDay()
23		{
24		return $this->BreakdownByDay;
25		}
26
27		/**
28		* @param BreakdownByDay[] $BreakdownByDay
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfBreakdownByDay
30		*/
31		public function setBreakdownByDay(array $BreakdownByDay = null)
32		{
33		$this->BreakdownByDay = $BreakdownByDay;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->BreakdownByDay[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return BreakdownByDay
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->BreakdownByDay[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param BreakdownByDay $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->BreakdownByDay[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->BreakdownByDay[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return BreakdownByDay Return the current element
86		*/
87		public function current()
88		{
89		return current($this->BreakdownByDay);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->BreakdownByDay);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->BreakdownByDay);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->BreakdownByDay);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return BreakdownByDay Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->BreakdownByDay);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCancellationReason implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var CancellationReason[] $CancellationReason
10		*/
11		protected $CancellationReason = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return CancellationReason[]
21		*/
22		public function getCancellationReason()
23		{
24		return $this->CancellationReason;
25		}
26
27		/**
28		* @param CancellationReason[] $CancellationReason
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCancellationReason
30		*/
31		public function setCancellationReason(array $CancellationReason = null)
32		{
33		$this->CancellationReason = $CancellationReason;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->CancellationReason[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return CancellationReason
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->CancellationReason[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param CancellationReason $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->CancellationReason[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->CancellationReason[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return CancellationReason Return the current element
86		*/
87		public function current()
88		{
89		return current($this->CancellationReason);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->CancellationReason);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->CancellationReason);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->CancellationReason);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return CancellationReason Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->CancellationReason);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCComments implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cComments[] $cComments
10		*/
11		protected $cComments = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cComments[]
21		*/
22		public function getCComments()
23		{
24		return $this->cComments;
25		}
26
27		/**
28		* @param cComments[] $cComments
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCComments
30		*/
31		public function setCComments(array $cComments = null)
32		{
33		$this->cComments = $cComments;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cComments[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cComments
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cComments[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cComments $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cComments[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cComments[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cComments Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cComments);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cComments);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cComments);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cComments);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cComments Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cComments);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCCreditCard implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cCreditCard[] $cCreditCard
10		*/
11		protected $cCreditCard = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cCreditCard[]
21		*/
22		public function getCCreditCard()
23		{
24		return $this->cCreditCard;
25		}
26
27		/**
28		* @param cCreditCard[] $cCreditCard
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCCreditCard
30		*/
31		public function setCCreditCard(array $cCreditCard = null)
32		{
33		$this->cCreditCard = $cCreditCard;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cCreditCard[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cCreditCard
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cCreditCard[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cCreditCard $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cCreditCard[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cCreditCard[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cCreditCard Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cCreditCard);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cCreditCard);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cCreditCard);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cCreditCard);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cCreditCard Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cCreditCard);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCElement implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cElement[] $cElement
10		*/
11		protected $cElement = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cElement[]
21		*/
22		public function getCElement()
23		{
24		return $this->cElement;
25		}
26
27		/**
28		* @param cElement[] $cElement
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCElement
30		*/
31		public function setCElement(array $cElement = null)
32		{
33		$this->cElement = $cElement;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cElement[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cElement
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cElement[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cElement $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cElement[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cElement[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cElement Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cElement);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cElement);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cElement);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cElement);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cElement Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cElement);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCFitMember implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cFitMember[] $cFitMember
10		*/
11		protected $cFitMember = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cFitMember[]
21		*/
22		public function getCFitMember()
23		{
24		return $this->cFitMember;
25		}
26
27		/**
28		* @param cFitMember[] $cFitMember
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCFitMember
30		*/
31		public function setCFitMember(array $cFitMember = null)
32		{
33		$this->cFitMember = $cFitMember;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cFitMember[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cFitMember
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cFitMember[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cFitMember $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cFitMember[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cFitMember[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cFitMember Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cFitMember);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cFitMember);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cFitMember);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cFitMember);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cFitMember Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cFitMember);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCFolioDist implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cFolioDist[] $cFolioDist
10		*/
11		protected $cFolioDist = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cFolioDist[]
21		*/
22		public function getCFolioDist()
23		{
24		return $this->cFolioDist;
25		}
26
27		/**
28		* @param cFolioDist[] $cFolioDist
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCFolioDist
30		*/
31		public function setCFolioDist(array $cFolioDist = null)
32		{
33		$this->cFolioDist = $cFolioDist;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cFolioDist[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cFolioDist
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cFolioDist[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cFolioDist $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cFolioDist[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cFolioDist[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cFolioDist Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cFolioDist);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cFolioDist);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cFolioDist);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cFolioDist);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cFolioDist Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cFolioDist);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCGiftCertificateIncentivePeriod implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cGiftCertificateIncentivePeriod[] $cGiftCertificateIncentivePeriod
10		*/
11		protected $cGiftCertificateIncentivePeriod = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cGiftCertificateIncentivePeriod[]
21		*/
22		public function getCGiftCertificateIncentivePeriod()
23		{
24		return $this->cGiftCertificateIncentivePeriod;
25		}
26
27		/**
28		* @param cGiftCertificateIncentivePeriod[] $cGiftCertificateIncentivePeriod
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCGiftCertificateIncentivePeriod
30		*/
31		public function setCGiftCertificateIncentivePeriod(array $cGiftCertificateIncentivePeriod = null)
32		{
33		$this->cGiftCertificateIncentivePeriod = $cGiftCertificateIncentivePeriod;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cGiftCertificateIncentivePeriod[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cGiftCertificateIncentivePeriod
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cGiftCertificateIncentivePeriod[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cGiftCertificateIncentivePeriod $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cGiftCertificateIncentivePeriod[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cGiftCertificateIncentivePeriod[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cGiftCertificateIncentivePeriod Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cGiftCertificateIncentivePeriod);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cGiftCertificateIncentivePeriod);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cGiftCertificateIncentivePeriod);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cGiftCertificateIncentivePeriod);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cGiftCertificateIncentivePeriod Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cGiftCertificateIncentivePeriod);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCGolfItems implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cGolfItems[] $cGolfItems
10		*/
11		protected $cGolfItems = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cGolfItems[]
21		*/
22		public function getCGolfItems()
23		{
24		return $this->cGolfItems;
25		}
26
27		/**
28		* @param cGolfItems[] $cGolfItems
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCGolfItems
30		*/
31		public function setCGolfItems(array $cGolfItems = null)
32		{
33		$this->cGolfItems = $cGolfItems;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cGolfItems[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cGolfItems
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cGolfItems[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cGolfItems $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cGolfItems[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cGolfItems[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cGolfItems Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cGolfItems);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cGolfItems);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cGolfItems);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cGolfItems);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cGolfItems Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cGolfItems);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCManualRateDaily implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cManualRateDaily[] $cManualRateDaily
10		*/
11		protected $cManualRateDaily = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cManualRateDaily[]
21		*/
22		public function getCManualRateDaily()
23		{
24		return $this->cManualRateDaily;
25		}
26
27		/**
28		* @param cManualRateDaily[] $cManualRateDaily
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCManualRateDaily
30		*/
31		public function setCManualRateDaily(array $cManualRateDaily = null)
32		{
33		$this->cManualRateDaily = $cManualRateDaily;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cManualRateDaily[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cManualRateDaily
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cManualRateDaily[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cManualRateDaily $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cManualRateDaily[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cManualRateDaily[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cManualRateDaily Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cManualRateDaily);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cManualRateDaily);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cManualRateDaily);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cManualRateDaily);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cManualRateDaily Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cManualRateDaily);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCPersonCountDaily implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cPersonCountDaily[] $cPersonCountDaily
10		*/
11		protected $cPersonCountDaily = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cPersonCountDaily[]
21		*/
22		public function getCPersonCountDaily()
23		{
24		return $this->cPersonCountDaily;
25		}
26
27		/**
28		* @param cPersonCountDaily[] $cPersonCountDaily
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCPersonCountDaily
30		*/
31		public function setCPersonCountDaily(array $cPersonCountDaily = null)
32		{
33		$this->cPersonCountDaily = $cPersonCountDaily;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cPersonCountDaily[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cPersonCountDaily
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cPersonCountDaily[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cPersonCountDaily $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cPersonCountDaily[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cPersonCountDaily[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cPersonCountDaily Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cPersonCountDaily);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cPersonCountDaily);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cPersonCountDaily);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cPersonCountDaily);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cPersonCountDaily Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cPersonCountDaily);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCRateDaily implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cRateDaily[] $cRateDaily
10		*/
11		protected $cRateDaily = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cRateDaily[]
21		*/
22		public function getCRateDaily()
23		{
24		return $this->cRateDaily;
25		}
26
27		/**
28		* @param cRateDaily[] $cRateDaily
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCRateDaily
30		*/
31		public function setCRateDaily(array $cRateDaily = null)
32		{
33		$this->cRateDaily = $cRateDaily;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cRateDaily[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cRateDaily
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cRateDaily[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cRateDaily $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cRateDaily[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cRateDaily[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cRateDaily Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cRateDaily);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cRateDaily);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cRateDaily);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cRateDaily);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cRateDaily Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cRateDaily);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCreditCardTypes implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var CreditCardTypes[] $CreditCardTypes
10		*/
11		protected $CreditCardTypes = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return CreditCardTypes[]
21		*/
22		public function getCreditCardTypes()
23		{
24		return $this->CreditCardTypes;
25		}
26
27		/**
28		* @param CreditCardTypes[] $CreditCardTypes
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCreditCardTypes
30		*/
31		public function setCreditCardTypes(array $CreditCardTypes = null)
32		{
33		$this->CreditCardTypes = $CreditCardTypes;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->CreditCardTypes[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return CreditCardTypes
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->CreditCardTypes[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param CreditCardTypes $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->CreditCardTypes[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->CreditCardTypes[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return CreditCardTypes Return the current element
86		*/
87		public function current()
88		{
89		return current($this->CreditCardTypes);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->CreditCardTypes);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->CreditCardTypes);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->CreditCardTypes);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return CreditCardTypes Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->CreditCardTypes);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCreditLimit implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var CreditLimit[] $CreditLimit
10		*/
11		protected $CreditLimit = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return CreditLimit[]
21		*/
22		public function getCreditLimit()
23		{
24		return $this->CreditLimit;
25		}
26
27		/**
28		* @param CreditLimit[] $CreditLimit
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCreditLimit
30		*/
31		public function setCreditLimit(array $CreditLimit = null)
32		{
33		$this->CreditLimit = $CreditLimit;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->CreditLimit[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return CreditLimit
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->CreditLimit[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param CreditLimit $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->CreditLimit[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->CreditLimit[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return CreditLimit Return the current element
86		*/
87		public function current()
88		{
89		return current($this->CreditLimit);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->CreditLimit);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->CreditLimit);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->CreditLimit);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return CreditLimit Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->CreditLimit);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCServiceChargeALaCarte implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cServiceChargeALaCarte[] $cServiceChargeALaCarte
10		*/
11		protected $cServiceChargeALaCarte = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cServiceChargeALaCarte[]
21		*/
22		public function getCServiceChargeALaCarte()
23		{
24		return $this->cServiceChargeALaCarte;
25		}
26
27		/**
28		* @param cServiceChargeALaCarte[] $cServiceChargeALaCarte
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCServiceChargeALaCarte
30		*/
31		public function setCServiceChargeALaCarte(array $cServiceChargeALaCarte = null)
32		{
33		$this->cServiceChargeALaCarte = $cServiceChargeALaCarte;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cServiceChargeALaCarte[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cServiceChargeALaCarte
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cServiceChargeALaCarte[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cServiceChargeALaCarte $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cServiceChargeALaCarte[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cServiceChargeALaCarte[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cServiceChargeALaCarte Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cServiceChargeALaCarte);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cServiceChargeALaCarte);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cServiceChargeALaCarte);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cServiceChargeALaCarte);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cServiceChargeALaCarte Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cServiceChargeALaCarte);
142		}
143		}
144

Gueststream-Inc / iqware

Code Duplication Length = 139-142 lines in 92 locations

src/API/ArrayOfActivityUnit.php 1 location

src/API/ArrayOfActivityUnitAvail.php 1 location

src/API/ArrayOfApplicableSpecialOffersRBO.php 1 location

src/API/ArrayOfArrivalAndDepartureTimeSeason.php 1 location

src/API/ArrayOfAvailabilityOverview.php 1 location

src/API/ArrayOfAvailableRoom.php 1 location

src/API/ArrayOfAvailableSuite.php 1 location

src/API/ArrayOfB2BAnywhere.php 1 location

src/API/ArrayOfBeachChairSite.php 1 location

src/API/ArrayOfBedding.php 1 location

src/API/ArrayOfBreakdownByDay.php 1 location

src/API/ArrayOfCancellationReason.php 1 location

src/API/ArrayOfCComments.php 1 location

src/API/ArrayOfCCreditCard.php 1 location

src/API/ArrayOfCElement.php 1 location

src/API/ArrayOfCFitMember.php 1 location

src/API/ArrayOfCFolioDist.php 1 location

src/API/ArrayOfCGiftCertificateIncentivePeriod.php 1 location

src/API/ArrayOfCGolfItems.php 1 location

src/API/ArrayOfCManualRateDaily.php 1 location

src/API/ArrayOfCPersonCountDaily.php 1 location

src/API/ArrayOfCRateDaily.php 1 location

src/API/ArrayOfCreditCardTypes.php 1 location

src/API/ArrayOfCreditLimit.php 1 location

src/API/ArrayOfCServiceChargeALaCarte.php 1 location

src/API/ArrayOfCTelephone.php 1 location

src/API/ArrayOfCTransfer.php 1 location

src/API/ArrayOfDailyBreakdown.php 1 location

src/API/ArrayOfDailyEvaluation.php 1 location

src/API/ArrayOfDailyOccupancy.php 1 location

src/API/ArrayOfDataSet.php 1 location

src/API/ArrayOfDateTime.php 1 location

src/API/ArrayOfDetail.php 1 location

src/API/ArrayOfDetails.php 1 location

src/API/ArrayOfElements.php 1 location

src/API/ArrayOfEvaluation.php 1 location

src/API/ArrayOfEvaluationResult.php 1 location

src/API/ArrayOfExportedRate.php 1 location

src/API/ArrayOfGDSListing.php 1 location

src/API/ArrayOfGlobalAccess.php 1 location

src/API/ArrayOfGroupValues.php 1 location

src/API/ArrayOfInfosBilling.php 1 location

src/API/ArrayOfInt.php 1 location

src/API/ArrayOfIQImage.php 1 location

src/API/ArrayOfLanguage.php 1 location

src/API/ArrayOfMarkupItem.php 1 location

src/API/ArrayOfMemberLanguage.php 1 location

src/API/ArrayOfMemberReservation.php 1 location

src/API/ArrayOfNationality.php 1 location

src/API/ArrayOfOaccAddress.php 1 location

src/API/ArrayOfOaccTelephone.php 1 location

src/API/ArrayOfOwnerInvoiceInfo.php 1 location

src/API/ArrayOfRateCode.php 1 location

src/API/ArrayOfRateReason.php 1 location

src/API/ArrayOfRatesDetails.php 1 location

src/API/ArrayOfRateSpecialValidPeriod.php 1 location

src/API/ArrayOfRefusal.php 1 location

src/API/ArrayOfRoomAttribute.php 1 location

src/API/ArrayOfRoomAttributGrouping.php 1 location

src/API/ArrayOfRoomAvailabilityForStay.php 1 location

src/API/ArrayOfRoomCalendar.php 1 location

src/API/ArrayOfRoomCalendarBreakdown.php 1 location

src/API/ArrayOfRoomDayAvailability.php 1 location

src/API/ArrayOfRoomInventory.php 1 location

src/API/ArrayOfRoomLocation.php 1 location

src/API/ArrayOfRoomLocationGrouping.php 1 location

src/API/ArrayOfRoomSpecification.php 1 location

src/API/ArrayOfRoomType.php 1 location

src/API/ArrayOfRoomTypeAvailability.php 1 location

src/API/ArrayOfRoomTypeBreakdown.php 1 location

src/API/ArrayOfRoomTypeBuildingsAndPL.php 1 location

src/API/ArrayOfRoomTypeCluster.php 1 location

src/API/ArrayOfRoomTypeClusterResult.php 1 location

src/API/ArrayOfSBDSummary.php 1 location

src/API/ArrayOfServiceCharge.php 1 location

src/API/ArrayOfShort.php 1 location

src/API/ArrayOfSpecialData.php 1 location

src/API/ArrayOfSpecialOfferByDay.php 1 location

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCTelephone implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cTelephone[] $cTelephone
10		*/
11		protected $cTelephone = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cTelephone[]
21		*/
22		public function getCTelephone()
23		{
24		return $this->cTelephone;
25		}
26
27		/**
28		* @param cTelephone[] $cTelephone
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCTelephone
30		*/
31		public function setCTelephone(array $cTelephone = null)
32		{
33		$this->cTelephone = $cTelephone;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cTelephone[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cTelephone
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cTelephone[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cTelephone $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cTelephone[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cTelephone[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cTelephone Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cTelephone);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cTelephone);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cTelephone);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cTelephone);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cTelephone Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cTelephone);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfCTransfer implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var cTransfer[] $cTransfer
10		*/
11		protected $cTransfer = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return cTransfer[]
21		*/
22		public function getCTransfer()
23		{
24		return $this->cTransfer;
25		}
26
27		/**
28		* @param cTransfer[] $cTransfer
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfCTransfer
30		*/
31		public function setCTransfer(array $cTransfer = null)
32		{
33		$this->cTransfer = $cTransfer;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->cTransfer[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return cTransfer
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->cTransfer[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param cTransfer $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->cTransfer[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->cTransfer[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return cTransfer Return the current element
86		*/
87		public function current()
88		{
89		return current($this->cTransfer);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->cTransfer);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->cTransfer);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->cTransfer);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return cTransfer Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->cTransfer);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfDailyBreakdown implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var DailyBreakdown[] $DailyBreakdown
10		*/
11		protected $DailyBreakdown = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return DailyBreakdown[]
21		*/
22		public function getDailyBreakdown()
23		{
24		return $this->DailyBreakdown;
25		}
26
27		/**
28		* @param DailyBreakdown[] $DailyBreakdown
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfDailyBreakdown
30		*/
31		public function setDailyBreakdown(array $DailyBreakdown = null)
32		{
33		$this->DailyBreakdown = $DailyBreakdown;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->DailyBreakdown[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return DailyBreakdown
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->DailyBreakdown[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param DailyBreakdown $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->DailyBreakdown[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->DailyBreakdown[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return DailyBreakdown Return the current element
86		*/
87		public function current()
88		{
89		return current($this->DailyBreakdown);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->DailyBreakdown);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->DailyBreakdown);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->DailyBreakdown);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return DailyBreakdown Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->DailyBreakdown);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfDailyEvaluation implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var DailyEvaluation[] $DailyEvaluation
10		*/
11		protected $DailyEvaluation = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return DailyEvaluation[]
21		*/
22		public function getDailyEvaluation()
23		{
24		return $this->DailyEvaluation;
25		}
26
27		/**
28		* @param DailyEvaluation[] $DailyEvaluation
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfDailyEvaluation
30		*/
31		public function setDailyEvaluation(array $DailyEvaluation = null)
32		{
33		$this->DailyEvaluation = $DailyEvaluation;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->DailyEvaluation[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return DailyEvaluation
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->DailyEvaluation[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param DailyEvaluation $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->DailyEvaluation[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->DailyEvaluation[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return DailyEvaluation Return the current element
86		*/
87		public function current()
88		{
89		return current($this->DailyEvaluation);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->DailyEvaluation);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->DailyEvaluation);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->DailyEvaluation);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return DailyEvaluation Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->DailyEvaluation);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfDailyOccupancy implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var DailyOccupancy[] $DailyOccupancy
10		*/
11		protected $DailyOccupancy = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return DailyOccupancy[]
21		*/
22		public function getDailyOccupancy()
23		{
24		return $this->DailyOccupancy;
25		}
26
27		/**
28		* @param DailyOccupancy[] $DailyOccupancy
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfDailyOccupancy
30		*/
31		public function setDailyOccupancy(array $DailyOccupancy = null)
32		{
33		$this->DailyOccupancy = $DailyOccupancy;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->DailyOccupancy[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return DailyOccupancy
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->DailyOccupancy[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param DailyOccupancy $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->DailyOccupancy[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->DailyOccupancy[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return DailyOccupancy Return the current element
86		*/
87		public function current()
88		{
89		return current($this->DailyOccupancy);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->DailyOccupancy);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->DailyOccupancy);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->DailyOccupancy);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return DailyOccupancy Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->DailyOccupancy);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfDataSet implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var DataSet[] $DataSet
10		*/
11		protected $DataSet = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return DataSet[]
21		*/
22		public function getDataSet()
23		{
24		return $this->DataSet;
25		}
26
27		/**
28		* @param DataSet[] $DataSet
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfDataSet
30		*/
31		public function setDataSet(array $DataSet = null)
32		{
33		$this->DataSet = $DataSet;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->DataSet[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return DataSet
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->DataSet[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param DataSet $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->DataSet[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->DataSet[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return DataSet Return the current element
86		*/
87		public function current()
88		{
89		return current($this->DataSet);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->DataSet);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->DataSet);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->DataSet);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return DataSet Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->DataSet);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfDateTime implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var dateTime[] $dateTime
10		*/
11		protected $dateTime = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return dateTime[]
21		*/
22		public function getDateTime()
23		{
24		return $this->dateTime;
25		}
26
27		/**
28		* @param dateTime[] $dateTime
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfDateTime
30		*/
31		public function setDateTime(array $dateTime = null)
32		{
33		$this->dateTime = $dateTime;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->dateTime[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return dateTime
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->dateTime[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param dateTime $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->dateTime[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->dateTime[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return dateTime Return the current element
86		*/
87		public function current()
88		{
89		return current($this->dateTime);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->dateTime);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->dateTime);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->dateTime);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return dateTime Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->dateTime);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfDetail implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var Detail[] $Detail
10		*/
11		protected $Detail = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return Detail[]
21		*/
22		public function getDetail()
23		{
24		return $this->Detail;
25		}
26
27		/**
28		* @param Detail[] $Detail
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfDetail
30		*/
31		public function setDetail(array $Detail = null)
32		{
33		$this->Detail = $Detail;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->Detail[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return Detail
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->Detail[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param Detail $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->Detail[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->Detail[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return Detail Return the current element
86		*/
87		public function current()
88		{
89		return current($this->Detail);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->Detail);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->Detail);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->Detail);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return Detail Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->Detail);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfDetails implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var Details[] $Details
10		*/
11		protected $Details = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return Details[]
21		*/
22		public function getDetails()
23		{
24		return $this->Details;
25		}
26
27		/**
28		* @param Details[] $Details
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfDetails
30		*/
31		public function setDetails(array $Details = null)
32		{
33		$this->Details = $Details;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->Details[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return Details
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->Details[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param Details $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->Details[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->Details[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return Details Return the current element
86		*/
87		public function current()
88		{
89		return current($this->Details);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->Details);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->Details);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->Details);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return Details Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->Details);
142		}
143		}
144

		@@ 5-143 (lines=139) @@
2
3		namespace Gueststream\PMS\IQWare\API;
4
5		class ArrayOfElements implements \ArrayAccess, \Iterator, \Countable
6		{
7
8		/**
9		* @var Elements[] $Elements
10		*/
11		protected $Elements = null;
12
13
14		public function __construct()
15		{
16
17		}
18
19		/**
20		* @return Elements[]
21		*/
22		public function getElements()
23		{
24		return $this->Elements;
25		}
26
27		/**
28		* @param Elements[] $Elements
29		* @return \Gueststream\PMS\IQWare\API\ArrayOfElements
30		*/
31		public function setElements(array $Elements = null)
32		{
33		$this->Elements = $Elements;
34		return $this;
35		}
36
37		/**
38		* ArrayAccess implementation
39		*
40		* @param mixed $offset An offset to check for
41		* @return boolean true on success or false on failure
42		*/
43		public function offsetExists($offset)
44		{
45		return isset($this->Elements[$offset]);
46		}
47
48		/**
49		* ArrayAccess implementation
50		*
51		* @param mixed $offset The offset to retrieve
52		* @return Elements
53		*/
54		public function offsetGet($offset)
55		{
56		return $this->Elements[$offset];
57		}
58
59		/**
60		* ArrayAccess implementation
61		*
62		* @param mixed $offset The offset to assign the value to
63		* @param Elements $value The value to set
64		* @return void
65		*/
66		public function offsetSet($offset, $value)
67		{
68		$this->Elements[$offset] = $value;
69		}
70
71		/**
72		* ArrayAccess implementation
73		*
74		* @param mixed $offset The offset to unset
75		* @return void
76		*/
77		public function offsetUnset($offset)
78		{
79		unset($this->Elements[$offset]);
80		}
81
82		/**
83		* Iterator implementation
84		*
85		* @return Elements Return the current element
86		*/
87		public function current()
88		{
89		return current($this->Elements);
90		}
91
92		/**
93		* Iterator implementation
94		* Move forward to next element
95		*
96		* @return void
97		*/
98		public function next()
99		{
100		next($this->Elements);
101		}
102
103		/**
104		* Iterator implementation
105		*
106		* @return string\|null Return the key of the current element or null
107		*/
108		public function key()
109		{
110		return key($this->Elements);
111		}
112
113		/**
114		* Iterator implementation
115		*
116		* @return boolean Return the validity of the current position
117		*/
118		public function valid()
119		{
120		return $this->key() !== null;
121		}
122
123		/**
124		* Iterator implementation
125		* Rewind the Iterator to the first element
126		*
127		* @return void
128		*/
129		public function rewind()
130		{
131		reset($this->Elements);
132		}
133
134		/**
135		* Countable implementation
136		*
137		* @return Elements Return count of elements
138		*/
139		public function count()
140		{
141		return count($this->Elements);
142		}
143		}
144