File indexing completed on 2023-05-30 11:20:06

 <?php
 // THIS FILE IS GENERATED
 // WARNING! All changes made in this file will be lost!
 
 /**
  * The number of arguments passed to script
  **/
 $argc = array();
 
 /**
  * Array of arguments passed to script
  **/
 $argv = array();
 
 /**
  * References all variables available in global scope
  *
  * @superglobal
  **/
 $GLOBALS = array();
 
 /**
  * HTTP Cookies
  *
  * @deprecated
  **/
 $HTTP_COOKIE_VARS = array();
 
 /**
  * Environment variables
  *
  * @deprecated
  **/
 $HTTP_ENV_VARS = array();
 
 /**
  * HTTP GET variables
  *
  * @deprecated
  **/
 $HTTP_GET_VARS = array();
 
 /**
  * HTTP File Upload variables
  *
  * @deprecated
  **/
 $HTTP_POST_FILES = array();
 
 /**
  * HTTP POST variables
  *
  * @deprecated
  **/
 $HTTP_POST_VARS = array();
 
 /**
  * Raw POST data
  **/
 $HTTP_RAW_POST_DATA = array();
 
 /**
  * HTTP response headers
  **/
 $http_response_header = array();
 
 /**
  * Session variables
  *
  * @deprecated
  **/
 $HTTP_SESSION_VARS = array();
 
 /**
  * The previous error message
  **/
 $php_errormsg = array();
 
 /**
  * HTTP Cookies
  *
  * @superglobal
  **/
 $_COOKIE = array();
 
 /**
  * Environment variables
  *
  * @superglobal
  **/
 $_ENV = array();
 
 /**
  * HTTP File Upload variables
  *
  * @superglobal
  **/
 $_FILES = array();
 
 /**
  * HTTP GET variables
  *
  * @superglobal
  **/
 $_GET = array();
 
 /**
  * HTTP POST variables
  *
  * @superglobal
  **/
 $_POST = array();
 
 /**
  * HTTP Request variables
  *
  * @superglobal
  **/
 $_REQUEST = array();
 
 /**
  * Server and execution environment information
  *
  * @superglobal
  **/
 $_SERVER = array();
 
 /**
  * Session variables
  *
  * @superglobal
  **/
 $_SESSION = array();
 
 /**
  * Interface to detect if a class is traversable using . Abstract base
  * interface that cannot be implemented alone. Instead it must be
  * implemented by either IteratorAggregate or Iterator. This interface
  * has no methods, its only purpose is to be the base interface for all
  * traversable classes.
  **/
 interface Traversable {
 }
 /**
  * Interface for external iterators or objects that can be iterated
  * themselves internally. PHP already provides a number of iterators for
  * many day to day tasks. See SPL iterators for a list.
  **/
 interface Iterator extends Traversable {
     /**
      * Return the current element
      *
      * Returns the current element.
      *
      * @return mixed Can return any type.
      * @since PHP 5, PHP 7
      **/
     public function current();
 
     /**
      * Return the key of the current element
      *
      * Returns the key of the current element.
      *
      * @return scalar Returns scalar on success, or NULL on failure.
      * @since PHP 5, PHP 7
      **/
     public function key();
 
     /**
      * Move forward to next element
      *
      * Moves the current position to the next element.
      *
      * @return void Any returned value is ignored.
      * @since PHP 5, PHP 7
      **/
     public function next();
 
     /**
      * Rewind the Iterator to the first element
      *
      * Rewinds back to the first element of the Iterator.
      *
      * @return void Any returned value is ignored.
      * @since PHP 5, PHP 7
      **/
     public function rewind();
 
     /**
      * Checks if current position is valid
      *
      * This method is called after Iterator::rewind and Iterator::next to
      * check if the current position is valid.
      *
      * @return bool The return value will be casted to boolean and then
      *   evaluated.
      * @since PHP 5, PHP 7
      **/
     public function valid();
 
 }
 /**
  * Throwable is the base interface for any object that can be thrown via
  * a statement in PHP 7, including Error and Exception.
  **/
 interface Throwable {
     /**
      * Gets the exception code
      *
      * Returns the error code associated with the thrown object.
      *
      * @return int Returns the exception code as integer in Exception but
      *   possibly as other type in Exception descendants (for example as
      *   string in PDOException).
      * @since PHP 7
      **/
     public function getCode();
 
     /**
      * Gets the file in which the object was created
      *
      * Get the name of the file in which the thrown object was created.
      *
      * @return string Returns the filename in which the thrown object was
      *   created.
      * @since PHP 7
      **/
     public function getFile();
 
     /**
      * Gets the line on which the object was instantiated
      *
      * Returns the line number where the thrown object was instantiated.
      *
      * @return int Returns the line number where the thrown object was
      *   instantiated.
      * @since PHP 7
      **/
     public function getLine();
 
     /**
      * Gets the message
      *
      * Returns the message associated with the thrown object.
      *
      * @return string Returns the message associated with the thrown
      *   object.
      * @since PHP 7
      **/
     public function getMessage();
 
     /**
      * Returns the previous Throwable
      *
      * Returns any previous Throwable (for example, one provided as the third
      * parameter to Exception::__construct).
      *
      * @return Throwable Returns the previous Throwable if available, or
      *   NULL otherwise.
      * @since PHP 7
      **/
     public function getPrevious();
 
     /**
      * Gets the stack trace
      *
      * Returns the stack trace as an array.
      *
      * @return array Returns the stack trace as an array in the same format
      *   as {@link debug_backtrace}.
      * @since PHP 7
      **/
     public function getTrace();
 
     /**
      * Gets the stack trace as a string
      *
      * @return string Returns the stack trace as a string.
      * @since PHP 7
      **/
     public function getTraceAsString();
 
     /**
      * Gets a string representation of the thrown object
      *
      * @return string Returns the string representation of the thrown
      *   object.
      * @since PHP 7
      **/
     public function __toString();
 
 }
 /**
  * Error is the base class for all internal PHP errors.
  **/
 class Error implements Throwable {
     /**
      * The error code
      *
      * @var int
      **/
     protected $code;
 
     /**
      * The filename where the error happened
      *
      * @var string
      **/
     protected $file;
 
     /**
      * The line where the error happened
      *
      * @var int
      **/
     protected $line;
 
     /**
      * The error message
      *
      * @var string
      **/
     protected $message;
 
     /**
      * Gets the error code
      *
      * Returns the error code.
      *
      * @return mixed Returns the error code as integer
      **/
     final public function getCode(){}
 
     /**
      * Gets the file in which the error occurred
      *
      * Get the name of the file the error occurred.
      *
      * @return string Returns the filename in which the error occurred.
      **/
     final public function getFile(){}
 
     /**
      * Gets the line in which the error occurred
      *
      * Get line number where the error occurred.
      *
      * @return int Returns the line number where the error occurred.
      **/
     final public function getLine(){}
 
     /**
      * Gets the error message
      *
      * Returns the error message.
      *
      * @return string Returns the error message as a string.
      **/
     final public function getMessage(){}
 
     /**
      * Returns previous Throwable
      *
      * Returns previous Throwable (the third parameter of
      * Error::__construct).
      *
      * @return Throwable Returns the previous Throwable if available or
      *   NULL otherwise.
      **/
     final public function getPrevious(){}
 
     /**
      * Gets the stack trace
      *
      * Returns the stack trace.
      *
      * @return array Returns the stack trace as an array.
      **/
     final public function getTrace(){}
 
     /**
      * Gets the stack trace as a string
      *
      * Returns the stack trace as a string.
      *
      * @return string Returns the stack trace as a string.
      **/
     final public function getTraceAsString(){}
 
     /**
      * Clone the error
      *
      * Error can not be cloned, so this method results in fatal error.
      *
      * @return void
      **/
     final private function __clone(){}
 
     /**
      * String representation of the error
      *
      * Returns the string representation of the error.
      *
      * @return string Returns the string representation of the error.
      **/
     public function __toString(){}
 
 }
 /**
  * Exception is the base class for all Exceptions in PHP 5, and the base
  * class for all user exceptions in PHP 7. Before PHP 7, Exception did
  * not implement the Throwable interface.
  **/
 class Exception implements Throwable {
     /**
      * The exception code
      *
      * @var int
      **/
     protected $code;
 
     /**
      * The filename where the exception was created
      *
      * @var string
      **/
     protected $file;
 
     /**
      * The line where the exception was created
      *
      * @var int
      **/
     protected $line;
 
     /**
      * The exception message
      *
      * @var string
      **/
     protected $message;
 
     /**
      * Gets the Exception code
      *
      * Returns the Exception code.
      *
      * @return mixed Returns the exception code as integer in Exception but
      *   possibly as other type in Exception descendants (for example as
      *   string in PDOException).
      * @since PHP 5, PHP 7
      **/
     final public function getCode(){}
 
     /**
      * Gets the file in which the exception was created
      *
      * Get the name of the file in which the exception was created.
      *
      * @return string Returns the filename in which the exception was
      *   created.
      * @since PHP 5, PHP 7
      **/
     final public function getFile(){}
 
     /**
      * Gets the line in which the exception was created
      *
      * Get line number where the exception was created.
      *
      * @return int Returns the line number where the exception was created.
      * @since PHP 5, PHP 7
      **/
     final public function getLine(){}
 
     /**
      * Gets the Exception message
      *
      * Returns the Exception message.
      *
      * @return string Returns the Exception message as a string.
      * @since PHP 5, PHP 7
      **/
     final public function getMessage(){}
 
     /**
      * Returns previous Exception
      *
      * Returns previous exception (the third parameter of
      * Exception::__construct).
      *
      * @return Throwable Returns the previous Throwable if available or
      *   NULL otherwise.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     final public function getPrevious(){}
 
     /**
      * Gets the stack trace
      *
      * Returns the Exception stack trace.
      *
      * @return array Returns the Exception stack trace as an array.
      * @since PHP 5, PHP 7
      **/
     final public function getTrace(){}
 
     /**
      * Gets the stack trace as a string
      *
      * Returns the Exception stack trace as a string.
      *
      * @return string Returns the Exception stack trace as a string.
      * @since PHP 5, PHP 7
      **/
     final public function getTraceAsString(){}
 
     /**
      * Clone the exception
      *
      * Tries to clone the Exception, which results in Fatal error.
      *
      * @return void
      * @since PHP 5, PHP 7
      **/
     final private function __clone(){}
 
     /**
      * String representation of the exception
      *
      * Returns the string representation of the exception.
      *
      * @return string Returns the string representation of the exception.
      * @since PHP 5, PHP 7
      **/
     public function __toString(){}
 
 }
 /**
  * The APCIterator class makes it easier to iterate over large APC
  * caches. This is helpful as it allows iterating over large caches in
  * steps, while grabbing a defined number of entries per lock instance,
  * so it frees the cache locks for other activities rather than hold up
  * the entire cache to grab 100 (the default) entries. Also, using
  * regular expression matching is more efficient as it's been moved to
  * the C level.
  **/
 class APCIterator implements Iterator {
     /**
      * Get current item
      *
      * Gets the current item from the APCIterator stack.
      *
      * @return mixed Returns the current item on success, or FALSE if no
      *   more items or exist, or on failure.
      * @since PECL apc >= 3.1.1
      **/
     public function current(){}
 
     /**
      * Get total count
      *
      * Get the total count.
      *
      * @return int The total count.
      * @since PECL apc >= 3.1.1
      **/
     public function getTotalCount(){}
 
     /**
      * Get total cache hits
      *
      * Gets the total number of cache hits.
      *
      * @return int The number of hits on success, or FALSE on failure.
      * @since PECL apc >= 3.1.1
      **/
     public function getTotalHits(){}
 
     /**
      * Get total cache size
      *
      * Gets the total cache size.
      *
      * @return int The total cache size.
      * @since PECL apc >= 3.1.1
      **/
     public function getTotalSize(){}
 
     /**
      * Get iterator key
      *
      * Gets the current iterator key.
      *
      * @return string Returns the key on success, or FALSE upon failure.
      * @since PECL apc >= 3.1.1
      **/
     public function key(){}
 
     /**
      * Move pointer to next item
      *
      * Moves the iterator pointer to the next element.
      *
      * @return bool
      * @since PECL apc >= 3.1.1
      **/
     public function next(){}
 
     /**
      * Rewinds iterator
      *
      * Rewinds back the iterator to the first element.
      *
      * @return void
      * @since PECL apc >= 3.1.1
      **/
     public function rewind(){}
 
     /**
      * Checks if current position is valid
      *
      * Checks if the current iterator position is valid.
      *
      * @return bool Returns TRUE if the current iterator position is valid,
      *   otherwise FALSE.
      * @since PECL apc >= 3.1.1
      **/
     public function valid(){}
 
     /**
      * Constructs an APCIterator iterator object
      *
      * Constructs an APCIterator object.
      *
      * @param string $cache The cache type, which will be user or file.
      * @param mixed $search A PCRE regular expression that matches against
      *   APC key names, either as a string for a single regular expression,
      *   or as an array of regular expressions. Or, optionally pass in NULL
      *   to skip the search.
      * @param int $format The desired format, as configured with one or
      *   more of the APC_ITER_* constants.
      * @param int $chunk_size The chunk size. Must be a value greater than
      *   0. The default value is 100.
      * @param int $list The type to list. Either pass in APC_LIST_ACTIVE or
      *   APC_LIST_DELETED.
      * @since PECL apc >= 3.1.1
      **/
     public function __construct($cache, $search, $format, $chunk_size, $list){}
 
 }
 /**
  * The APCUIterator class makes it easier to iterate over large APCu
  * caches. This is helpful as it allows iterating over large caches in
  * steps, while grabbing a defined number of entries per lock instance,
  * so it frees the cache locks for other activities rather than hold up
  * the entire cache to grab 100 (the default) entries. Also, using
  * regular expression matching is more efficient as it's been moved to
  * the C level.
  **/
 class APCUIterator implements Iterator {
     /**
      * Get current item
      *
      * Gets the current item from the APCUIterator stack.
      *
      * @return mixed Returns the current item on success, or FALSE if no
      *   more items or exist, or on failure.
      * @since PECL apcu >= 5.0.0
      **/
     public function current(){}
 
     /**
      * Get total count
      *
      * Get the total count.
      *
      * @return int The total count.
      * @since PECL apcu >= 5.0.0
      **/
     public function getTotalCount(){}
 
     /**
      * Get total cache hits
      *
      * Gets the total number of cache hits.
      *
      * @return int The number of hits on success, or FALSE on failure.
      * @since PECL apcu >= 5.0.0
      **/
     public function getTotalHits(){}
 
     /**
      * Get total cache size
      *
      * Gets the total cache size.
      *
      * @return int The total cache size.
      * @since PECL apcu >= 5.0.0
      **/
     public function getTotalSize(){}
 
     /**
      * Get iterator key
      *
      * Gets the current iterator key.
      *
      * @return string Returns the key on success, or FALSE upon failure.
      * @since PECL apcu >= 5.0.0
      **/
     public function key(){}
 
     /**
      * Move pointer to next item
      *
      * Moves the iterator pointer to the next element.
      *
      * @return bool
      * @since PECL apcu >= 5.0.0
      **/
     public function next(){}
 
     /**
      * Rewinds iterator
      *
      * Rewinds back the iterator to the first element.
      *
      * @return void
      * @since PECL apcu >= 5.0.0
      **/
     public function rewind(){}
 
     /**
      * Checks if current position is valid
      *
      * Checks if the current iterator position is valid.
      *
      * @return bool Returns TRUE if the current iterator position is valid,
      *   otherwise FALSE.
      * @since PECL apcu >= 5.0.0
      **/
     public function valid(){}
 
     /**
      * Constructs an APCUIterator iterator object
      *
      * Constructs an APCUIterator object.
      *
      * @param mixed $search A PCRE regular expression that matches against
      *   APCu key names, either as a string for a single regular expression,
      *   or as an array of regular expressions. Or, optionally pass in NULL
      *   to skip the search.
      * @param int $format The desired format, as configured with one or
      *   more of the APC_ITER_* constants.
      * @param int $chunk_size The chunk size. Must be a value greater than
      *   0. The default value is 100.
      * @param int $list The type to list. Either pass in APC_LIST_ACTIVE or
      *   APC_LIST_DELETED.
      * @since PECL apcu >= 5.0.0
      **/
     public function __construct($search, $format, $chunk_size, $list){}
 
 }
 /**
  * An Iterator that iterates over several iterators one after the other.
  **/
 class AppendIterator extends IteratorIterator implements OuterIterator {
     /**
      * Appends an iterator
      *
      * @param Iterator $iterator The iterator to append.
      * @return void
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function append($iterator){}
 
     /**
      * Gets the current value
      *
      * @return mixed The current value if it is valid or NULL otherwise.
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function current(){}
 
     /**
      * Gets the ArrayIterator
      *
      * This method gets the ArrayIterator that is used to store the iterators
      * added with AppendIterator::append.
      *
      * @return ArrayIterator Returns an ArrayIterator containing the
      *   appended iterators.
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function getArrayIterator(){}
 
     /**
      * Gets the inner iterator
      *
      * This method returns the current inner iterator.
      *
      * @return Iterator The current inner iterator, or NULL if there is not
      *   one.
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function getInnerIterator(){}
 
     /**
      * Gets an index of iterators
      *
      * Gets the index of the current inner iterator.
      *
      * @return int Returns an integer, which is the zero-based index of the
      *   current inner iterator.
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function getIteratorIndex(){}
 
     /**
      * Gets the current key
      *
      * Get the current key.
      *
      * @return scalar The current key if it is valid or NULL otherwise.
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function key(){}
 
     /**
      * Moves to the next element
      *
      * Moves to the next element. If this means to another Iterator then it
      * rewinds that Iterator.
      *
      * @return void
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function next(){}
 
     /**
      * Rewinds the Iterator
      *
      * Rewind to the first element of the first inner Iterator.
      *
      * @return void
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function rewind(){}
 
     /**
      * Checks validity of the current element
      *
      * @return bool Returns TRUE if the current iteration is valid, FALSE
      *   otherwise.
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function valid(){}
 
 }
 /**
  * ArgumentCountError is thrown when too few arguments are passed to a
  * user-defined function or method.
  **/
 class ArgumentCountError extends TypeError {
 }
 /**
  * ArithmeticError is thrown when an error occurs while performing
  * mathematical operations. In PHP 7.0, these errors include attempting
  * to perform a bitshift by a negative amount, and any call to {@link
  * intdiv} that would result in a value outside the possible bounds of an
  * integer.
  **/
 class ArithmeticError extends Error {
 }
 /**
  * Interface to provide accessing objects as arrays.
  **/
 interface ArrayAccess {
     /**
      * Whether an offset exists
      *
      * Whether or not an offset exists.
      *
      * This method is executed when using {@link isset} or {@link empty} on
      * objects implementing ArrayAccess.
      *
      * @param mixed $offset An offset to check for.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function offsetExists($offset);
 
     /**
      * Offset to retrieve
      *
      * Returns the value at specified offset.
      *
      * This method is executed when checking if offset is {@link empty}.
      *
      * @param mixed $offset The offset to retrieve.
      * @return mixed Can return all value types.
      * @since PHP 5, PHP 7
      **/
     public function offsetGet($offset);
 
     /**
      * Assign a value to the specified offset
      *
      * Assigns a value to the specified offset.
      *
      * @param mixed $offset The offset to assign the value to.
      * @param mixed $value The value to set.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function offsetSet($offset, $value);
 
     /**
      * Unset an offset
      *
      * Unsets an offset.
      *
      * @param mixed $offset The offset to unset.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function offsetUnset($offset);
 
 }
 /**
  * This iterator allows to unset and modify values and keys while
  * iterating over Arrays and Objects. When you want to iterate over the
  * same array multiple times you need to instantiate ArrayObject and let
  * it create ArrayIterator instances that refer to it either by using or
  * by calling its getIterator() method manually.
  **/
 class ArrayIterator implements ArrayAccess, SeekableIterator, Countable, Serializable {
     /**
      * Entries can be accessed as properties (read and write).
      *
      * @var mixed
      **/
     const ARRAY_AS_PROPS = 0;
 
     /**
      * Properties of the object have their normal functionality when accessed
      * as list (var_dump, foreach, etc.).
      *
      * @var mixed
      **/
     const STD_PROP_LIST = 0;
 
     /**
      * Append an element
      *
      * Appends value as the last element.
      *
      * @param mixed $value The value to append.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function append($value){}
 
     /**
      * Sort array by values
      *
      * Sorts an array by values.
      *
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function asort(){}
 
     /**
      * Count elements
      *
      * Gets the number of elements in the array, or the number of public
      * properties in the object.
      *
      * @return int The number of elements or public properties in the
      *   associated array or object, respectively.
      * @since PHP 5, PHP 7
      **/
     public function count(){}
 
     /**
      * Return current array entry
      *
      * Get the current array entry.
      *
      * @return mixed The current array entry.
      * @since PHP 5, PHP 7
      **/
     public function current(){}
 
     /**
      * Get array copy
      *
      * Get a copy of an array.
      *
      * @return array A copy of the array, or array of public properties if
      *   ArrayIterator refers to an object.
      * @since PHP 5, PHP 7
      **/
     public function getArrayCopy(){}
 
     /**
      * Get behavior flags
      *
      * Gets the behavior flags of the ArrayIterator. See the
      * ArrayIterator::setFlags method for a list of the available flags.
      *
      * @return int Returns the behavior flags of the ArrayIterator.
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function getFlags(){}
 
     /**
      * Return current array key
      *
      * This function returns the current array key
      *
      * @return mixed The current array key.
      * @since PHP 5, PHP 7
      **/
     public function key(){}
 
     /**
      * Sort array by keys
      *
      * Sorts an array by the keys.
      *
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function ksort(){}
 
     /**
      * Sort an array naturally, case insensitive
      *
      * Sort the entries by values using a case insensitive "natural order"
      * algorithm.
      *
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function natcasesort(){}
 
     /**
      * Sort an array naturally
      *
      * Sort the entries by values using "natural order" algorithm.
      *
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function natsort(){}
 
     /**
      * Move to next entry
      *
      * The iterator to the next entry.
      *
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function next(){}
 
     /**
      * Check if offset exists
      *
      * Checks if the offset exists.
      *
      * @param mixed $index The offset being checked.
      * @return bool TRUE if the offset exists, otherwise FALSE
      * @since PHP 5, PHP 7
      **/
     public function offsetExists($index){}
 
     /**
      * Get value for an offset
      *
      * Gets the value from the provided offset.
      *
      * @param mixed $index The offset to get the value from.
      * @return mixed The value at offset {@link index}.
      * @since PHP 5, PHP 7
      **/
     public function offsetGet($index){}
 
     /**
      * Set value for an offset
      *
      * Sets a value for a given offset.
      *
      * @param mixed $index The index to set for.
      * @param mixed $newval The new value to store at the index.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function offsetSet($index, $newval){}
 
     /**
      * Unset value for an offset
      *
      * Unsets a value for an offset.
      *
      * If iteration is in progress, and ArrayIterator::offsetUnset is used to
      * unset the current index of iteration, the iteration position will be
      * advanced to the next index. Since the iteration position is also
      * advanced at the end of a loop body, use of ArrayIterator::offsetUnset
      * inside a foreach loop may result in indices being skipped.
      *
      * @param mixed $index The offset to unset.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function offsetUnset($index){}
 
     /**
      * Rewind array back to the start
      *
      * This rewinds the iterator to the beginning.
      *
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function rewind(){}
 
     /**
      * Seek to position
      *
      * @param int $position The position to seek to.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function seek($position){}
 
     /**
      * Serialize
      *
      * @return string The serialized ArrayIterator.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function serialize(){}
 
     /**
      * Set behaviour flags
      *
      * Set the flags that change the behavior of the ArrayIterator.
      *
      * @param string $flags The new ArrayIterator behavior. It takes on
      *   either a bitmask, or named constants. Using named constants is
      *   strongly encouraged to ensure compatibility for future versions. The
      *   available behavior flags are listed below. The actual meanings of
      *   these flags are described in the predefined constants. ArrayIterator
      *   behavior flags value constant 1 ArrayIterator::STD_PROP_LIST 2
      *   ArrayIterator::ARRAY_AS_PROPS
      * @return void
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function setFlags($flags){}
 
     /**
      * Sort with a user-defined comparison function and maintain index
      * association
      *
      * This method sorts the elements such that indices maintain their
      * correlation with the values they are associated with, using a
      * user-defined comparison function.
      *
      * @param callable $cmp_function
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function uasort($cmp_function){}
 
     /**
      * Sort by keys using a user-defined comparison function
      *
      * This method sorts the elements by keys using a user-supplied
      * comparison function.
      *
      * @param callable $cmp_function
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function uksort($cmp_function){}
 
     /**
      * Unserialize
      *
      * @param string $serialized The serialized ArrayIterator object to be
      *   unserialized.
      * @return void
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function unserialize($serialized){}
 
     /**
      * Check whether array contains more entries
      *
      * Checks if the array contains any more entries.
      *
      * @return bool Returns TRUE if the iterator is valid, otherwise FALSE
      * @since PHP 5, PHP 7
      **/
     public function valid(){}
 
     /**
      * Construct an ArrayIterator
      *
      * Constructs an ArrayIterator object.
      *
      * @param mixed $array The array or object to be iterated on.
      * @param int $flags Flags to control the behaviour of the
      *   ArrayIterator object. See ArrayIterator::setFlags.
      * @since PHP 5, PHP 7
      **/
     public function __construct($array, $flags){}
 
 }
 /**
  * This class allows objects to work as arrays.
  **/
 class ArrayObject implements IteratorAggregate, ArrayAccess, Serializable, Countable {
     /**
      * Entries can be accessed as properties (read and write).
      *
      * @var mixed
      **/
     const ARRAY_AS_PROPS = 0;
 
     /**
      * Properties of the object have their normal functionality when accessed
      * as list (var_dump, foreach, etc.).
      *
      * @var mixed
      **/
     const STD_PROP_LIST = 0;
 
     /**
      * Appends the value
      *
      * Appends a new value as the last element.
      *
      * @param mixed $value The value being appended.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function append($value){}
 
     /**
      * Sort the entries by value
      *
      * Sorts the entries such that the keys maintain their correlation with
      * the entries they are associated with. This is used mainly when sorting
      * associative arrays where the actual element order is significant.
      *
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function asort(){}
 
     /**
      * Get the number of public properties in the ArrayObject
      *
      * Get the number of public properties in the ArrayObject.
      *
      * @return int The number of public properties in the ArrayObject.
      * @since PHP 5, PHP 7
      **/
     public function count(){}
 
     /**
      * Exchange the array for another one
      *
      * Exchange the current array with another array or object.
      *
      * @param mixed $input The new array or object to exchange with the
      *   current array.
      * @return array Returns the old array.
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function exchangeArray($input){}
 
     /**
      * Creates a copy of the ArrayObject
      *
      * Exports the ArrayObject to an array.
      *
      * @return array Returns a copy of the array. When the ArrayObject
      *   refers to an object, an array of the public properties of that
      *   object will be returned.
      * @since PHP 5, PHP 7
      **/
     public function getArrayCopy(){}
 
     /**
      * Gets the behavior flags
      *
      * Gets the behavior flags of the ArrayObject. See the
      * ArrayObject::setFlags method for a list of the available flags.
      *
      * @return int Returns the behavior flags of the ArrayObject.
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function getFlags(){}
 
     /**
      * Create a new iterator from an ArrayObject instance
      *
      * Create a new iterator from an ArrayObject instance.
      *
      * @return ArrayIterator An iterator from an ArrayObject.
      * @since PHP 5, PHP 7
      **/
     public function getIterator(){}
 
     /**
      * Gets the iterator classname for the ArrayObject
      *
      * Gets the class name of the array iterator that is used by
      * ArrayObject::getIterator().
      *
      * @return string Returns the iterator class name that is used to
      *   iterate over this object.
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function getIteratorClass(){}
 
     /**
      * Sort the entries by key
      *
      * Sorts the entries by key, maintaining key to entry correlations. This
      * is useful mainly for associative arrays.
      *
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function ksort(){}
 
     /**
      * Sort an array using a case insensitive "natural order" algorithm
      *
      * This method is a case insensitive version of ArrayObject::natsort.
      *
      * This method implements a sort algorithm that orders alphanumeric
      * strings in the way a human being would while maintaining key/value
      * associations. This is described as a "natural ordering".
      *
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function natcasesort(){}
 
     /**
      * Sort entries using a "natural order" algorithm
      *
      * This method implements a sort algorithm that orders alphanumeric
      * strings in the way a human being would while maintaining key/value
      * associations. This is described as a "natural ordering". An example of
      * the difference between this algorithm and the regular computer string
      * sorting algorithms (used in ArrayObject::asort) method can be seen in
      * the example below.
      *
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function natsort(){}
 
     /**
      * Returns whether the requested index exists
      *
      * @param mixed $index The index being checked.
      * @return bool TRUE if the requested index exists, otherwise FALSE
      * @since PHP 5, PHP 7
      **/
     public function offsetExists($index){}
 
     /**
      * Returns the value at the specified index
      *
      * @param mixed $index The index with the value.
      * @return mixed The value at the specified index or NULL.
      * @since PHP 5, PHP 7
      **/
     public function offsetGet($index){}
 
     /**
      * Sets the value at the specified index to newval
      *
      * @param mixed $index The index being set.
      * @param mixed $newval The new value for the {@link index}.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function offsetSet($index, $newval){}
 
     /**
      * Unsets the value at the specified index
      *
      * @param mixed $index The index being unset.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function offsetUnset($index){}
 
     /**
      * Serialize an ArrayObject
      *
      * Serializes an ArrayObject.
      *
      * @return string The serialized representation of the ArrayObject.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function serialize(){}
 
     /**
      * Sets the behavior flags
      *
      * Set the flags that change the behavior of the ArrayObject.
      *
      * @param int $flags The new ArrayObject behavior. It takes on either a
      *   bitmask, or named constants. Using named constants is strongly
      *   encouraged to ensure compatibility for future versions. The
      *   available behavior flags are listed below. The actual meanings of
      *   these flags are described in the predefined constants. ArrayObject
      *   behavior flags value constant 1 ArrayObject::STD_PROP_LIST 2
      *   ArrayObject::ARRAY_AS_PROPS
      * @return void
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function setFlags($flags){}
 
     /**
      * Sets the iterator classname for the ArrayObject
      *
      * Sets the classname of the array iterator that is used by
      * ArrayObject::getIterator().
      *
      * @param string $iterator_class The classname of the array iterator to
      *   use when iterating over this object.
      * @return void
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function setIteratorClass($iterator_class){}
 
     /**
      * Sort the entries with a user-defined comparison function and maintain
      * key association
      *
      * This function sorts the entries such that keys maintain their
      * correlation with the entry that they are associated with, using a
      * user-defined comparison function.
      *
      * This is used mainly when sorting associative arrays where the actual
      * element order is significant.
      *
      * @param callable $cmp_function Function {@link cmp_function} should
      *   accept two parameters which will be filled by pairs of entries. The
      *   comparison function must return an integer less than, equal to, or
      *   greater than zero if the first argument is considered to be
      *   respectively less than, equal to, or greater than the second.
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function uasort($cmp_function){}
 
     /**
      * Sort the entries by keys using a user-defined comparison function
      *
      * This function sorts the keys of the entries using a user-supplied
      * comparison function. The key to entry correlations will be maintained.
      *
      * @param callable $cmp_function The callback comparison function.
      *   Function {@link cmp_function} should accept two parameters which
      *   will be filled by pairs of entry keys. The comparison function must
      *   return an integer less than, equal to, or greater than zero if the
      *   first argument is considered to be respectively less than, equal to,
      *   or greater than the second.
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function uksort($cmp_function){}
 
     /**
      * Unserialize an ArrayObject
      *
      * Unserializes a serialized ArrayObject.
      *
      * @param string $serialized The serialized ArrayObject.
      * @return void The unserialized ArrayObject.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function unserialize($serialized){}
 
 }
 /**
  * AssertionError is thrown when an assertion made via {@link assert}
  * fails.
  **/
 class AssertionError extends Error {
 }
 /**
  * Exception thrown if a callback refers to an undefined function or if
  * some arguments are missing.
  **/
 class BadFunctionCallException extends LogicException {
 }
 /**
  * Exception thrown if a callback refers to an undefined method or if
  * some arguments are missing.
  **/
 class BadMethodCallException extends BadFunctionCallException {
 }
 /**
  * This object supports cached iteration over another iterator.
  **/
 class CachingIterator extends IteratorIterator implements OuterIterator, ArrayAccess, Countable {
     /**
      * @var integer
      **/
     const CALL_TOSTRING = 0;
 
     /**
      * @var integer
      **/
     const CATCH_GET_CHILD = 0;
 
     /**
      * @var integer
      **/
     const FULL_CACHE = 0;
 
     /**
      * @var integer
      **/
     const TOSTRING_USE_CURRENT = 0;
 
     /**
      * @var integer
      **/
     const TOSTRING_USE_INNER = 0;
 
     /**
      * @var integer
      **/
     const TOSTRING_USE_KEY = 0;
 
     /**
      * The number of elements in the iterator
      *
      * May return the number of elements in the iterator.
      *
      * @return int The count of the elements iterated over.
      * @since PHP 5 >= 5.2.2, PHP 7
      **/
     public function count(){}
 
     /**
      * Return the current element
      *
      * May return the current element in the iteration.
      *
      * @return mixed Mixed
      * @since PHP 5, PHP 7
      **/
     public function current(){}
 
     /**
      * Retrieve the contents of the cache
      *
      * @return array An array containing the cache items.
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function getCache(){}
 
     /**
      * Get flags used
      *
      * Get the bitmask of the flags used for this CachingIterator instance.
      *
      * @return int Description...
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function getFlags(){}
 
     /**
      * Returns the inner iterator
      *
      * Returns the iterator sent to the constructor.
      *
      * @return Iterator Returns an object implementing the Iterator
      *   interface.
      * @since PHP 5, PHP 7
      **/
     public function getInnerIterator(){}
 
     /**
      * Check whether the inner iterator has a valid next element
      *
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function hasNext(){}
 
     /**
      * Return the key for the current element
      *
      * This method may return a key for the current element.
      *
      * @return scalar
      * @since PHP 5, PHP 7
      **/
     public function key(){}
 
     /**
      * Move the iterator forward
      *
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function next(){}
 
     /**
      * The offsetExists purpose
      *
      * @param mixed $index The index being checked.
      * @return void Returns TRUE if an entry referenced by the offset
      *   exists, FALSE otherwise.
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function offsetExists($index){}
 
     /**
      * The offsetGet purpose
      *
      * @param string $index Description...
      * @return void Description...
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function offsetGet($index){}
 
     /**
      * The offsetSet purpose
      *
      * @param mixed $index The index of the element to be set.
      * @param mixed $newval The new value for the {@link index}.
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function offsetSet($index, $newval){}
 
     /**
      * The offsetUnset purpose
      *
      * @param string $index The index of the element to be unset.
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function offsetUnset($index){}
 
     /**
      * Rewind the iterator
      *
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function rewind(){}
 
     /**
      * The setFlags purpose
      *
      * Set the flags for the CachingIterator object.
      *
      * @param int $flags Bitmask of the flags to set.
      * @return void
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function setFlags($flags){}
 
     /**
      * Check whether the current element is valid
      *
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function valid(){}
 
     /**
      * Construct a new CachingIterator object for the iterator
      *
      * @param Iterator $iterator Iterator to cache
      * @param int $flags Bitmask of flags.
      * @since PHP 5, PHP 7
      **/
     public function __construct($iterator, $flags){}
 
     /**
      * Return the string representation of the current element
      *
      * Get the string representation of the current element.
      *
      * @return void The string representation of the current element.
      * @since PHP 5, PHP 7
      **/
     public function __toString(){}
 
 }
 /**
  * Simple class with some static helper methods.
  **/
 class Cairo {
     /**
      * Retrieves the availables font types
      *
      * Returns an array with the available font backends
      *
      * @return array A list-type array with all available font backends.
      * @since PECL cairo >= 0.1.0
      **/
     public static function availableFonts(){}
 
     /**
      * Retrieves all available surfaces
      *
      * Returns an array with the available surface backends
      *
      * @return array A list-type array with all available surface backends.
      * @since PECL cairo >= 0.1.0
      **/
     public static function availableSurfaces(){}
 
     /**
      * Retrieves the current status as string
      *
      * Retrieves the current status as a readable string
      *
      * @param int $status A valid status code given by {@link cairo_status}
      *   or CairoContext::status
      * @return string A string containing the current status of a
      *   CairoContext object
      * @since PECL cairo >= 0.1.0
      **/
     public static function statusToString($status){}
 
     /**
      * Retrieves cairo's library version
      *
      * Retrieves the current version of the cairo library as an integer value
      *
      * @return int Current Cairo library version integer
      * @since PECL cairo >= 0.1.0
      **/
     public static function version(){}
 
     /**
      * Retrieves cairo version as string
      *
      * Retrieves the current cairo library version as a string.
      *
      * @return string Current Cairo library version string
      * @since PECL cairo >= 0.1.0
      **/
     public static function versionString(){}
 
 }
 /**
  * Enum class that specifies the type of antialiasing to do when
  * rendering text or shapes.
  **/
 class CairoAntialias {
     /**
      * @var integer
      **/
     const MODE_DEFAULT = 0;
 
     /**
      * @var integer
      **/
     const MODE_GRAY = 0;
 
     /**
      * @var integer
      **/
     const MODE_NONE = 0;
 
     /**
      * @var integer
      **/
     const MODE_SUBPIXEL = 0;
 
 }
 /**
  * CairoContent is used to describe the content that a surface will
  * contain, whether color information, alpha information (translucence
  * vs. opacity), or both. Note: The large values here are designed to
  * keep CairoContent values distinct from CairoContent values so that the
  * implementation can detect the error if users confuse the two types.
  **/
 class CairoContent {
     /**
      * The surface will hold alpha content only.
      *
      * @var integer
      **/
     const ALPHA = 0;
 
     /**
      * The surface will hold color content only.
      *
      * @var integer
      **/
     const COLOR = 0;
 
     /**
      * @var integer
      **/
     const COLOR_ALPHA = 0;
 
 }
 /**
  * Context is the main object used when drawing with cairo. To draw with
  * cairo, you create a CairoContext, set the target CairoSurface, and
  * drawing options for the CairoContext, create shapes with functions .
  * like CairoContext::moveTo and CairoContext::lineTo, and then draw
  * shapes with CairoContext::stroke or CairoContext::fill.
  *
  * Contexts can be pushed to a stack via CairoContext::save. They may
  * then safely be changed, without losing the current state. Use
  * CairoContext::restore to restore to the saved state.
  **/
 class CairoContext {
     /**
      * Appends a path to current path
      *
      * Appends the {@link path} onto the current path. The {@link path} may
      * be either the return value from one of CairoContext::copyPath or
      * CairoContext::copyPathFlat;
      *
      * if {@link path} is not a valid CairoPath instance a CairoException
      * will be thrown
      *
      * @param CairoPath $path CairoContext object
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function appendPath($path){}
 
     /**
      * Adds a circular arc
      *
      * Adds a circular arc of the given radius to the current path. The arc
      * is centered at ({@link x}, {@link y}), begins at {@link angle1} and
      * proceeds in the direction of increasing angles to end at {@link
      * angle2}. If {@link angle2} is less than {@link angle1} it will be
      * progressively increased by 2*M_PI until it is greater than {@link
      * angle1}. If there is a current point, an initial line segment will be
      * added to the path to connect the current point to the beginning of the
      * arc. If this initial line is undesired, it can be avoided by calling
      * CairoContext::newSubPath or procedural {@link cairo_new_sub_path}
      * before calling CairoContext::arc or {@link cairo_arc}.
      *
      * Angles are measured in radians. An angle of 0.0 is in the direction of
      * the positive X axis (in user space). An angle of M_PI/2.0 radians (90
      * degrees) is in the direction of the positive Y axis (in user space).
      * Angles increase in the direction from the positive X axis toward the
      * positive Y axis. So with the default transformation matrix, angles
      * increase in a clockwise direction.
      *
      * (To convert from degrees to radians, use degrees * (M_PI / 180.).)
      * This function gives the arc in the direction of increasing angles; see
      * CairoContext::arcNegative or {@link cairo_arc_negative} to get the arc
      * in the direction of decreasing angles.
      *
      * @param float $x A valid CairoContext object
      * @param float $y x position
      * @param float $radius y position
      * @param float $angle1 Radius of the arc
      * @param float $angle2 start angle
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function arc($x, $y, $radius, $angle1, $angle2){}
 
     /**
      * Adds a negative arc
      *
      * Adds a circular arc of the given {@link radius} to the current path.
      * The arc is centered at ({@link x}, {@link y}), begins at {@link
      * angle1} and proceeds in the direction of decreasing angles to end at
      * {@link angle2}. If {@link angle2} is greater than {@link angle1} it
      * will be progressively decreased by 2*M_PI until it is less than {@link
      * angle1}.
      *
      * See CairoContext::arc or {@link cairo_arc} for more details. This
      * function differs only in the direction of the arc between the two
      * angles.
      *
      * @param float $x A valid CairoContext object
      * @param float $y double x position
      * @param float $radius double y position
      * @param float $angle1 The radius of the desired negative arc
      * @param float $angle2 Start angle of the arc
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function arcNegative($x, $y, $radius, $angle1, $angle2){}
 
     /**
      * Establishes a new clip region
      *
      * Establishes a new clip region by intersecting the current clip region
      * with the current path as it would be filled by CairoContext::fill or
      * {@link cairo_fill} and according to the current fill rule (see
      * CairoContext::setFillRule or {@link cairo_set_fill_rule}).
      *
      * After CairoContext::clip or {@link cairo_clip}, the current path will
      * be cleared from the cairo context.
      *
      * The current clip region affects all drawing operations by effectively
      * masking out any changes to the surface that are outside the current
      * clip region.
      *
      * Calling CairoContext::clip or {@link cairo_clip} can only make the
      * clip region smaller, never larger. But the current clip is part of the
      * graphics state, so a temporary restriction of the clip region can be
      * achieved by calling CairoContext::clip or {@link cairo_clip} within a
      * CairoContext::save/CairoContext::restore or {@link cairo_save}/{@link
      * cairo_restore} pair. The only other means of increasing the size of
      * the clip region is CairoContext::resetClip or procedural {@link
      * cairo_reset_clip}.
      *
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function clip(){}
 
     /**
      * Computes the area inside the current clip
      *
      * Computes a bounding box in user coordinates covering the area inside
      * the current clip.
      *
      * @return array An array containing the (float)x1, (float)y1,
      *   (float)x2, (float)y2, coordinates covering the area inside the
      *   current clip
      * @since PECL cairo >= 0.1.0
      **/
     public function clipExtents(){}
 
     /**
      * Establishes a new clip region from the current clip
      *
      * Establishes a new clip region by intersecting the current clip region
      * with the current path as it would be filled by Context.fill and
      * according to the current FILL RULE (see CairoContext::setFillRule or
      * {@link cairo_set_fill_rule}).
      *
      * Unlike CairoContext::clip, CairoContext::clipPreserve preserves the
      * path within the Context. The current clip region affects all drawing
      * operations by effectively masking out any changes to the surface that
      * are outside the current clip region.
      *
      * Calling CairoContext::clipPreserve can only make the clip region
      * smaller, never larger. But the current clip is part of the graphics
      * state, so a temporary restriction of the clip region can be achieved
      * by calling CairoContext::clipPreserve within a
      * CairoContext::save/CairoContext::restore pair. The only other means of
      * increasing the size of the clip region is CairoContext::resetClip.
      *
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function clipPreserve(){}
 
     /**
      * Retrieves the current clip as a list of rectangles
      *
      * Returns a list-type array with the current clip region as a list of
      * rectangles in user coordinates
      *
      * @return array An array of user-space represented rectangles for the
      *   current clip
      * @since PECL cairo >= 0.1.0
      **/
     public function clipRectangleList(){}
 
     /**
      * Closes the current path
      *
      * Adds a line segment to the path from the current point to the
      * beginning of the current sub-path, (the most recent point passed to
      * CairoContext::moveTo), and closes this sub-path. After this call the
      * current point will be at the joined endpoint of the sub-path.
      *
      * The behavior of close_path() is distinct from simply calling
      * CairoContext::lineTo with the equivalent coordinate in the case of
      * stroking. When a closed sub-path is stroked, there are no caps on the
      * ends of the sub-path. Instead, there is a line join connecting the
      * final and initial segments of the sub-path.
      *
      * If there is no current point before the call to
      * CairoContext::closePath, this function will have no effect.
      *
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function closePath(){}
 
     /**
      * Emits the current page
      *
      * Emits the current page for backends that support multiple pages, but
      * doesn’t clear it, so, the contents of the current page will be
      * retained for the next page too. Use CairoContext::showPage if you want
      * to get an empty page after the emission.
      *
      * This is a convenience function that simply calls
      * CairoSurface::copyPage on CairoContext’s target.
      *
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function copyPage(){}
 
     /**
      * Creates a copy of the current path
      *
      * Creates a copy of the current path and returns it to the user as a
      * CairoPath. See CairoPath for hints on how to iterate over the returned
      * data structure.
      *
      * This function will always return a valid CairoPath object, but the
      * result will have no data, if either of the following conditions hold:
      * 1. If there is insufficient memory to copy the path. In this case
      * CairoPath->status will be set to CAIRO_STATUS_NO_MEMORY. 2. If {@link
      * context} is already in an error state. In this case CairoPath->status
      * will contain the same status that would be returned by {@link
      * cairo_status}.
      *
      * In either case, CairoPath->status will be set to
      * CAIRO_STATUS_NO_MEMORY (regardless of what the error status in cr
      * might have been).
      *
      * @return CairoPath A copy of the current CairoPath in the context
      * @since PECL cairo >= 0.1.0
      **/
     public function copyPath(){}
 
     /**
      * Gets a flattened copy of the current path
      *
      * Gets a flattened copy of the current path and returns it to the user
      * as a CairoPath.
      *
      * This function is like CairoContext::copyPath except that any curves in
      * the path will be approximated with piecewise-linear approximations,
      * (accurate to within the current tolerance value). That is, the result
      * is guaranteed to not have any elements of type CAIRO_PATH_CURVE_TO
      * which will instead be replaced by a series of CAIRO_PATH_LINE_TO
      * elements.
      *
      * @return CairoPath A copy of the current path
      * @since PECL cairo >= 0.1.0
      **/
     public function copyPathFlat(){}
 
     /**
      * Adds a curve
      *
      * Adds a cubic Bezier spline to the path from the current point to
      * position {@link x3} ,{@link y3} in user-space coordinates, using
      * {@link x1}, {@link y1} and {@link x2}, {@link y2} as the control
      * points. After this call the current point will be {@link x3}, {@link
      * y3}.
      *
      * If there is no current point before the call to CairoContext::curveTo
      * this function will behave as if preceded by a call to
      * CairoContext::moveTo ({@link x1}, {@link y1}).
      *
      * @param float $x1 A valid CairoContext object created with
      *   CairoContext::__construct or {@link cairo_create}
      * @param float $y1 First control point in the x axis for the curve
      * @param float $x2 First control point in the y axis for the curve
      * @param float $y2 Second control point in x axis for the curve
      * @param float $x3 Second control point in y axis for the curve
      * @param float $y3 Final point in the x axis for the curve
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function curveTo($x1, $y1, $x2, $y2, $x3, $y3){}
 
     /**
      * Transform a coordinate
      *
      * Transform a coordinate from device space to user space by multiplying
      * the given point by the inverse of the current transformation matrix
      * (CTM).
      *
      * @param float $x A valid CairoContext object created with
      *   CairoContext::__construct or {@link cairo_create}
      * @param float $y x value of the coordinate
      * @return array An array containing the x and y coordinates in the
      *   user-space
      * @since PECL cairo >= 0.1.0
      **/
     public function deviceToUser($x, $y){}
 
     /**
      * Transform a distance
      *
      * Transform a distance vector from device space to user space. This
      * function is similar to CairoContext::deviceToUser or {@link
      * cairo_device_to_user} except that the translation components of the
      * inverse Cairo Transformation Matrix will be ignored when transforming
      * ({@link x},{@link y}).
      *
      * @param float $x A valid CairoContext object created with
      *   CairoContext::__construct or {@link cairo_create}
      * @param float $y X component of a distance vector
      * @return array Returns an array with the x and y values of a distance
      *   vector in the user-space
      * @since PECL cairo >= 0.1.0
      **/
     public function deviceToUserDistance($x, $y){}
 
     /**
      * Fills the current path
      *
      * A drawing operator that fills the current path according to the
      * current CairoFillRule, (each sub-path is implicitly closed before
      * being filled). After CairoContext::fill or {@link cairo_fill}, the
      * current path will be cleared from the CairoContext.
      *
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function fill(){}
 
     /**
      * Computes the filled area
      *
      * Computes a bounding box in user coordinates covering the area that
      * would be affected, (the “inked” area), by a CairoContext::fill
      * operation given the current path and fill parameters. If the current
      * path is empty, returns an empty rectangle (0,0,0,0). Surface
      * dimensions and clipping are not taken into account.
      *
      * Contrast with CairoContext::pathExtents, which is similar, but returns
      * non-zero extents for some paths with no inked area, (such as a simple
      * line segment).
      *
      * Note that CairoContext::fillExtents must necessarily do more work to
      * compute the precise inked areas in light of the fill rule, so
      * CairoContext::pathExtents may be more desirable for sake of
      * performance if the non-inked path extents are desired.
      *
      * @return array An array with the coordinates of the afected area
      * @since PECL cairo >= 0.1.0
      **/
     public function fillExtents(){}
 
     /**
      * Fills and preserve the current path
      *
      * A drawing operator that fills the current path according to the
      * current CairoFillRule, (each sub-path is implicitly closed before
      * being filled). Unlike CairoContext::fill, CairoContext::fillPreserve
      * (Procedural {@link cairo_fill}, {@link cairo_fill_preserve},
      * respectively) preserves the path within the Context.
      *
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function fillPreserve(){}
 
     /**
      * Get the font extents
      *
      * Gets the font extents for the currently selected font.
      *
      * @return array An array containing the font extents for the current
      *   font.
      * @since PECL cairo >= 0.1.0
      **/
     public function fontExtents(){}
 
     /**
      * Retrieves the current antialias mode
      *
      * Returns the current CairoAntialias mode, as set by
      * CairoContext::setAntialias.
      *
      * @return int The current CairoAntialias mode.
      * @since PECL cairo >= 0.1.0
      **/
     public function getAntialias(){}
 
     /**
      * The getCurrentPoint purpose
      *
      * Gets the current point of the current path, which is conceptually the
      * final point reached by the path so far.
      *
      * The current point is returned in the user-space coordinate system. If
      * there is no defined current point or if cr is in an error status, x
      * and y will both be set to 0.0. It is possible to check this in advance
      * with CairoContext::hasCurrentPoint.
      *
      * Most path construction functions alter the current point. See the
      * following for details on how they affect the current point:
      * CairoContext::newPath, CairoContext::newSubPath,
      * CairoContext::appendPath, CairoContext::closePath,
      * CairoContext::moveTo, CairoContext::lineTo, CairoContext::curveTo,
      * CairoContext::relMoveTo, CairoContext::relLineTo,
      * CairoContext::relCurveTo, CairoContext::arc,
      * CairoContext::arcNegative, CairoContext::rectangle,
      * CairoContext::textPath, CairoContext::glyphPath.
      *
      * Some functions use and alter the current point but do not otherwise
      * change current path: CairoContext::showText.
      *
      * Some functions unset the current path and as a result, current point:
      * CairoContext::fill, CairoContext::stroke.
      *
      * @return array An array containing the x (index 0) and y (index 1)
      *   coordinates of the current point.
      * @since PECL cairo >= 0.1.0
      **/
     public function getCurrentPoint(){}
 
     /**
      * The getDash purpose
      *
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getDash(){}
 
     /**
      * The getDashCount purpose
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getDashCount(){}
 
     /**
      * The getFillRule purpose
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getFillRule(){}
 
     /**
      * The getFontFace purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getFontFace(){}
 
     /**
      * The getFontMatrix purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getFontMatrix(){}
 
     /**
      * The getFontOptions purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getFontOptions(){}
 
     /**
      * The getGroupTarget purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getGroupTarget(){}
 
     /**
      * The getLineCap purpose
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getLineCap(){}
 
     /**
      * The getLineJoin purpose
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getLineJoin(){}
 
     /**
      * The getLineWidth purpose
      *
      * @return float Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getLineWidth(){}
 
     /**
      * The getMatrix purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getMatrix(){}
 
     /**
      * The getMiterLimit purpose
      *
      * @return float Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getMiterLimit(){}
 
     /**
      * The getOperator purpose
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getOperator(){}
 
     /**
      * The getScaledFont purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getScaledFont(){}
 
     /**
      * The getSource purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getSource(){}
 
     /**
      * The getTarget purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getTarget(){}
 
     /**
      * The getTolerance purpose
      *
      * @return float Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getTolerance(){}
 
     /**
      * The glyphPath purpose
      *
      * Adds closed paths for the glyphs to the current path. The generated
      * path if filled, achieves an effect similar to that of
      * CairoContext::showGlyphs.
      *
      * @param array $glyphs A CairoContext object
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function glyphPath($glyphs){}
 
     /**
      * The hasCurrentPoint purpose
      *
      * Returns whether a current point is defined on the current path. See
      * CairoContext::getCurrentPoint for details on the current point.
      *
      * @return bool Whether a current point is defined
      * @since PECL cairo >= 0.1.0
      **/
     public function hasCurrentPoint(){}
 
     /**
      * The identityMatrix purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function identityMatrix(){}
 
     /**
      * The inFill purpose
      *
      * @param float $x Description...
      * @param float $y Description...
      * @return bool Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function inFill($x, $y){}
 
     /**
      * The inStroke purpose
      *
      * @param float $x Description...
      * @param float $y Description...
      * @return bool Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function inStroke($x, $y){}
 
     /**
      * The lineTo purpose
      *
      * @param float $x Description...
      * @param float $y Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function lineTo($x, $y){}
 
     /**
      * The mask purpose
      *
      * @param CairoPattern $pattern Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function mask($pattern){}
 
     /**
      * The maskSurface purpose
      *
      * @param CairoSurface $surface Description...
      * @param float $x Description...
      * @param float $y Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function maskSurface($surface, $x, $y){}
 
     /**
      * The moveTo purpose
      *
      * Begin a new sub-path. After this call the current point will be (x,
      * y).
      *
      * @param float $x A valid CairoContext object.
      * @param float $y The x coordinate of the new position.
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function moveTo($x, $y){}
 
     /**
      * The newPath purpose
      *
      * Clears the current path. After this call there will be no path and no
      * current point.
      *
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function newPath(){}
 
     /**
      * The newSubPath purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function newSubPath(){}
 
     /**
      * The paint purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function paint(){}
 
     /**
      * The paintWithAlpha purpose
      *
      * @param float $alpha Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function paintWithAlpha($alpha){}
 
     /**
      * The pathExtents purpose
      *
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function pathExtents(){}
 
     /**
      * The popGroup purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function popGroup(){}
 
     /**
      * The popGroupToSource purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function popGroupToSource(){}
 
     /**
      * The pushGroup purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function pushGroup(){}
 
     /**
      * The pushGroupWithContent purpose
      *
      * @param int $content Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function pushGroupWithContent($content){}
 
     /**
      * The rectangle purpose
      *
      * @param float $x Description...
      * @param float $y Description...
      * @param float $width Description...
      * @param float $height Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function rectangle($x, $y, $width, $height){}
 
     /**
      * The relCurveTo purpose
      *
      * @param float $x1 Description...
      * @param float $y1 Description...
      * @param float $x2 Description...
      * @param float $y2 Description...
      * @param float $x3 Description...
      * @param float $y3 Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function relCurveTo($x1, $y1, $x2, $y2, $x3, $y3){}
 
     /**
      * The relLineTo purpose
      *
      * @param float $x Description...
      * @param float $y Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function relLineTo($x, $y){}
 
     /**
      * The relMoveTo purpose
      *
      * @param float $x Description...
      * @param float $y Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function relMoveTo($x, $y){}
 
     /**
      * The resetClip purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function resetClip(){}
 
     /**
      * The restore purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function restore(){}
 
     /**
      * The rotate purpose
      *
      * @param float $angle Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function rotate($angle){}
 
     /**
      * The save purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function save(){}
 
     /**
      * The scale purpose
      *
      * @param float $x Description...
      * @param float $y Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function scale($x, $y){}
 
     /**
      * The selectFontFace purpose
      *
      * @param string $family Description...
      * @param int $slant Description...
      * @param int $weight Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function selectFontFace($family, $slant, $weight){}
 
     /**
      * The setAntialias purpose
      *
      * @param int $antialias Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setAntialias($antialias){}
 
     /**
      * The setDash purpose
      *
      * @param array $dashes Description...
      * @param float $offset Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setDash($dashes, $offset){}
 
     /**
      * The setFillRule purpose
      *
      * @param int $setting Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setFillRule($setting){}
 
     /**
      * The setFontFace purpose
      *
      * Sets the font-face for a given context.
      *
      * @param CairoFontFace $fontface A CairoContext object to change the
      *   font-face for.
      * @return void No value is returned
      * @since PECL cairo >= 0.1.0
      **/
     public function setFontFace($fontface){}
 
     /**
      * The setFontMatrix purpose
      *
      * @param CairoMatrix $matrix Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setFontMatrix($matrix){}
 
     /**
      * The setFontOptions purpose
      *
      * @param CairoFontOptions $fontoptions Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setFontOptions($fontoptions){}
 
     /**
      * The setFontSize purpose
      *
      * @param float $size Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setFontSize($size){}
 
     /**
      * The setLineCap purpose
      *
      * @param int $setting Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setLineCap($setting){}
 
     /**
      * The setLineJoin purpose
      *
      * @param int $setting Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setLineJoin($setting){}
 
     /**
      * The setLineWidth purpose
      *
      * @param float $width Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setLineWidth($width){}
 
     /**
      * The setMatrix purpose
      *
      * @param CairoMatrix $matrix Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setMatrix($matrix){}
 
     /**
      * The setMiterLimit purpose
      *
      * @param float $limit Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setMiterLimit($limit){}
 
     /**
      * The setOperator purpose
      *
      * @param int $setting Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setOperator($setting){}
 
     /**
      * The setScaledFont purpose
      *
      * @param CairoScaledFont $scaledfont Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setScaledFont($scaledfont){}
 
     /**
      * The setSource purpose
      *
      * @param CairoPattern $pattern Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setSource($pattern){}
 
     /**
      * The setSourceRGB purpose
      *
      * @param float $red Description...
      * @param float $green Description...
      * @param float $blue Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setSourceRGB($red, $green, $blue){}
 
     /**
      * The setSourceRGBA purpose
      *
      * @param float $red Description...
      * @param float $green Description...
      * @param float $blue Description...
      * @param float $alpha Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setSourceRGBA($red, $green, $blue, $alpha){}
 
     /**
      * The setSourceSurface purpose
      *
      * @param CairoSurface $surface Description...
      * @param float $x Description...
      * @param float $y Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setSourceSurface($surface, $x, $y){}
 
     /**
      * The setTolerance purpose
      *
      * @param float $tolerance Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setTolerance($tolerance){}
 
     /**
      * The showPage purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function showPage(){}
 
     /**
      * The showText purpose
      *
      * @param string $text Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function showText($text){}
 
     /**
      * The status purpose
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function status(){}
 
     /**
      * The stroke purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function stroke(){}
 
     /**
      * The strokeExtents purpose
      *
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function strokeExtents(){}
 
     /**
      * The strokePreserve purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function strokePreserve(){}
 
     /**
      * The textExtents purpose
      *
      * @param string $text Description...
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function textExtents($text){}
 
     /**
      * The textPath purpose
      *
      * Adds closed paths for text to the current path. The generated path, if
      * filled, achieves an effect similar to that of CairoContext::showText.
      *
      * Text conversion and positioning is done similar to
      * CairoContext::showText.
      *
      * Like CairoContext::showText, after this call the current point is
      * moved to the origin of where the next glyph would be placed in this
      * same progression. That is, the current point will be at the origin of
      * the final glyph offset by its advance values. This allows for chaining
      * multiple calls to CairoContext::showText without having to set current
      * point in between.
      *
      * Note: The CairoContext::textPath function call is part of what the
      * cairo designers call the "toy" text API. It is convenient for short
      * demos and simple programs, but it is not expected to be adequate for
      * serious text-using applications. See CairoContext::glyphPath for the
      * "real" text path API in cairo.
      *
      * @param string $string A CairoContext object
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function textPath($string){}
 
     /**
      * The transform purpose
      *
      * @param CairoMatrix $matrix Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function transform($matrix){}
 
     /**
      * The translate purpose
      *
      * @param float $x Description...
      * @param float $y Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function translate($x, $y){}
 
     /**
      * The userToDevice purpose
      *
      * @param float $x Description...
      * @param float $y Description...
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function userToDevice($x, $y){}
 
     /**
      * The userToDeviceDistance purpose
      *
      * @param float $x Description...
      * @param float $y Description...
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function userToDeviceDistance($x, $y){}
 
     /**
      * Creates a new CairoContext
      *
      * Creates a new CairoContext object to draw
      *
      * @param CairoSurface $surface A valid CairoSurface like
      *   CairoImageSurface or CairoPdfSurface
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct($surface){}
 
 }
 /**
  * Exception class thrown by Cairo functions and methods
  **/
 class CairoException extends Exception {
 }
 class CairoExtend {
     /**
      * @var integer
      **/
     const NONE = 0;
 
     /**
      * @var integer
      **/
     const PAD = 0;
 
     /**
      * @var integer
      **/
     const REFLECT = 0;
 
     /**
      * @var integer
      **/
     const REPEAT = 0;
 
 }
 /**
  * A CairoFillRule is used to select how paths are filled. For both fill
  * rules, whether or not a point is included in the fill is determined by
  * taking a ray from that point to infinity and looking at intersections
  * with the path. The ray can be in any direction, as long as it doesn't
  * pass through the end point of a segment or have a tricky intersection
  * such as intersecting tangent to the path. (Note that filling is not
  * actually implemented in this way. This is just a description of the
  * rule that is applied.) The default fill rule is
  * CairoFillRule::WINDING.
  **/
 class CairoFillRule {
     /**
      * @var integer
      **/
     const EVEN_ODD = 0;
 
     /**
      * If the path crosses the ray from left-to-right, counts +1. If the path
      * crosses the ray from right to left, counts -1. (Left and right are
      * determined from the perspective of looking along the ray from the
      * starting point.) If the total count is non-zero, the point will be
      * filled.
      *
      * @var integer
      **/
     const WINDING = 0;
 
 }
 /**
  * A CairoFilter is used to indicate what filtering should be applied
  * when reading pixel values from patterns. See CairoPattern::setSource
  * or {@link cairo_pattern_set_source} for indicating the desired filter
  * to be used with a particular pattern.
  **/
 class CairoFilter {
     /**
      * The highest-quality available, performance may not be suitable for
      * interactive use.
      *
      * @var integer
      **/
     const BEST = 0;
 
     /**
      * Linear interpolation in two dimensions
      *
      * @var integer
      **/
     const BILINEAR = 0;
 
     /**
      * A high-performance filter, with quality similar to
      * CairoFilter::NEAREST
      *
      * @var integer
      **/
     const FAST = 0;
 
     /**
      * This filter value is currently unimplemented, and should not be used
      * in current code.
      *
      * @var integer
      **/
     const GAUSSIAN = 0;
 
     /**
      * A reasonable-performance filter, with quality similar to
      * CairoFilter::BILINEAR
      *
      * @var integer
      **/
     const GOOD = 0;
 
     /**
      * Nearest-neighbor filtering
      *
      * @var integer
      **/
     const NEAREST = 0;
 
 }
 /**
  * CairoFontFace abstract class represents a particular font at a
  * particular weight, slant, and other characteristic but no
  * transformation or size. Note: This class can not be instantiated
  * directly, it is created by CairoContext::getFontFace or {@link
  * cairo_scaled_font_get_font_face}.
  **/
 class CairoFontFace {
     /**
      * Retrieves the font face type
      *
      * This function returns the type of the backend used to create a font
      * face. See CairoFontType class constants for available types.
      *
      * @return int A font type that can be any one defined in CairoFontType
      * @since PECL cairo >= 0.1.0
      **/
     public function getType(){}
 
     /**
      * Check for CairoFontFace errors
      *
      * Checks whether an error has previously occurred for this font face
      *
      * @return int CAIRO_STATUS_SUCCESS or another error such as
      *   CAIRO_STATUS_NO_MEMORY.
      * @since PECL cairo >= 0.1.0
      **/
     public function status(){}
 
     /**
      * Creates a new CairoFontFace object
      *
      * CairoFontFace class represents a particular font at a particular
      * weight, slant, and other characteristic but no transformation or size.
      *
      * Note: This class can't be instantiated directly it is created by
      * CairoContext::getFontFace or {@link cairo_scaled_font_get_font_face}
      *
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct(){}
 
 }
 /**
  * An opaque structure holding all options that are used when rendering
  * fonts. Individual features of a cairo_font_options_t can be set or
  * accessed using functions named cairo_font_options_set_feature_name and
  * cairo_font_options_get_feature_name, like
  * cairo_font_options_set_antialias() and
  * cairo_font_options_get_antialias(). New features may be added to
  * CairoFontOptions in the future. For this reason
  * CairoFontOptions::copy, CairoFontOptions::equal,
  * CairoFontOptions::merge, CairoFontOptions::hash
  * (cairo_font_options_copy(), cairo_font_options_equal(),
  * cairo_font_options_merge(), and cairo_font_options_hash() in
  * procedural way) should be used to copy, check for equality, merge, or
  * compute a hash value of CairoFontOptions objects.
  **/
 class CairoFontOptions {
     /**
      * The equal purpose
      *
      * The method description goes here.
      *
      * @param CairoFontOptions $other Description...
      * @return bool Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function equal($other){}
 
     /**
      * The getAntialias purpose
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getAntialias(){}
 
     /**
      * The getHintMetrics purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getHintMetrics(){}
 
     /**
      * The getHintStyle purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getHintStyle(){}
 
     /**
      * The getSubpixelOrder purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getSubpixelOrder(){}
 
     /**
      * The hash purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function hash(){}
 
     /**
      * The merge purpose
      *
      * The method description goes here.
      *
      * @param CairoFontOptions $other Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function merge($other){}
 
     /**
      * The setAntialias purpose
      *
      * @param int $antialias Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setAntialias($antialias){}
 
     /**
      * The setHintMetrics purpose
      *
      * The method description goes here.
      *
      * @param int $hint_metrics Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setHintMetrics($hint_metrics){}
 
     /**
      * The setHintStyle purpose
      *
      * The method description goes here.
      *
      * @param int $hint_style Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setHintStyle($hint_style){}
 
     /**
      * The setSubpixelOrder purpose
      *
      * The method description goes here.
      *
      * @param int $subpixel_order Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setSubpixelOrder($subpixel_order){}
 
     /**
      * The status purpose
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function status(){}
 
     /**
      * The __construct purpose
      *
      * The method description goes here.
      *
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct(){}
 
 }
 /**
  * Specifies variants of a font face based on their slant.
  **/
 class CairoFontSlant {
     /**
      * Italic font style
      *
      * @var integer
      **/
     const ITALIC = 0;
 
     /**
      * Upright font style
      *
      * @var integer
      **/
     const NORMAL = 0;
 
     /**
      * Oblique font style
      *
      * @var integer
      **/
     const OBLIQUE = 0;
 
 }
 /**
  * CairoFontType class is an abstract final class that contains constants
  * used to describe the type of a given CairoFontFace or CairoScaledFont.
  * The font types are also known as "font backends" within cairo. The
  * type of a CairoFontFace is determined by the how it is created, an
  * example would be the CairoToyFontFace::__construct. The CairoFontFace
  * type can be queried with CairoFontFace::getType or {@link
  * cairo_font_face_get_type} The various CairoFontFace functions can be
  * used with a font face of any type. The type of a CairoScaledFont is
  * determined by the type of the CairoFontFace passed to
  * CairoScaledFont::__construct or {@link cairo_scaled_font_create}. The
  * scaled font type can be queried with CairoScaledFont::getType or
  * {@link cairo_scaled_font_get_type}.
  **/
 class CairoFontType {
     /**
      * The font is of type CairoFreeType
      *
      * @var integer
      **/
     const FT = 0;
 
     /**
      * The font is of type Quartz
      *
      * @var integer
      **/
     const QUARTZ = 0;
 
     /**
      * The font was created using CairoToyFont api
      *
      * @var integer
      **/
     const TOY = 0;
 
     /**
      * The font was create using cairo's user font api
      *
      * @var mixed
      **/
     const USER = 0;
 
     /**
      * The font is of type Win32
      *
      * @var integer
      **/
     const WIN32 = 0;
 
 }
 /**
  * Specifies variants of a font face based on their weight.
  **/
 class CairoFontWeight {
     /**
      * Bold font weight
      *
      * @var integer
      **/
     const BOLD = 0;
 
     /**
      * Normal font weight
      *
      * @var integer
      **/
     const NORMAL = 0;
 
 }
 /**
  * CairoFormat enums are used to identify the memory format of the image
  * data.
  **/
 class CairoFormat {
     /**
      * Each pixel is a 1-bit quantity holding an alpha value. Pixels are
      * packed together into 32-bit quantities. The ordering of the bits
      * matches the endianness of the platform. On a big-endian machine, the
      * first pixel is in the uppermost bit, on a little-endian machine the
      * first pixel is in the least-significant bit.
      *
      * @var integer
      **/
     const A1 = 0;
 
     /**
      * Each pixel is a 8-bit quantity holding an alpha value.
      *
      * @var integer
      **/
     const A8 = 0;
 
     /**
      * Each pixel is a 32-bit quantity, with alpha in the upper 8 bits, then
      * red, then green, then blue. The 32-bit quantities are stored
      * native-endian. Pre-multiplied alpha is used. (That is, 50% transparent
      * red is 0x80800000, not 0x80ff0000.)
      *
      * @var integer
      **/
     const ARGB32 = 0;
 
     /**
      * Each pixel is a 32-bit quantity, with the upper 8 bits unused. Red,
      * Green, and Blue are stored in the remaining 24 bits in that order.
      *
      * @var integer
      **/
     const RGB24 = 0;
 
     /**
      * Provides an appropriate stride to use
      *
      * This method provides a stride value that will respect all alignment
      * requirements of the accelerated image-rendering code within cairo.
      *
      * @param int $format The desired CairoFormat to use
      * @param int $width The width of the image
      * @return int The appropriate stride to use given the desired format
      *   and width, or -1 if either the format is invalid or the width too
      *   large.
      * @since PECL cairo >= 0.1.0
      **/
     public static function strideForWidth($format, $width){}
 
 }
 /**
  * CairoGradientPattern is an abstract base class from which other
  * Pattern classes derive. It cannot be instantiated directly.
  **/
 class CairoGradientPattern extends CairoPattern {
     /**
      * The addColorStopRgb purpose
      *
      * The method description goes here.
      *
      * @param float $offset Description...
      * @param float $red Description...
      * @param float $green Description...
      * @param float $blue Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function addColorStopRgb($offset, $red, $green, $blue){}
 
     /**
      * The addColorStopRgba purpose
      *
      * The method description goes here.
      *
      * @param float $offset Description...
      * @param float $red Description...
      * @param float $green Description...
      * @param float $blue Description...
      * @param float $alpha Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function addColorStopRgba($offset, $red, $green, $blue, $alpha){}
 
     /**
      * The getColorStopCount purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getColorStopCount(){}
 
     /**
      * The getColorStopRgba purpose
      *
      * The method description goes here.
      *
      * @param int $index Description...
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getColorStopRgba($index){}
 
     /**
      * The getExtend purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getExtend(){}
 
     /**
      * The setExtend purpose
      *
      * The method description goes here.
      *
      * @param int $extend Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setExtend($extend){}
 
 }
 /**
  * Specifies whether to hint font metrics; hinting font metrics means
  * quantizing them so that they are integer values in device space. Doing
  * this improves the consistency of letter and line spacing, however it
  * also means that text will be laid out differently at different zoom
  * factors.
  **/
 class CairoHintMetrics {
     /**
      * @var integer
      **/
     const METRICS_DEFAULT = 0;
 
     /**
      * @var integer
      **/
     const METRICS_OFF = 0;
 
     /**
      * @var integer
      **/
     const METRICS_ON = 0;
 
 }
 /**
  * Specifies the type of hinting to do on font outlines. Hinting is the
  * process of fitting outlines to the pixel grid in order to improve the
  * appearance of the result. Since hinting outlines involves distorting
  * them, it also reduces the faithfulness to the original outline shapes.
  * Not all of the outline hinting styles are supported by all font
  * backends.
  **/
 class CairoHintStyle {
     /**
      * @var integer
      **/
     const STYLE_DEFAULT = 0;
 
     /**
      * @var integer
      **/
     const STYLE_FULL = 0;
 
     /**
      * @var integer
      **/
     const STYLE_MEDIUM = 0;
 
     /**
      * @var integer
      **/
     const STYLE_NONE = 0;
 
     /**
      * @var integer
      **/
     const STYLE_SLIGHT = 0;
 
 }
 /**
  * CairoImageSurface provide the ability to render to memory buffers
  * either allocated by cairo or by the calling code. The supported image
  * formats are those defined in CairoFormat.
  **/
 class CairoImageSurface extends CairoSurface {
     /**
      * The createForData purpose
      *
      * The method description goes here.
      *
      * @param string $data Description...
      * @param int $format Description...
      * @param int $width Description...
      * @param int $height Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public static function createForData($data, $format, $width, $height){}
 
     /**
      * Creates a new CairoImageSurface form a png image file
      *
      * This method should be called static
      *
      * @param string $file Path to PNG image file
      * @return CairoImageSurface CairoImageSurface object
      * @since PECL cairo >= 0.1.0
      **/
     public static function createFromPng($file){}
 
     /**
      * Gets the image data as string
      *
      * Returns the image data of this surface or NULL if surface is not an
      * image surface, or if CairoContext::finish, procedural : {@link
      * cairo_surface_finish}, has been called.
      *
      * @return string The image data as string
      * @since PECL cairo >= 0.1.0
      **/
     public function getData(){}
 
     /**
      * Get the image format
      *
      * Retrieves the image format, as one of the CairoFormat defined
      *
      * @return int One of the CairoFormat enums
      * @since PECL cairo >= 0.1.0
      **/
     public function getFormat(){}
 
     /**
      * Retrieves the height of the CairoImageSurface
      *
      * This methods returns the CairoImageSurface height.
      *
      * @return int CairoImageSurface object height
      * @since PECL cairo >= 0.1.0
      **/
     public function getHeight(){}
 
     /**
      * The getStride purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getStride(){}
 
     /**
      * Retrieves the width of the CairoImageSurface
      *
      * Gets the width of the CairoImageSurface
      *
      * @return int Returns the width of the CairoImageSurface object
      * @since PECL cairo >= 0.1.0
      **/
     public function getWidth(){}
 
     /**
      * Creates a new CairoImageSurface
      *
      * Creates a new CairoImageSuface object of type {@link format}
      *
      * @param int $format Can be any defined in CairoFormat
      * @param int $width The width of the image surface
      * @param int $height The height of the image surface
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct($format, $width, $height){}
 
 }
 /**
  * Create a new CairoLinearGradient along the line defined
  **/
 class CairoLinearGradient extends CairoGradientPattern {
     /**
      * The getPoints purpose
      *
      * The method description goes here.
      *
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getPoints(){}
 
     /**
      * The __construct purpose
      *
      * The method description goes here.
      *
      * @param float $x0 Description...
      * @param float $y0 Description...
      * @param float $x1 Description...
      * @param float $y1 Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct($x0, $y0, $x1, $y1){}
 
 }
 /**
  * Specifies how to render the endpoints of the path when stroking. The
  * default line cap style is CairoLineCap::BUTT.
  **/
 class CairoLineCap {
     /**
      * Start(stop) the line exactly at the start(end) point
      *
      * @var integer
      **/
     const BUTT = 0;
 
     /**
      * Use a round ending, the center of the circle is the end point
      *
      * @var integer
      **/
     const ROUND = 0;
 
     /**
      * Use squared ending, the center of the square is the end point
      *
      * @var integer
      **/
     const SQUARE = 0;
 
 }
 class CairoLineJoin {
     /**
      * @var integer
      **/
     const BEVEL = 0;
 
     /**
      * @var integer
      **/
     const MITER = 0;
 
     /**
      * @var integer
      **/
     const ROUND = 0;
 
 }
 /**
  * Matrices are used throughout cairo to convert between different
  * coordinate spaces.
  **/
 class CairoMatrix {
     /**
      * Creates a new identity matrix
      *
      * Creates a new matrix that is an identity transformation. An identity
      * transformation means the source data is copied into the destination
      * data without change
      *
      * @return void Returns a new CairoMatrix object that can be used with
      *   surfaces, contexts, and patterns.
      * @since PECL cairo >= 0.1.0
      **/
     public static function initIdentity(){}
 
     /**
      * Creates a new rotated matrix
      *
      * Creates a new matrix to a transformation that rotates by radians
      * provided
      *
      * @param float $radians angle of rotation, in radians. The direction
      *   of rotation is defined such that positive angles rotate in the
      *   direction from the positive X axis toward the positive Y axis. With
      *   the default axis orientation of cairo, positive angles rotate in a
      *   clockwise direction.
      * @return void Returns a new CairoMatrix object that can be used with
      *   surfaces, contexts, and patterns.
      * @since PECL cairo >= 0.1.0
      **/
     public static function initRotate($radians){}
 
     /**
      * Creates a new scaling matrix
      *
      * Creates a new matrix to a transformation that scales by sx and sy in
      * the X and Y dimensions, respectively.
      *
      * @param float $sx scale factor in the X direction
      * @param float $sy scale factor in the Y direction
      * @return void Returns a new CairoMatrix object that can be used with
      *   surfaces, contexts, and patterns.
      * @since PECL cairo >= 0.1.0
      **/
     public static function initScale($sx, $sy){}
 
     /**
      * Creates a new translation matrix
      *
      * Creates a new matrix to a transformation that translates by tx and ty
      * in the X and Y dimensions, respectively.
      *
      * @param float $tx amount to translate in the X direction
      * @param float $ty amount to translate in the Y direction
      * @return void Returns a new CairoMatrix object that can be used with
      *   surfaces, contexts, and patterns.
      * @since PECL cairo >= 0.1.0
      **/
     public static function initTranslate($tx, $ty){}
 
     /**
      * The invert purpose
      *
      * The method description goes here.
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function invert(){}
 
     /**
      * The multiply purpose
      *
      * The method description goes here.
      *
      * @param CairoMatrix $matrix1 Description...
      * @param CairoMatrix $matrix2 Description...
      * @return CairoMatrix Description...
      * @since PECL cairo >= 0.1.0
      **/
     public static function multiply($matrix1, $matrix2){}
 
     /**
      * The rotate purpose
      *
      * @param float $radians Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function rotate($radians){}
 
     /**
      * Applies scaling to a matrix
      *
      * Applies scaling by sx, sy to the transformation in the matrix. The
      * effect of the new transformation is to first scale the coordinates by
      * sx and sy, then apply the original transformation to the coordinates.
      *
      * @param float $sx Procedural only - CairoMatrix instance
      * @param float $sy scale factor in the X direction
      * @return void
      * @since PECL cairo >= 0.1.0
      **/
     public function scale($sx, $sy){}
 
     /**
      * The transformDistance purpose
      *
      * The method description goes here.
      *
      * @param float $dx Description...
      * @param float $dy Description...
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function transformDistance($dx, $dy){}
 
     /**
      * The transformPoint purpose
      *
      * The method description goes here.
      *
      * @param float $dx Description...
      * @param float $dy Description...
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function transformPoint($dx, $dy){}
 
     /**
      * The translate purpose
      *
      * @param float $tx Description...
      * @param float $ty Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function translate($tx, $ty){}
 
     /**
      * Creates a new CairoMatrix object
      *
      * Returns new CairoMatrix object. Matrices are used throughout cairo to
      * convert between different coordinate spaces. Sets matrix to be the
      * affine transformation given by xx, yx, xy, yy, x0, y0. The
      * transformation is given by: x_new = xx * x + xy * y + x0; and y_new =
      * yx * x + yy * y + y0;
      *
      * @param float $xx xx component of the affine transformation
      * @param float $yx yx component of the affine transformation
      * @param float $xy xy component of the affine transformation
      * @param float $yy yy component of the affine transformation
      * @param float $x0 X translation component of the affine
      *   transformation
      * @param float $y0 Y translation component of the affine
      *   transformation
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct($xx, $yx, $xy, $yy, $x0, $y0){}
 
 }
 /**
  * This is used to set the compositing operator for all cairo drawing
  * operations. The default operator is CairoOperator::OVER The operators
  * marked as unbounded modify their destination even outside of the mask
  * layer (that is, their effect is not bound by the mask layer). However,
  * their effect can still be limited by way of clipping. To keep things
  * simple, the operator descriptions here document the behavior for when
  * both source and destination are either fully transparent or fully
  * opaque. The actual implementation works for translucent layers too.
  * For a more detailed explanation of the effects of each operator,
  * including the mathematical definitions, see
  * http://cairographics.org/operators/.
  **/
 class CairoOperator {
     /**
      * Source and destination layers are accumulated
      *
      * @var integer
      **/
     const ADD = 0;
 
     /**
      * Draw source on top of destination content and only there
      *
      * @var integer
      **/
     const ATOP = 0;
 
     /**
      * Clear destination layer (bounded)
      *
      * @var integer
      **/
     const CLEAR = 0;
 
     /**
      * Ignore the source
      *
      * @var integer
      **/
     const DEST = 0;
 
     /**
      * @var integer
      **/
     const DEST_ATOP = 0;
 
     /**
      * @var integer
      **/
     const DEST_IN = 0;
 
     /**
      * @var integer
      **/
     const DEST_OUT = 0;
 
     /**
      * @var integer
      **/
     const DEST_OVER = 0;
 
     /**
      * Draw source where there was destination content (unbounded)
      *
      * @var integer
      **/
     const IN = 0;
 
     /**
      * Draw source where there was no destination content (unbounded)
      *
      * @var integer
      **/
     const OUT = 0;
 
     /**
      * Draw source layer on top of destination layer (bounded)
      *
      * @var integer
      **/
     const OVER = 0;
 
     /**
      * Like CairoOperator::OVER, but assuming source and dest are disjoint
      * geometries
      *
      * @var integer
      **/
     const SATURATE = 0;
 
     /**
      * Replace destination layer (bounded)
      *
      * @var integer
      **/
     const SOURCE = 0;
 
     /**
      * Source and destination are shown where there is only one of them
      *
      * @var integer
      **/
     const XOR = 0;
 
 }
 /**
  * Note: CairoPath class cannot be instantiated directly, doing so will
  * result in Fatal Error if used or passed
  **/
 class CairoPath {
 }
 /**
  * CairoPattern is the abstract base class from which all the other
  * pattern classes derive. It cannot be instantiated directly
  **/
 class CairoPattern {
     /**
      * The getMatrix purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getMatrix(){}
 
     /**
      * The getType purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getType(){}
 
     /**
      * The setMatrix purpose
      *
      * @param CairoMatrix $matrix Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setMatrix($matrix){}
 
     /**
      * The status purpose
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function status(){}
 
     /**
      * The __construct purpose
      *
      * The method description goes here.
      *
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct(){}
 
 }
 /**
  * CairoPatternType is used to describe the type of a given pattern. The
  * type of a pattern is determined by the function used to create it. The
  * {@link cairo_pattern_create_rgb} and {@link cairo_pattern_create_rgba}
  * functions create CairoPatternType::SOLID patterns. The remaining
  * cairo_pattern_create_* functions map to pattern types in obvious ways.
  **/
 class CairoPatternType {
     /**
      * The pattern is a linear gradient.
      *
      * @var integer
      **/
     const LINEAR = 0;
 
     /**
      * The pattern is a radial gradient.
      *
      * @var integer
      **/
     const RADIAL = 0;
 
     /**
      * The pattern is a solid (uniform) color. It may be opaque or
      * translucent.
      *
      * @var integer
      **/
     const SOLID = 0;
 
     /**
      * The pattern is a based on a surface (an image).
      *
      * @var integer
      **/
     const SURFACE = 0;
 
 }
 class CairoPdfSurface extends CairoSurface {
     /**
      * The setSize purpose
      *
      * The method description goes here.
      *
      * @param float $width Description...
      * @param float $height Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setSize($width, $height){}
 
     /**
      * The __construct purpose
      *
      * The method description goes here.
      *
      * @param string $file Description...
      * @param float $width Description...
      * @param float $height Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct($file, $width, $height){}
 
 }
 class CairoPsLevel {
     /**
      * @var integer
      **/
     const LEVEL_2 = 0;
 
     /**
      * @var integer
      **/
     const LEVEL_3 = 0;
 
 }
 class CairoPsSurface extends CairoSurface {
     /**
      * The dscBeginPageSetup purpose
      *
      * The method description goes here.
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function dscBeginPageSetup(){}
 
     /**
      * The dscBeginSetup purpose
      *
      * The method description goes here.
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function dscBeginSetup(){}
 
     /**
      * The dscComment purpose
      *
      * The method description goes here.
      *
      * @param string $comment Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function dscComment($comment){}
 
     /**
      * The getEps purpose
      *
      * The method description goes here.
      *
      * @return bool Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getEps(){}
 
     /**
      * The getLevels purpose
      *
      * The method description goes here.
      *
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public static function getLevels(){}
 
     /**
      * The levelToString purpose
      *
      * The method description goes here.
      *
      * @param int $level Description...
      * @return string Description...
      * @since PECL cairo >= 0.1.0
      **/
     public static function levelToString($level){}
 
     /**
      * The restrictToLevel purpose
      *
      * The method description goes here.
      *
      * @param int $level Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function restrictToLevel($level){}
 
     /**
      * The setEps purpose
      *
      * The method description goes here.
      *
      * @param bool $level Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setEps($level){}
 
     /**
      * The setSize purpose
      *
      * The method description goes here.
      *
      * @param float $width Description...
      * @param float $height Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setSize($width, $height){}
 
     /**
      * The __construct purpose
      *
      * The method description goes here.
      *
      * @param string $file Description...
      * @param float $width Description...
      * @param float $height Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct($file, $width, $height){}
 
 }
 class CairoRadialGradient extends CairoGradientPattern {
     /**
      * The getCircles purpose
      *
      * The method description goes here.
      *
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getCircles(){}
 
     /**
      * The __construct purpose
      *
      * Creates a new radial gradient CairoPattern between the two circles
      * defined by (x0, y0, r0) and (x1, y1, r1). Before using the gradient
      * pattern, a number of color stops should be defined using
      * CairoRadialGradient::addColorStopRgb or
      * CairoRadialGradient::addColorStopRgba.
      *
      * Note: The coordinates here are in pattern space. For a new pattern,
      * pattern space is identical to user space, but the relationship between
      * the spaces can be changed with CairoRadialGradient::setMatrix.
      *
      * @param float $x0 x coordinate for the center of the start circle.
      * @param float $y0 y coordinate for the center of the start circle.
      * @param float $r0 radius of the start circle.
      * @param float $x1 x coordinate for the center of the end circle.
      * @param float $y1 y coordinate for the center of the end circle.
      * @param float $r1 radius of the end circle.
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct($x0, $y0, $r0, $x1, $y1, $r1){}
 
 }
 class CairoScaledFont {
     /**
      * The extents purpose
      *
      * The method description goes here.
      *
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function extents(){}
 
     /**
      * The getCtm purpose
      *
      * The method description goes here.
      *
      * @return CairoMatrix Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getCtm(){}
 
     /**
      * The getFontFace purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getFontFace(){}
 
     /**
      * The getFontMatrix purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getFontMatrix(){}
 
     /**
      * The getFontOptions purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getFontOptions(){}
 
     /**
      * The getScaleMatrix purpose
      *
      * The method description goes here.
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getScaleMatrix(){}
 
     /**
      * The getType purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getType(){}
 
     /**
      * The glyphExtents purpose
      *
      * The method description goes here.
      *
      * @param array $glyphs Description...
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function glyphExtents($glyphs){}
 
     /**
      * The status purpose
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function status(){}
 
     /**
      * The textExtents purpose
      *
      * @param string $text Description...
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function textExtents($text){}
 
     /**
      * The __construct purpose
      *
      * The method description goes here.
      *
      * @param CairoFontFace $font_face Description...
      * @param CairoMatrix $matrix Description...
      * @param CairoMatrix $ctm Description...
      * @param CairoFontOptions $options Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct($font_face, $matrix, $ctm, $options){}
 
 }
 class CairoSolidPattern extends CairoPattern {
     /**
      * The getRgba purpose
      *
      * The method description goes here.
      *
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getRgba(){}
 
     /**
      * The __construct purpose
      *
      * The method description goes here.
      *
      * @param float $red Description...
      * @param float $green Description...
      * @param float $blue Description...
      * @param float $alpha Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct($red, $green, $blue, $alpha){}
 
 }
 /**
  * CairoStatus is used to indicate errors that can occur when using
  * Cairo. In some cases it is returned directly by functions. but when
  * using CairoContext, the last error, if any, is stored in the object
  * and can be retrieved with CairoContext::status or {@link
  * cairo_status}. New entries may be added in future versions. Use
  * Cairo::statusToString or {@link cairo_status_to_string} to get a
  * human-readable representation of an error message.
  **/
 class CairoStatus {
     /**
      * @var integer
      **/
     const CLIP_NOT_REPRESENTABLE = 0;
 
     /**
      * @var integer
      **/
     const FILE_NOT_FOUND = 0;
 
     /**
      * @var integer
      **/
     const INVALID_CONTENT = 0;
 
     /**
      * @var integer
      **/
     const INVALID_DASH = 0;
 
     /**
      * @var integer
      **/
     const INVALID_DSC_COMMENT = 0;
 
     /**
      * @var integer
      **/
     const INVALID_FORMAT = 0;
 
     /**
      * @var integer
      **/
     const INVALID_INDEX = 0;
 
     /**
      * @var integer
      **/
     const INVALID_MATRIX = 0;
 
     /**
      * @var integer
      **/
     const INVALID_PATH_DATA = 0;
 
     /**
      * @var integer
      **/
     const INVALID_POP_GROUP = 0;
 
     /**
      * @var integer
      **/
     const INVALID_RESTORE = 0;
 
     /**
      * @var integer
      **/
     const INVALID_STATUS = 0;
 
     /**
      * @var integer
      **/
     const INVALID_STRIDE = 0;
 
     /**
      * @var integer
      **/
     const INVALID_STRING = 0;
 
     /**
      * @var integer
      **/
     const INVALID_VISUAL = 0;
 
     /**
      * @var integer
      **/
     const NO_CURRENT_POINT = 0;
 
     /**
      * @var integer
      **/
     const NO_MEMORY = 0;
 
     /**
      * @var integer
      **/
     const NULL_POINTER = 0;
 
     /**
      * @var integer
      **/
     const PATTERN_TYPE_MISMATCH = 0;
 
     /**
      * @var integer
      **/
     const READ_ERROR = 0;
 
     /**
      * No error has occurred
      *
      * @var integer
      **/
     const SUCCESS = 0;
 
     /**
      * @var integer
      **/
     const SURFACE_FINISHED = 0;
 
     /**
      * @var integer
      **/
     const SURFACE_TYPE_MISMATCH = 0;
 
     /**
      * @var integer
      **/
     const TEMP_FILE_ERROR = 0;
 
     /**
      * @var integer
      **/
     const WRITE_ERROR = 0;
 
 }
 class CairoSubpixelOrder {
     /**
      * @var integer
      **/
     const ORDER_BGR = 0;
 
     /**
      * @var integer
      **/
     const ORDER_DEFAULT = 0;
 
     /**
      * @var integer
      **/
     const ORDER_RGB = 0;
 
     /**
      * @var integer
      **/
     const ORDER_VBGR = 0;
 
     /**
      * @var integer
      **/
     const ORDER_VRGB = 0;
 
 }
 /**
  * This is the base-class for all other Surface types. CairoSurface is
  * the abstract type representing all different drawing targets that
  * cairo can render to. The actual drawings are performed using a
  * CairoContext.
  **/
 class CairoSurface {
     /**
      * The copyPage purpose
      *
      * Emits the current page for backends that support multiple pages, but
      * doesn't clear it, so that the contents of the current page will be
      * retained for the next page. Use CairoSurface::showPage() if you want
      * to get an empty page after the emission.
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function copyPage(){}
 
     /**
      * The createSimilar purpose
      *
      * Create a new surface that is as compatible as possible with an
      * existing surface. For example the new surface will have the same
      * fallback resolution and font options as other. Generally, the new
      * surface will also use the same backend as other, unless that is not
      * possible for some reason. The type of the returned surface may be
      * examined with CairoSurface::getType(). Initially the surface contents
      * are all 0 (transparent if contents have transparency, black
      * otherwise.)
      *
      * @param CairoSurface $other An existing surface used to select the
      *   backend of the new surface
      * @param int $content The content for the new surface. See the
      *   CairoContent class for possible values.
      * @param string $width Width of the new surface, (in device-space
      *   units).
      * @param string $height Height of the new surface, (in device-space
      *   units).
      * @return void A new CairoSurface
      * @since PECL cairo >= 0.1.0
      **/
     public function createSimilar($other, $content, $width, $height){}
 
     /**
      * The finish purpose
      *
      * The method description goes here.
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function finish(){}
 
     /**
      * The flush purpose
      *
      * The method description goes here.
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function flush(){}
 
     /**
      * The getContent purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getContent(){}
 
     /**
      * The getDeviceOffset purpose
      *
      * The method description goes here.
      *
      * @return array Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getDeviceOffset(){}
 
     /**
      * The getFontOptions purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getFontOptions(){}
 
     /**
      * The getType purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getType(){}
 
     /**
      * The markDirty purpose
      *
      * The method description goes here.
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function markDirty(){}
 
     /**
      * The markDirtyRectangle purpose
      *
      * The method description goes here.
      *
      * @param float $x Description...
      * @param float $y Description...
      * @param float $width Description...
      * @param float $height Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function markDirtyRectangle($x, $y, $width, $height){}
 
     /**
      * The setDeviceOffset purpose
      *
      * The method description goes here.
      *
      * @param float $x Description...
      * @param float $y Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setDeviceOffset($x, $y){}
 
     /**
      * The setFallbackResolution purpose
      *
      * The method description goes here.
      *
      * @param float $x Description...
      * @param float $y Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setFallbackResolution($x, $y){}
 
     /**
      * The showPage purpose
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function showPage(){}
 
     /**
      * The status purpose
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function status(){}
 
     /**
      * The writeToPng purpose
      *
      * The method description goes here.
      *
      * @param string $file Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function writeToPng($file){}
 
     /**
      * The __construct purpose
      *
      * CairoSurface is an abstract type and, as such, should not be
      * instantiated in your PHP scripts.
      *
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct(){}
 
 }
 class CairoSurfacePattern extends CairoPattern {
     /**
      * The getExtend purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getExtend(){}
 
     /**
      * The getFilter purpose
      *
      * The method description goes here.
      *
      * @return int Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getFilter(){}
 
     /**
      * The getSurface purpose
      *
      * The method description goes here.
      *
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function getSurface(){}
 
     /**
      * The setExtend purpose
      *
      * The method description goes here.
      *
      * @param int $extend Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setExtend($extend){}
 
     /**
      * The setFilter purpose
      *
      * The method description goes here.
      *
      * @param int $filter Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function setFilter($filter){}
 
     /**
      * The __construct purpose
      *
      * The method description goes here.
      *
      * @param CairoSurface $surface Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct($surface){}
 
 }
 class CairoSurfaceType {
     /**
      * @var integer
      **/
     const BEOS = 0;
 
     /**
      * @var integer
      **/
     const DIRECTFB = 0;
 
     /**
      * @var integer
      **/
     const GLITZ = 0;
 
     /**
      * @var integer
      **/
     const IMAGE = 0;
 
     /**
      * @var integer
      **/
     const OS2 = 0;
 
     /**
      * @var integer
      **/
     const PDF = 0;
 
     /**
      * @var integer
      **/
     const PS = 0;
 
     /**
      * @var integer
      **/
     const QUARTZ = 0;
 
     /**
      * @var integer
      **/
     const QUARTZ_IMAGE = 0;
 
     /**
      * @var integer
      **/
     const SVG = 0;
 
     /**
      * @var integer
      **/
     const WIN32 = 0;
 
     /**
      * @var integer
      **/
     const WIN32_PRINTING = 0;
 
     /**
      * @var integer
      **/
     const XCB = 0;
 
     /**
      * @var integer
      **/
     const XLIB = 0;
 
 }
 /**
  * Svg specific surface class, uses the SVG (standard vector graphics)
  * surface backend.
  **/
 class CairoSvgSurface extends CairoSurface {
     /**
      * Used to retrieve a list of supported SVG versions
      *
      * Returns a numerically indexed array of currently available
      * CairoSvgVersion constants. In order to retrieve the string values for
      * each item, use CairoSvgSurface::versionToString.
      *
      * @return array Returns a numerically indexed array of integer values.
      * @since PECL cairo >= 0.1.0
      **/
     public static function getVersions(){}
 
     /**
      * The restrictToVersion purpose
      *
      * The method description goes here.
      *
      * @param int $version Description...
      * @return void Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function restrictToVersion($version){}
 
     /**
      * The versionToString purpose
      *
      * The method description goes here.
      *
      * @param int $version Description...
      * @return string Description...
      * @since PECL cairo >= 0.1.0
      **/
     public static function versionToString($version){}
 
     /**
      * The __construct purpose
      *
      * The method description goes here.
      *
      * @param string $file Description...
      * @param float $width Description...
      * @param float $height Description...
      * @since PECL cairo >= 0.1.0
      **/
     public function __construct($file, $width, $height){}
 
 }
 class CairoSvgVersion {
     /**
      * @var integer
      **/
     const VERSION_1_1 = 0;
 
     /**
      * @var integer
      **/
     const VERSION_1_2 = 0;
 
 }
 /**
  * The CairoToyFontFace class can be used instead of
  * CairoContext::selectFontFace to create a toy font independently of a
  * context.
  **/
 class CairoToyFontFace extends CairoFontFace {
 }
 /**
  * The callback should accept up to three arguments: the current item,
  * the current key and the iterator, respectively. Any callable may be
  * used; such as a string containing a function name, an array for a
  * method, or an anonymous function.
  **/
 class CallbackFilterIterator extends FilterIterator implements OuterIterator {
     /**
      * Calls the callback with the current value, the current key and the
      * inner iterator as arguments
      *
      * This method calls the callback with the current value, current key and
      * the inner iterator.
      *
      * The callback is expected to return TRUE if the current item is to be
      * accepted, or FALSE otherwise.
      *
      * @return bool Returns TRUE to accept the current item, or FALSE
      *   otherwise.
      * @since PHP 5 >= 5.4.0, PHP 7
      **/
     public function accept(){}
 
 }
 /**
  * Represents a loaded chdb file.
  **/
 class chdb {
     /**
      * Gets the value associated with a key
      *
      * Gets the value associated with a key from a chdb database.
      *
      * @param string $key The key for which to get the value.
      * @return string Returns a string containing the value associated with
      *   the given {@link key}, or NULL if not found.
      * @since PECL chdb >= 0.1.0
      **/
     public function get($key){}
 
     /**
      * Creates a instance
      *
      * Loads a chdb file, by mapping it into memory. While some validity
      * checks are performed on the specified file, they are mostly there to
      * avoid the possibility of common mistakes (for example, loading a file
      * which is not a chdb database, or that is somehow incompatible with the
      * current system). A maliciously crafted chdb file can thus be dangerous
      * if loaded, so chdb files should be trusted and treated with the same
      * security protections used for PHP shared libraries.
      *
      * @param string $pathname The name of the file to load.
      * @since PECL chdb >= 0.1.0
      **/
     public function __construct($pathname){}
 
 }
 /**
  * Class used to represent anonymous functions. Anonymous functions,
  * implemented in PHP 5.3, yield objects of this type. This fact used to
  * be considered an implementation detail, but it can now be relied upon.
  * Starting with PHP 5.4, this class has methods that allow further
  * control of the anonymous function after it has been created. Besides
  * the methods listed here, this class also has an __invoke method. This
  * is for consistency with other classes that implement calling magic, as
  * this method is not used for calling the function.
  **/
 class Closure {
     /**
      * Duplicates a closure with a specific bound object and class scope
      *
      * This method is a static version of Closure::bindTo. See the
      * documentation of that method for more information.
      *
      * @param Closure $closure The anonymous functions to bind.
      * @param object $newthis The object to which the given anonymous
      *   function should be bound, or NULL for the closure to be unbound.
      * @param mixed $newscope The class scope to which associate the
      *   closure is to be associated, or 'static' to keep the current one. If
      *   an object is given, the type of the object will be used instead.
      *   This determines the visibility of protected and private methods of
      *   the bound object. It is not allowed to pass (an object of) an
      *   internal class as this parameter.
      * @return Closure Returns a new Closure object
      * @since PHP 5 >= 5.4.0, PHP 7
      **/
     public static function bind($closure, $newthis, $newscope){}
 
     /**
      * Duplicates the closure with a new bound object and class scope
      *
      * Create and return a new anonymous function with the same body and
      * bound variables as this one, but possibly with a different bound
      * object and a new class scope.
      *
      * The “bound object” determines the value $this will have in the
      * function body and the “class scope” represents a class which
      * determines which private and protected members the anonymous function
      * will be able to access. Namely, the members that will be visible are
      * the same as if the anonymous function were a method of the class given
      * as value of the {@link newscope} parameter.
      *
      * Static closures cannot have any bound object (the value of the
      * parameter {@link newthis} should be NULL), but this function can
      * nevertheless be used to change their class scope.
      *
      * This function will ensure that for a non-static closure, having a
      * bound instance will imply being scoped and vice-versa. To this end,
      * non-static closures that are given a scope but a NULL instance are
      * made static and non-static non-scoped closures that are given a
      * non-null instance are scoped to an unspecified class.
      *
      * @param object $newthis The object to which the given anonymous
      *   function should be bound, or NULL for the closure to be unbound.
      * @param mixed $newscope The class scope to which the closure is to be
      *   associated, or 'static' to keep the current one. If an object is
      *   given, the type of the object will be used instead. This determines
      *   the visibility of protected and private methods of the bound object.
      *   It is not allowed to pass (an object of) an internal class as this
      *   parameter.
      * @return Closure Returns the newly created Closure object
      * @since PHP 5 >= 5.4.0, PHP 7
      **/
     public function bindTo($newthis, $newscope){}
 
     /**
      * Binds and calls the closure
      *
      * Temporarily binds the closure to {@link newthis}, and calls it with
      * any given parameters.
      *
      * @param object $newthis The object to bind the closure to for the
      *   duration of the call.
      * @param mixed ...$vararg Zero or more parameters, which will be given
      *   as parameters to the closure.
      * @return mixed Returns the return value of the closure.
      * @since PHP 7
      **/
     public function call($newthis, ...$vararg){}
 
     /**
      * Converts a callable into a closure
      *
      * Create and return a new anonymous function from given {@link callable}
      * using the current scope. This method checks if the {@link callable} is
      * callable in the current scope and throws a TypeError if it is not.
      *
      * @param callable $callable The callable to convert.
      * @return Closure Returns the newly created Closure or throws a
      *   TypeError if the {@link callable} is not callable in the current
      *   scope.
      * @since PHP 7 >= 7.1.0
      **/
     public static function fromCallable($callable){}
 
     /**
      * Constructor that disallows instantiation
      *
      * This method exists only to disallow instantiation of the Closure
      * class. Objects of this class are created in the fashion described on
      * the anonymous functions page.
      *
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     private function __construct(){}
 
 }
 /**
  * Provides string comparison capability with support for appropriate
  * locale-sensitive sort orderings.
  **/
 class Collator {
     /**
      * Sort array maintaining index association
      *
      * This function sorts an array such that array indices maintain their
      * correlation with the array elements they are associated with. This is
      * used mainly when sorting associative arrays where the actual element
      * order is significant. Array elements will have sort order according to
      * current locale rules.
      *
      * Equivalent to standard PHP {@link asort}.
      *
      * @param array $arr Collator object.
      * @param int $sort_flag Array of strings to sort.
      * @return bool
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public function asort(&$arr, $sort_flag){}
 
     /**
      * Compare two Unicode strings
      *
      * Compare two Unicode strings according to collation rules.
      *
      * @param string $str1 Collator object.
      * @param string $str2 The first string to compare.
      * @return int Return comparison result:
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public function compare($str1, $str2){}
 
     /**
      * Create a collator
      *
      * The strings will be compared using the options already specified.
      *
      * @param string $locale The locale containing the required collation
      *   rules. Special values for locales can be passed in - if null is
      *   passed for the locale, the default locale collation rules will be
      *   used. If empty string ("") or "root" are passed, UCA rules will be
      *   used.
      * @return Collator Return new instance of Collator object, or NULL on
      *   error.
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public static function create($locale){}
 
     /**
      * Get collation attribute value
      *
      * Get a value of an integer collator attribute.
      *
      * @param int $attr Collator object.
      * @return int Attribute value, or boolean FALSE on error.
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public function getAttribute($attr){}
 
     /**
      * Get collator's last error code
      *
      * @return int Error code returned by the last Collator API function
      *   call.
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public function getErrorCode(){}
 
     /**
      * Get text for collator's last error code
      *
      * Retrieves the message for the last error.
      *
      * @return string Description of an error occurred in the last Collator
      *   API function call.
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public function getErrorMessage(){}
 
     /**
      * Get the locale name of the collator
      *
      * Get collector locale name.
      *
      * @param int $type Collator object.
      * @return string Real locale name from which the collation data comes.
      *   If the collator was instantiated from rules or an error occurred,
      *   returns boolean FALSE.
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public function getLocale($type){}
 
     /**
      * Get sorting key for a string
      *
      * Return collation key for a string. Collation keys can be compared
      * directly instead of strings, though are implementation specific and
      * may change between ICU library versions. Sort keys are generally only
      * useful in databases or other circumstances where function calls are
      * extremely expensive.
      *
      * @param string $str Collator object.
      * @return string Returns the collation key for the string, .
      * @since PHP 5 >= 5.3.2, PHP 7, PECL intl >= 1.0.3
      **/
     public function getSortKey($str){}
 
     /**
      * Get current collation strength
      *
      * @return int Returns current collation strength, or boolean FALSE on
      *   error.
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public function getStrength(){}
 
     /**
      * Set collation attribute
      *
      * @param int $attr Collator object.
      * @param int $val Attribute.
      * @return bool
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public function setAttribute($attr, $val){}
 
     /**
      * Set collation strength
      *
      * The ICU Collation Service supports many levels of comparison (named
      * "Levels", but also known as "Strengths"). Having these categories
      * enables ICU to sort strings precisely according to local conventions.
      * However, by allowing the levels to be selectively employed, searching
      * for a string in text can be performed with various matching
      * conditions.
      *
      * Primary Level: Typically, this is used to denote differences between
      * base characters (for example, "a" < "b"). It is the strongest
      * difference. For example, dictionaries are divided into different
      * sections by base character. This is also called the level1 strength.
      * Secondary Level: Accents in the characters are considered secondary
      * differences (for example, "as" < "às" < "at"). Other differences
      * between letters can also be considered secondary differences,
      * depending on the language. A secondary difference is ignored when
      * there is a primary difference anywhere in the strings. This is also
      * called the level2 strength. Note: In some languages (such as Danish),
      * certain accented letters are considered to be separate base
      * characters. In most languages, however, an accented letter only has a
      * secondary difference from the unaccented version of that letter.
      * Tertiary Level: Upper and lower case differences in characters are
      * distinguished at the tertiary level (for example, "ao" < "Ao" <
      * "aò"). In addition, a variant of a letter differs from the base form
      * on the tertiary level (such as "A" and " "). Another example is the
      * difference between large and small Kana. A tertiary difference is
      * ignored when there is a primary or secondary difference anywhere in
      * the strings. This is also called the level3 strength. Quaternary
      * Level: When punctuation is ignored (see Ignoring Punctuations ) at
      * level 13, an additional level can be used to distinguish words with
      * and without punctuation (for example, "ab" < "a-b" < "aB"). This
      * difference is ignored when there is a primary, secondary or tertiary
      * difference. This is also known as the level4 strength. The quaternary
      * level should only be used if ignoring punctuation is required or when
      * processing Japanese text (see Hiragana processing). Identical Level:
      * When all other levels are equal, the identical level is used as a
      * tiebreaker. The Unicode code point values of the NFD form of each
      * string are compared at this level, just in case there is no difference
      * at levels 14. For example, Hebrew cantillation marks are only
      * distinguished at this level. This level should be used sparingly, as
      * only code point values differences between two strings is an extremely
      * rare occurrence. Using this level substantially decreases the
      * performance for both incremental comparison and sort key generation
      * (as well as increasing the sort key length). It is also known as level
      * 5 strength.
      *
      * For example, people may choose to ignore accents or ignore accents and
      * case when searching for text. Almost all characters are distinguished
      * by the first three levels, and in most locales the default value is
      * thus Tertiary. However, if Alternate is set to be Shifted, then the
      * Quaternary strength can be used to break ties among whitespace,
      * punctuation, and symbols that would otherwise be ignored. If very fine
      * distinctions among characters are required, then the Identical
      * strength can be used (for example, Identical Strength distinguishes
      * between the Mathematical Bold Small A and the Mathematical Italic
      * Small A.). However, using levels higher than Tertiary the Identical
      * strength result in significantly longer sort keys, and slower string
      * comparison performance for equal strings.
      *
      * @param int $strength Collator object.
      * @return bool
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public function setStrength($strength){}
 
     /**
      * Sort array using specified collator
      *
      * This function sorts an array according to current locale rules.
      *
      * Equivalent to standard PHP {@link sort} .
      *
      * @param array $arr Collator object.
      * @param int $sort_flag Array of strings to sort.
      * @return bool
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public function sort(&$arr, $sort_flag){}
 
     /**
      * Sort array using specified collator and sort keys
      *
      * Similar to {@link collator_sort} but uses ICU sorting keys produced by
      * ucol_getSortKey() to gain more speed on large arrays.
      *
      * @param array $arr Collator object.
      * @return bool
      * @since PHP 5 >= 5.3.0, PHP 7, PECL intl >= 1.0.0
      **/
     public function sortWithSortKeys(&$arr){}
 
 }
 /**
  * Represents a garbage-collectable object.
  **/
 interface Collectable {
     /**
      * Determine whether an object has been marked as garbage
      *
      * Can be called in Pool::collect to determine if this object is garbage.
      *
      * @return bool
      * @since PECL pthreads >= 2.0.8
      **/
     public function isGarbage();
 
     /**
      * Mark an object as garbage
      *
      * Should be called once per object when the object is finished being
      * executed or referenced.
      *
      * @return void
      * @since PECL pthreads < 3.0.0
      **/
     public function setGarbage();
 
 }
 /**
  * The com class allows you to instantiate an OLE compatible COM object
  * and call its methods and access its properties.
  **/
 class com extends variant {
 }
 namespace CommonMark {
 class CQL {
     /**
      * CQL Execution
      *
      * Shall invoke the current CQL function on the given {@link root},
      * executing the given {@link handler} on entry to a \CommonMark\Node
      *
      * @param \CommonMark\Node $root the root node of a tree
      * @param callable $handler should have the prototype: ?boolhandler
      *   \CommonMark\Node{@link root} \CommonMark\Node{@link entering} Should
      *   {@link handler} fail to return (void), or return null, CQL will
      *   continue executing Should the handler return a truthy value, CQL
      *   will continue executing. Should the handler return a falsy value,
      *   CQL will stop executing
      **/
     public function __invoke($root, $handler){}
 
 }
 }
 namespace CommonMark\Interfaces {
 interface IVisitable {
     /**
      * Visitation
      *
      * @param CommonMark\Interfaces\IVisitor $visitor An object
      *   implementing CommonMark\Interfaces\IVisitor
      * @return void
      **/
     public function accept($visitor);
 
 }
 }
 namespace CommonMark\Interfaces {
 interface IVisitor {
     /**
      * Visitation
      *
      * @param IVisitable $visitable The current
      *   CommonMark\Interfaces\IVisitable being entered
      * @return ?int|IVisitable Returning
      *   CommonMark\Interfaces\IVisitor::Done will cause the backing iterator
      *   to exit.
      **/
     public function enter($visitable);
 
     /**
      * Visitation
      *
      * @param IVisitable $visitable The current
      *   CommonMark\Interfaces\IVisitable being exited
      * @return ?int|IVisitable Returning
      *   CommonMark\Interfaces\IVisitor::Done will cause the backing iterator
      *   to exit.
      **/
     public function leave($visitable);
 
 }
 }
 namespace CommonMark {
 final class Node implements CommonMark\Interfaces\IVisitable, Traversable {
     /**
      * @var int
      **/
     public $endColumn;
 
     /**
      * @var int
      **/
     public $endLine;
 
     /**
      * @var ?Node
      **/
     public $firstChild;
 
     /**
      * @var ?Node
      **/
     public $lastChild;
 
     /**
      * @var ?Node
      **/
     public $next;
 
     /**
      * @var ?Node
      **/
     public $parent;
 
     /**
      * @var ?Node
      **/
     public $previous;
 
     /**
      * @var int
      **/
     public $startColumn;
 
     /**
      * @var int
      **/
     public $startLine;
 
     /**
      * Visitation
      *
      * @param CommonMark\Interfaces\IVisitor $visitor An object
      *   implementing CommonMark\Interfaces\IVisitor
      * @return void
      **/
     public function accept($visitor){}
 
     /**
      * AST Manipulation
      *
      * @param CommonMark\Node $child
      * @return CommonMark\Node
      **/
     public function appendChild($child){}
 
     /**
      * AST Manipulation
      *
      * @param CommonMark\Node $sibling
      * @return CommonMark\Node
      **/
     public function insertAfter($sibling){}
 
     /**
      * AST Manipulation
      *
      * @param CommonMark\Node $sibling
      * @return CommonMark\Node
      **/
     public function insertBefore($sibling){}
 
     /**
      * AST Manipulation
      *
      * @param CommonMark\Node $child
      * @return CommonMark\Node
      **/
     public function prependChild($child){}
 
     /**
      * AST Manipulation
      *
      * @param CommonMark\Node $target
      * @return CommonMark\Node
      **/
     public function replace($target){}
 
     /**
      * AST Manipulation
      *
      * @return void
      **/
     public function unlink(){}
 
 }
 }
 namespace CommonMark\Node {
 final class BlockQuote extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class BulletList extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class Code extends CommonMark\Node\Text implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class CodeBlock extends CommonMark\Node\Text implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class CustomBlock extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class CustomInline extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class Document extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class Heading extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class HTMLBlock extends CommonMark\Node\Text implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class HTMLInline extends CommonMark\Node\Text implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class Image extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class Item extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class LineBreak extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class Link extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class OrderedList extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class Paragraph extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class SoftBreak extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class Text extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node\Text {
 final class Emphasis extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node\Text {
 final class Strong extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark\Node {
 final class ThematicBreak extends CommonMark\Node implements CommonMark\Interfaces\IVisitable, Traversable {
 }
 }
 namespace CommonMark {
 final class Parser {
     /**
      * Parsing
      *
      * @return CommonMark\Node
      **/
     public function finish(){}
 
     /**
      * Parsing
      *
      * @param string $buffer
      * @return void
      **/
     public function parse($buffer){}
 
 }
 }
 /**
  * COMPersistHelper improves the interoperability of COM and PHP with
  * regard to the directive open_basedir, and stream s.
  **/
 final class COMPersistHelper {
     /**
      * Get current filename
      *
      * Retrieves the current name of the file associated with the object.
      *
      * @return string Returns the current name of the file associated with
      *   the object.
      * @since PHP 5, PHP 7
      **/
     public function GetCurFileName(){}
 
     /**
      * Get maximum stream size
      *
      * Retrieves the size of the stream (in bytes) needed to save the object.
      *
      * @return int Returns the size of the stream (in bytes) needed to save
      *   the object.
      * @since PHP 5, PHP 7
      **/
     public function GetMaxStreamSize(){}
 
     /**
      * Initialize object to default state
      *
      * Initializes an object to a default state.
      *
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function InitNew(){}
 
     /**
      * Load object from file
      *
      * Opens the specified file and initializes an object from the file
      * contents.
      *
      * @param string $path
      * @param int $flags
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function LoadFromFile($path, $flags){}
 
     /**
      * Load object from stream
      *
      * Initializes an object from the stream where it was saved previously.
      *
      * @param resource $stream
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function LoadFromStream($stream){}
 
     /**
      * Save object to file
      *
      * Saves a copy of the object to the specified file.
      *
      * @param string $filename
      * @param bool $remember
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function SaveToFile($filename, $remember){}
 
     /**
      * Save object to stream
      *
      * Saves an object to the specified stream.
      *
      * @param resource $stream
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function SaveToStream($stream){}
 
 }
 /**
  * CompileError is thrown for some compilation errors, which formerly
  * issued a fatal error.
  **/
 class CompileError extends Error {
 }
 namespace Componere {
 final class Definition {
     /**
      * Add Constant
      *
      * Shall declare a class constant on the current Definition
      *
      * @param string $name The case sensitive name for the constant
      * @param \Componere\Value $value The Value for the constant, must not
      *   be undefined or static
      * @return Definition The current Definition
      **/
     public function addConstant($name, $value){}
 
     /**
      * Add Interface
      *
      * Shall implement the given interface on the current definition
      *
      * @param string $interface The case insensitive name of an interface
      * @return Definition The current Definition
      **/
     public function addInterface($interface){}
 
     /**
      * Add Method
      *
      * Shall create or override a method on the current definition.
      *
      * @param string $name The case insensitive name for method
      * @param \Componere\Method $method \Componere\Method not previously
      *   added to another Definition
      * @return Definition The current Definition
      **/
     public function addMethod($name, $method){}
 
     /**
      * Add Property
      *
      * Shall declare a class property on the current Definition
      *
      * @param string $name The case sensitive name for the property
      * @param \Componere\Value $value The default Value for the property
      * @return Definition The current Definition
      **/
     public function addProperty($name, $value){}
 
     /**
      * Add Trait
      *
      * Shall use the given trait for the current definition
      *
      * @param string $trait The case insensitive name of a trait
      * @return Definition The current Definition
      **/
     public function addTrait($trait){}
 
     /**
      * Get Closure
      *
      * Shall return a Closure for the method specified by name
      *
      * @param string $name The case insensitive name of the method
      * @return \Closure A Closure bound to the correct scope
      **/
     public function getClosure($name){}
 
     /**
      * Get Closures
      *
      * Shall return an array of Closures
      *
      * @return array Shall return all methods as an array of Closure
      *   objects bound to the correct scope
      **/
     public function getClosures(){}
 
     /**
      * Reflection
      *
      * Shall create or return a ReflectionClass
      *
      * @return \ReflectionClass A ReflectionClass for the current
      *   definition (cached)
      **/
     public function getReflector(){}
 
     /**
      * State Detection
      *
      * Shall detect the registration state of this Definition
      *
      * @return bool Shall return true if this Definition is registered
      **/
     public function isRegistered(){}
 
     /**
      * Registration
      *
      * Shall register the current Definition
      *
      * @return void
      **/
     public function register(){}
 
 }
 }
 namespace Componere {
 final class Method {
     /**
      * Reflection
      *
      * Shall create or return a ReflectionMethod
      *
      * @return \ReflectionMethod A ReflectionMethod for the current method
      *   (cached)
      **/
     public function getReflector(){}
 
     /**
      * Accessibility Modification
      *
      * @return Method The current Method
      **/
     public function setPrivate(){}
 
     /**
      * Accessibility Modification
      *
      * @return Method The current Method
      **/
     public function setProtected(){}
 
     /**
      * Accessibility Modification
      *
      * @return Method The current Method
      **/
     public function setStatic(){}
 
 }
 }
 namespace Componere {
 final class Patch {
     /**
      * Add Interface
      *
      * Shall implement the given interface on the current definition
      *
      * @param string $interface The case insensitive name of an interface
      * @return Definition The current Definition
      **/
     public function addInterface($interface){}
 
     /**
      * Add Method
      *
      * Shall create or override a method on the current definition.
      *
      * @param string $name The case insensitive name for method
      * @param \Componere\Method $method \Componere\Method not previously
      *   added to another Definition
      * @return Definition The current Definition
      **/
     public function addMethod($name, $method){}
 
     /**
      * Add Trait
      *
      * Shall use the given trait for the current definition
      *
      * @param string $trait The case insensitive name of a trait
      * @return Definition The current Definition
      **/
     public function addTrait($trait){}
 
     /**
      * Application
      *
      * Shall apply the current patch
      *
      * @return void
      **/
     public function apply(){}
 
     /**
      * Patch Derivation
      *
      * Shall derive a Patch for the given {@link instance}
      *
      * @param object $instance The target for the derived Patch
      * @return Patch Patch for {@link instance} derived from the current
      *   Patch
      **/
     public function derive($instance){}
 
     /**
      * Get Closure
      *
      * Shall return a Closure for the method specified by name
      *
      * @param string $name The case insensitive name of the method
      * @return \Closure A Closure bound to the correct scope and object
      **/
     public function getClosure($name){}
 
     /**
      * Get Closures
      *
      * Shall return an array of Closures
      *
      * @return array Shall return all methods as an array of Closure
      *   objects bound to the correct scope and object
      **/
     public function getClosures(){}
 
     /**
      * Reflection
      *
      * Shall create or return a ReflectionClass
      *
      * @return \ReflectionClass A ReflectionClass for the current
      *   definition (cached)
      **/
     public function getReflector(){}
 
     /**
      * State Detection
      *
      * @return bool
      **/
     public function isApplied(){}
 
     /**
      * Reversal
      *
      * Shall revert the current patch
      *
      * @return void
      **/
     public function revert(){}
 
 }
 }
 namespace Componere {
 final class Value {
     /**
      * Value Interaction
      *
      * @return bool
      **/
     public function hasDefault(){}
 
     /**
      * Accessibility Detection
      *
      * @return bool
      **/
     public function isPrivate(){}
 
     /**
      * Accessibility Detection
      *
      * @return bool
      **/
     public function isProtected(){}
 
     /**
      * Accessibility Detection
      *
      * @return bool
      **/
     public function isStatic(){}
 
     /**
      * Accessibility Modification
      *
      * @return Value The current Value
      **/
     public function setPrivate(){}
 
     /**
      * Accessibility Modification
      *
      * @return Value The current Value
      **/
     public function setProtected(){}
 
     /**
      * Accessibility Modification
      *
      * @return Value The current Value
      **/
     public function setStatic(){}
 
 }
 }
 class com_exception extends Exception implements Throwable {
 }
 /**
  * The static methods contained in the Cond class provide direct access
  * to Posix Condition Variables.
  **/
 class Cond {
     /**
      * Broadcast a Condition
      *
      * Broadcast to all Threads blocking on a call to {@link Cond::wait}.
      *
      * @param int $condition A handle to a Condition Variable returned by a
      *   previous call to {@link Cond::create}
      * @return bool A boolean indication of success.
      * @since PECL pthreads < 3.0.0
      **/
     final public static function broadcast($condition){}
 
     /**
      * Create a Condition
      *
      * Creates a new Condition Variable for the caller.
      *
      * @return int A handle to a Condition Variable
      * @since PECL pthreads < 3.0.0
      **/
     final public static function create(){}
 
     /**
      * Destroy a Condition
      *
      * Destroying Condition Variable handles must be carried out explicitly
      * by the programmer when they are finished with the Condition Variable.
      * No Threads should be blocking on a call to {@link Cond::wait} when the
      * call to {@link Cond::destroy} takes place.
      *
      * @param int $condition A handle to a Condition Variable returned by a
      *   previous call to {@link Cond::create}
      * @return bool A boolean indication of success.
      * @since PECL pthreads < 3.0.0
      **/
     final public static function destroy($condition){}
 
     /**
      * Signal a Condition
      *
      * @param int $condition A handle returned by a previous call to {@link
      *   Cond::create}
      * @return bool A boolean indication of success.
      * @since PECL pthreads < 3.0.0
      **/
     final public static function signal($condition){}
 
     /**
      * Wait for Condition
      *
      * Wait for a signal on a Condition Variable, optionally specifying a
      * timeout to limit waiting time.
      *
      * @param int $condition A handle returned by a previous call to {@link
      *   Cond::create}.
      * @param int $mutex A handle returned by a previous call to {@link
      *   Mutex::create} and owned (locked) by the caller.
      * @param int $timeout An optional timeout, in microseconds (
      *   millionths of a second ).
      * @return bool A boolean indication of success.
      * @since PECL pthreads < 3.0.0
      **/
     final public static function wait($condition, $mutex, $timeout){}
 
 }
 /**
  * Classes implementing Countable can be used with the {@link count}
  * function.
  **/
 interface Countable {
     /**
      * Count elements of an object
      *
      * This method is executed when using the {@link count} function on an
      * object implementing Countable.
      *
      * @return int The custom count as an integer.
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function count();
 
 }
 /**
  * CURLFile should be used to upload a file with CURLOPT_POSTFIELDS.
  * {@link curl_setopt}
  **/
 class CURLFile {
     /**
      * MIME type of the file (default is application/octet-stream).
      *
      * @var mixed
      **/
     public $mime;
 
     /**
      * Name of the file to be uploaded.
      *
      * @var mixed
      **/
     public $name;
 
     /**
      * The name of the file in the upload data (defaults to the name
      * property).
      *
      * @var mixed
      **/
     public $postname;
 
     /**
      * Get file name
      *
      * @return string Returns file name.
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function getFilename(){}
 
     /**
      * Get MIME type
      *
      * @return string Returns MIME type.
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function getMimeType(){}
 
     /**
      * Get file name for POST
      *
      * @return string Returns file name for POST.
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function getPostFilename(){}
 
     /**
      * Set MIME type
      *
      * @param string $mime MIME type to be used in POST data.
      * @return void
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function setMimeType($mime){}
 
     /**
      * Set file name for POST
      *
      * @param string $postname Filename to be used in POST data.
      * @return void
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function setPostFilename($postname){}
 
     /**
      * Create a CURLFile object
      *
      * Creates a CURLFile object, used to upload a file with
      * CURLOPT_POSTFIELDS.
      *
      * @param string $filename Path to the file which will be uploaded.
      * @param string $mimetype Mimetype of the file.
      * @param string $postname Name of the file to be used in the upload
      *   data.
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function __construct($filename, $mimetype, $postname){}
 
     /**
      * Unserialization handler
      *
      * @return void
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function __wakeup(){}
 
 }
 /**
  * Represents a date interval. A date interval stores either a fixed
  * amount of time (in years, months, days, hours etc) or a relative time
  * string in the format that DateTime's constructor supports. More
  * specifically, the information in an object of the DateInterval class
  * is an instruction to get from one date/time to another date/time. This
  * process is not always reversible. A common way to create a
  * DateInterval object is by calculating the difference between two
  * date/time objects through {@link DateTimeInterface::diff}. 7.1.0 The f
  * property was added.
  **/
 class DateInterval {
     /**
      * Number of days.
      *
      * @var integer
      **/
     public $d;
 
     /**
      * If the DateInterval object was created by {@link DateTime::diff}, then
      * this is the total number of days between the start and end dates.
      * Otherwise, days will be FALSE.
      *
      * Before PHP 5.4.20/5.5.4 instead of FALSE you will receive -99999 upon
      * accessing the property.
      *
      * @var mixed
      **/
     public $days;
 
     /**
      * Number of microseconds, as a fraction of a second.
      *
      * @var float
      **/
     public $f;
 
     /**
      * Number of hours.
      *
      * @var integer
      **/
     public $h;
 
     /**
      * Number of minutes.
      *
      * @var integer
      **/
     public $i;
 
     /**
      * Is 1 if the interval represents a negative time period and 0
      * otherwise. See DateInterval::format.
      *
      * @var integer
      **/
     public $invert;
 
     /**
      * Number of months.
      *
      * @var integer
      **/
     public $m;
 
     /**
      * Number of seconds.
      *
      * @var integer
      **/
     public $s;
 
     /**
      * Number of years.
      *
      * @var integer
      **/
     public $y;
 
     /**
      * Sets up a DateInterval from the relative parts of the string
      *
      * Uses the normal date parsers and sets up a DateInterval from the
      * relative parts of the parsed string.
      *
      * @param string $datetime A date with relative parts. Specifically,
      *   the relative formats supported by the parser used for {@link
      *   strtotime} and DateTime will be used to construct the DateInterval.
      * @return DateInterval Returns a new DateInterval instance.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public static function createFromDateString($datetime){}
 
     /**
      * Formats the interval
      *
      * @param string $format The following characters are recognized in the
      *   {@link format} parameter string. Each format character must be
      *   prefixed by a percent sign (%). {@link format} character Description
      *   Example values % Literal % % Y Years, numeric, at least 2 digits
      *   with leading 0 01, 03 y Years, numeric 1, 3 M Months, numeric, at
      *   least 2 digits with leading 0 01, 03, 12 m Months, numeric 1, 3, 12
      *   D Days, numeric, at least 2 digits with leading 0 01, 03, 31 d Days,
      *   numeric 1, 3, 31 a Total number of days as a result of a
      *   DateTime::diff or (unknown) otherwise 4, 18, 8123 H Hours, numeric,
      *   at least 2 digits with leading 0 01, 03, 23 h Hours, numeric 1, 3,
      *   23 I Minutes, numeric, at least 2 digits with leading 0 01, 03, 59 i
      *   Minutes, numeric 1, 3, 59 S Seconds, numeric, at least 2 digits with
      *   leading 0 01, 03, 57 s Seconds, numeric 1, 3, 57 F Microseconds,
      *   numeric, at least 6 digits with leading 0 007701, 052738, 428291 f
      *   Microseconds, numeric 7701, 52738, 428291 R Sign "-" when negative,
      *   "+" when positive -, + r Sign "-" when negative, empty when positive
      *   -,
      * @return string Returns the formatted interval.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function format($format){}
 
 }
 /**
  * Represents a date period. A date period allows iteration over a set of
  * dates and times, recurring at regular intervals, over a given period.
  * 5.3.27, 5.4.17 The public properties recurrences, include_start_date,
  * start, current, end and interval have been exposed.
  **/
 class DatePeriod implements Traversable {
     /**
      * @var integer
      **/
     const EXCLUDE_START_DATE = 0;
 
     /**
      * During iteration this will contain the current date within the period.
      *
      * @var DateTimeInterface
      **/
     public $current;
 
     /**
      * The end date of the period.
      *
      * @var DateTimeInterface
      **/
     public $end;
 
     /**
      * Whether to include the start date in the set of recurring dates or
      * not.
      *
      * @var boolean
      **/
     public $include_start_date;
 
     /**
      * An ISO 8601 repeating interval specification.
      *
      * @var DateInterval
      **/
     public $interval;
 
     /**
      * The number of recurrences, if the DatePeriod instance had been created
      * by explicitly passing $recurrences. See also
      * DatePeriod::getRecurrences.
      *
      * @var integer
      **/
     public $recurrences;
 
     /**
      * The start date of the period.
      *
      * @var DateTimeInterface
      **/
     public $start;
 
     /**
      * Gets the interval
      *
      * Gets a DateInterval object representing the interval used for the
      * period.
      *
      * @return DateInterval Returns a DateInterval object
      * @since PHP 5 >= 5.6.5, PHP 7
      **/
     public function getDateInterval(){}
 
     /**
      * Gets the end date
      *
      * Gets the end date of the period.
      *
      * @return DateTimeInterface Returns NULL if the DatePeriod does not
      *   have an end date. For example, when initialized with the {@link
      *   recurrences} parameter, or the {@link isostr} parameter without an
      *   end date.
      * @since PHP 5 >= 5.6.5, PHP 7
      **/
     public function getEndDate(){}
 
     /**
      * Gets the number of recurrences
      *
      * Get the number of recurrences.
      *
      * @return int Returns the number of recurrences.
      * @since PHP 7 >= 7.2.17/7.3.4
      **/
     public function getRecurrences(){}
 
     /**
      * Gets the start date
      *
      * Gets the start date of the period.
      *
      * @return DateTimeInterface Returns a DateTimeImmutable object when
      *   the DatePeriod is initialized with a DateTimeImmutable object as the
      *   {@link start} parameter.
      * @since PHP 5 >= 5.6.5, PHP 7
      **/
     public function getStartDate(){}
 
 }
 /**
  * This class behaves the same as DateTimeImmutable except objects are
  * modified itself when modification methods such as {@link
  * DateTime::modify} are called. 7.2.0 The class constants of DateTime
  * are now defined on DateTimeInterface. 7.0.0 Added constants:
  * DATE_RFC3339_EXTENDED and DateTime::RFC3339_EXTENDED. 5.5.0 The class
  * now implements DateTimeInterface. 5.4.24 The COOKIE constant was
  * changed to reflect RFC 1036 using a four digit year rather than a two
  * digit year (RFC 850) as prior versions. 5.2.2 DateTime object
  * comparison with the comparison operators changed to work as expected.
  * Previously, all DateTime objects were considered equal (using ==).
  **/
 class DateTime implements DateTimeInterface {
     /**
      * Adds an amount of days, months, years, hours, minutes and seconds to a
      * DateTime object
      *
      * Adds the specified DateInterval object to the specified DateTime
      * object.
      *
      * @param DateInterval $interval A DateInterval object
      * @return DateTime
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function add($interval){}
 
     /**
      * Parses a time string according to a specified format
      *
      * Returns a new DateTime object representing the date and time specified
      * by the {@link datetime} string, which was formatted in the given
      * {@link format}.
      *
      * @param string $format The format that the passed in string should be
      *   in. See the formatting options below. In most cases, the same
      *   letters as for the {@link date} can be used.
      *   
      *   The following characters are recognized in the {@link format}
      *   parameter string {@link format} character Description Example
      *   parsable values Day --- --- d and j Day of the month, 2 digits with
      *   or without leading zeros 01 to 31 or 1 to 31 D and l A textual
      *   representation of a day Mon through Sun or Sunday through Saturday S
      *   English ordinal suffix for the day of the month, 2 characters. It's
      *   ignored while processing. st, nd, rd or th. z The day of the year
      *   (starting from 0) 0 through 365 Month --- --- F and M A textual
      *   representation of a month, such as January or Sept January through
      *   December or Jan through Dec m and n Numeric representation of a
      *   month, with or without leading zeros 01 through 12 or 1 through 12
      *   Year --- --- Y A full numeric representation of a year, 4 digits
      *   Examples: 1999 or 2003 y A two digit representation of a year (which
      *   is assumed to be in the range 1970-2069, inclusive) Examples: 99 or
      *   03 (which will be interpreted as 1999 and 2003, respectively) Time
      *   --- --- a and A Ante meridiem and Post meridiem am or pm g and h
      *   12-hour format of an hour with or without leading zero 1 through 12
      *   or 01 through 12 G and H 24-hour format of an hour with or without
      *   leading zeros 0 through 23 or 00 through 23 i Minutes with leading
      *   zeros 00 to 59 s Seconds, with leading zeros 00 through 59 v
      *   Milliseconds (up to three digits) Example: 12, 345 u Microseconds
      *   (up to six digits) Example: 45, 654321 Timezone --- --- e, O, P and
      *   T Timezone identifier, or difference to UTC in hours, or difference
      *   to UTC with colon between hours and minutes, or timezone
      *   abbreviation Examples: UTC, GMT, Atlantic/Azores or +0200 or +02:00
      *   or EST, MDT Full Date/Time --- --- U Seconds since the Unix Epoch
      *   (January 1 1970 00:00:00 GMT) Example: 1292177455 Whitespace and
      *   Separators --- --- (space) One space or one tab Example: # One of
      *   the following separation symbol: ;, :, /, ., ,, -, ( or ) Example: /
      *   ;, :, /, ., ,, -, ( or ) The specified character. Example: - ? A
      *   random byte Example: ^ (Be aware that for UTF-8 characters you might
      *   need more than one ?. In this case, using * is probably what you
      *   want instead) * Random bytes until the next separator or digit
      *   Example: * in Y-*-d with the string 2009-aWord-08 will match aWord !
      *   Resets all fields (year, month, day, hour, minute, second, fraction
      *   and timezone information) to the Unix Epoch Without !, all fields
      *   will be set to the current date and time. | Resets all fields (year,
      *   month, day, hour, minute, second, fraction and timezone information)
      *   to the Unix Epoch if they have not been parsed yet Y-m-d| will set
      *   the year, month and day to the information found in the string to
      *   parse, and sets the hour, minute and second to 0. + If this format
      *   specifier is present, trailing data in the string will not cause an
      *   error, but a warning instead Use DateTime::getLastErrors to find out
      *   whether trailing data was present. Unrecognized characters in the
      *   format string will cause the parsing to fail and an error message is
      *   appended to the returned structure. You can query error messages
      *   with DateTime::getLastErrors. To include literal characters in
      *   {@link format}, you have to escape them with a backslash (\). If
      *   {@link format} does not contain the character ! then portions of the
      *   generated time which are not specified in {@link format} will be set
      *   to the current system time. If {@link format} contains the character
      *   !, then portions of the generated time not provided in {@link
      *   format}, as well as values to the left-hand side of the !, will be
      *   set to corresponding values from the Unix epoch. The Unix epoch is
      *   1970-01-01 00:00:00 UTC.
      * @param string $datetime String representing the time.
      * @param DateTimeZone $timezone A DateTimeZone object representing the
      *   desired time zone. If {@link timezone} is omitted and {@link
      *   datetime} contains no timezone, the current timezone will be used.
      * @return DateTime Returns a new DateTime instance.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public static function createFromFormat($format, $datetime, $timezone){}
 
     /**
      * Returns new DateTime object encapsulating the given DateTimeImmutable
      * object
      *
      * @param DateTimeImmutable $object The immutable DateTimeImmutable
      *   object that needs to be converted to a mutable version. This object
      *   is not modified, but instead a new DateTime object is created
      *   containing the same date, time, and timezone information.
      * @return DateTime Returns a new DateTime instance.
      * @since PHP 7 >= 7.3.0
      **/
     public static function createFromImmutable($object){}
 
     /**
      * Returns the difference between two DateTime objects
      *
      * Returns the difference between two DateTimeInterface objects.
      *
      * @param DateTimeInterface $targetObject The date to compare to.
      * @param bool $absolute Should the interval be forced to be positive?
      * @return DateInterval The DateInterval object represents the
      *   difference between the two dates.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function diff($targetObject, $absolute){}
 
     /**
      * Returns date formatted according to given format
      *
      * @param string $format The format of the outputted date string. See
      *   the formatting options below. There are also several predefined date
      *   constants that may be used instead, so for example DATE_RSS contains
      *   the format string 'D, d M Y H:i:s'.
      *   
      *   The following characters are recognized in the {@link format}
      *   parameter string {@link format} character Description Example
      *   returned values Day --- --- d Day of the month, 2 digits with
      *   leading zeros 01 to 31 D A textual representation of a day, three
      *   letters Mon through Sun j Day of the month without leading zeros 1
      *   to 31 l (lowercase 'L') A full textual representation of the day of
      *   the week Sunday through Saturday N ISO-8601 numeric representation
      *   of the day of the week (added in PHP 5.1.0) 1 (for Monday) through 7
      *   (for Sunday) S English ordinal suffix for the day of the month, 2
      *   characters st, nd, rd or th. Works well with j w Numeric
      *   representation of the day of the week 0 (for Sunday) through 6 (for
      *   Saturday) z The day of the year (starting from 0) 0 through 365 Week
      *   --- --- W ISO-8601 week number of year, weeks starting on Monday
      *   Example: 42 (the 42nd week in the year) Month --- --- F A full
      *   textual representation of a month, such as January or March January
      *   through December m Numeric representation of a month, with leading
      *   zeros 01 through 12 M A short textual representation of a month,
      *   three letters Jan through Dec n Numeric representation of a month,
      *   without leading zeros 1 through 12 t Number of days in the given
      *   month 28 through 31 Year --- --- L Whether it's a leap year 1 if it
      *   is a leap year, 0 otherwise. o ISO-8601 week-numbering year. This
      *   has the same value as Y, except that if the ISO week number (W)
      *   belongs to the previous or next year, that year is used instead.
      *   (added in PHP 5.1.0) Examples: 1999 or 2003 Y A full numeric
      *   representation of a year, 4 digits Examples: 1999 or 2003 y A two
      *   digit representation of a year Examples: 99 or 03 Time --- --- a
      *   Lowercase Ante meridiem and Post meridiem am or pm A Uppercase Ante
      *   meridiem and Post meridiem AM or PM B Swatch Internet time 000
      *   through 999 g 12-hour format of an hour without leading zeros 1
      *   through 12 G 24-hour format of an hour without leading zeros 0
      *   through 23 h 12-hour format of an hour with leading zeros 01 through
      *   12 H 24-hour format of an hour with leading zeros 00 through 23 i
      *   Minutes with leading zeros 00 to 59 s Seconds with leading zeros 00
      *   through 59 u Microseconds (added in PHP 5.2.2). Note that {@link
      *   date} will always generate 000000 since it takes an integer
      *   parameter, whereas DateTime::format does support microseconds if
      *   DateTime was created with microseconds. Example: 654321 v
      *   Milliseconds (added in PHP 7.0.0). Same note applies as for u.
      *   Example: 654 Timezone --- --- e Timezone identifier (added in PHP
      *   5.1.0) Examples: UTC, GMT, Atlantic/Azores I (capital i) Whether or
      *   not the date is in daylight saving time 1 if Daylight Saving Time, 0
      *   otherwise. O Difference to Greenwich time (GMT) without colon
      *   between hours and minutes Example: +0200 P Difference to Greenwich
      *   time (GMT) with colon between hours and minutes (added in PHP 5.1.3)
      *   Example: +02:00 T Timezone abbreviation Examples: EST, MDT ... Z
      *   Timezone offset in seconds. The offset for timezones west of UTC is
      *   always negative, and for those east of UTC is always positive.
      *   -43200 through 50400 Full Date/Time --- --- c ISO 8601 date (added
      *   in PHP 5) 2004-02-12T15:19:21+00:00 r RFC 2822 formatted date
      *   Example: Thu, 21 Dec 2000 16:01:07 +0200 U Seconds since the Unix
      *   Epoch (January 1 1970 00:00:00 GMT) See also {@link time}
      *   Unrecognized characters in the format string will be printed as-is.
      *   The Z format will always return 0 when using {@link gmdate}.
      * @return string Returns the formatted date string on success.
      * @since PHP 5 >= 5.2.1, PHP 7
      **/
     public function format($format){}
 
     /**
      * Returns the warnings and errors
      *
      * Returns an array of warnings and errors found while parsing a
      * date/time string.
      *
      * @return array Returns array containing info about warnings and
      *   errors.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public static function getLastErrors(){}
 
     /**
      * Returns the timezone offset
      *
      * @return int Returns the timezone offset in seconds from UTC on
      *   success .
      * @since PHP 5 >= 5.2.1, PHP 7
      **/
     public function getOffset(){}
 
     /**
      * Gets the Unix timestamp
      *
      * @return int Returns the Unix timestamp representing the date.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function getTimestamp(){}
 
     /**
      * Return time zone relative to given DateTime
      *
      * @return DateTimeZone Returns a DateTimeZone object on success .
      * @since PHP 5 >= 5.2.1, PHP 7
      **/
     public function getTimezone(){}
 
     /**
      * Alters the timestamp
      *
      * Alter the timestamp of a DateTime object by incrementing or
      * decrementing in a format accepted by {@link
      * DateTimeImmutable::__construct}.
      *
      * @param string $modifier
      * @return DateTime
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function modify($modifier){}
 
     /**
      * Sets the date
      *
      * Resets the current date of the DateTime object to a different date.
      *
      * @param int $year Year of the date.
      * @param int $month Month of the date.
      * @param int $day Day of the date.
      * @return DateTime
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function setDate($year, $month, $day){}
 
     /**
      * Sets the ISO date
      *
      * Set a date according to the ISO 8601 standard - using weeks and day
      * offsets rather than specific dates.
      *
      * @param int $year Year of the date.
      * @param int $week Week of the date.
      * @param int $dayOfWeek Offset from the first day of the week.
      * @return DateTime
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function setISODate($year, $week, $dayOfWeek){}
 
     /**
      * Sets the time
      *
      * Resets the current time of the DateTime object to a different time.
      *
      * @param int $hour Hour of the time.
      * @param int $minute Minute of the time.
      * @param int $second Second of the time.
      * @param int $microsecond Microsecond of the time.
      * @return DateTime
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function setTime($hour, $minute, $second, $microsecond){}
 
     /**
      * Sets the date and time based on an Unix timestamp
      *
      * @param int $timestamp Unix timestamp representing the date.
      * @return DateTime
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function setTimestamp($timestamp){}
 
     /**
      * Sets the time zone for the DateTime object
      *
      * Sets a new timezone for a DateTime object.
      *
      * @param DateTimeZone $timezone A DateTimeZone object representing the
      *   desired time zone.
      * @return DateTime
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function setTimezone($timezone){}
 
     /**
      * Subtracts an amount of days, months, years, hours, minutes and seconds
      * from a DateTime object
      *
      * Subtracts the specified DateInterval object from the specified
      * DateTime object.
      *
      * @param DateInterval $interval A DateInterval object
      * @return DateTime
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function sub($interval){}
 
     /**
      * The __set_state handler
      *
      * The __set_state() handler.
      *
      * @param array $array Initialization array.
      * @return DateTime Returns a new instance of a DateTime object.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public static function __set_state($array){}
 
     /**
      * The __wakeup handler
      *
      * The __wakeup() handler.
      *
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function __wakeup(){}
 
 }
 /**
  * Representation of date and time.
  **/
 class DateTimeImmutable implements DateTimeInterface {
     /**
      * Adds an amount of days, months, years, hours, minutes and seconds
      *
      * Like DateTime::add but works with DateTimeImmutable.
      *
      * @param DateInterval $interval
      * @return DateTimeImmutable
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function add($interval){}
 
     /**
      * Parses a time string according to a specified format
      *
      * Like DateTime::createFromFormat but works with DateTimeImmutable.
      *
      * @param string $format
      * @param string $datetime
      * @param DateTimeZone $timezone
      * @return DateTimeImmutable
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public static function createFromFormat($format, $datetime, $timezone){}
 
     /**
      * Returns new DateTimeImmutable object encapsulating the given DateTime
      * object
      *
      * @param DateTime $object The mutable DateTime object that you want to
      *   convert to an immutable version. This object is not modified, but
      *   instead a new DateTimeImmutable object is created containing the
      *   same date time and timezone information.
      * @return DateTimeImmutable Returns a new DateTimeImmutable instance.
      * @since PHP 5 >= 5.6.0, PHP 7
      **/
     public static function createFromMutable($object){}
 
     /**
      * Returns the difference between two DateTime objects
      *
      * Returns the difference between two DateTimeInterface objects.
      *
      * @param DateTimeInterface $targetObject The date to compare to.
      * @param bool $absolute Should the interval be forced to be positive?
      * @return DateInterval The DateInterval object represents the
      *   difference between the two dates.
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function diff($targetObject, $absolute){}
 
     /**
      * Returns date formatted according to given format
      *
      * @param string $format The format of the outputted date string. See
      *   the formatting options below. There are also several predefined date
      *   constants that may be used instead, so for example DATE_RSS contains
      *   the format string 'D, d M Y H:i:s'.
      *   
      *   The following characters are recognized in the {@link format}
      *   parameter string {@link format} character Description Example
      *   returned values Day --- --- d Day of the month, 2 digits with
      *   leading zeros 01 to 31 D A textual representation of a day, three
      *   letters Mon through Sun j Day of the month without leading zeros 1
      *   to 31 l (lowercase 'L') A full textual representation of the day of
      *   the week Sunday through Saturday N ISO-8601 numeric representation
      *   of the day of the week (added in PHP 5.1.0) 1 (for Monday) through 7
      *   (for Sunday) S English ordinal suffix for the day of the month, 2
      *   characters st, nd, rd or th. Works well with j w Numeric
      *   representation of the day of the week 0 (for Sunday) through 6 (for
      *   Saturday) z The day of the year (starting from 0) 0 through 365 Week
      *   --- --- W ISO-8601 week number of year, weeks starting on Monday
      *   Example: 42 (the 42nd week in the year) Month --- --- F A full
      *   textual representation of a month, such as January or March January
      *   through December m Numeric representation of a month, with leading
      *   zeros 01 through 12 M A short textual representation of a month,
      *   three letters Jan through Dec n Numeric representation of a month,
      *   without leading zeros 1 through 12 t Number of days in the given
      *   month 28 through 31 Year --- --- L Whether it's a leap year 1 if it
      *   is a leap year, 0 otherwise. o ISO-8601 week-numbering year. This
      *   has the same value as Y, except that if the ISO week number (W)
      *   belongs to the previous or next year, that year is used instead.
      *   (added in PHP 5.1.0) Examples: 1999 or 2003 Y A full numeric
      *   representation of a year, 4 digits Examples: 1999 or 2003 y A two
      *   digit representation of a year Examples: 99 or 03 Time --- --- a
      *   Lowercase Ante meridiem and Post meridiem am or pm A Uppercase Ante
      *   meridiem and Post meridiem AM or PM B Swatch Internet time 000
      *   through 999 g 12-hour format of an hour without leading zeros 1
      *   through 12 G 24-hour format of an hour without leading zeros 0
      *   through 23 h 12-hour format of an hour with leading zeros 01 through
      *   12 H 24-hour format of an hour with leading zeros 00 through 23 i
      *   Minutes with leading zeros 00 to 59 s Seconds with leading zeros 00
      *   through 59 u Microseconds (added in PHP 5.2.2). Note that {@link
      *   date} will always generate 000000 since it takes an integer
      *   parameter, whereas DateTime::format does support microseconds if
      *   DateTime was created with microseconds. Example: 654321 v
      *   Milliseconds (added in PHP 7.0.0). Same note applies as for u.
      *   Example: 654 Timezone --- --- e Timezone identifier (added in PHP
      *   5.1.0) Examples: UTC, GMT, Atlantic/Azores I (capital i) Whether or
      *   not the date is in daylight saving time 1 if Daylight Saving Time, 0
      *   otherwise. O Difference to Greenwich time (GMT) without colon
      *   between hours and minutes Example: +0200 P Difference to Greenwich
      *   time (GMT) with colon between hours and minutes (added in PHP 5.1.3)
      *   Example: +02:00 T Timezone abbreviation Examples: EST, MDT ... Z
      *   Timezone offset in seconds. The offset for timezones west of UTC is
      *   always negative, and for those east of UTC is always positive.
      *   -43200 through 50400 Full Date/Time --- --- c ISO 8601 date (added
      *   in PHP 5) 2004-02-12T15:19:21+00:00 r RFC 2822 formatted date
      *   Example: Thu, 21 Dec 2000 16:01:07 +0200 U Seconds since the Unix
      *   Epoch (January 1 1970 00:00:00 GMT) See also {@link time}
      *   Unrecognized characters in the format string will be printed as-is.
      *   The Z format will always return 0 when using {@link gmdate}.
      * @return string Returns the formatted date string on success.
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function format($format){}
 
     /**
      * Returns the warnings and errors
      *
      * Like DateTime::getLastErrors but works with DateTimeImmutable.
      *
      * @return array
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public static function getLastErrors(){}
 
     /**
      * Returns the timezone offset
      *
      * @return int Returns the timezone offset in seconds from UTC on
      *   success .
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function getOffset(){}
 
     /**
      * Gets the Unix timestamp
      *
      * @return int Returns the Unix timestamp representing the date.
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function getTimestamp(){}
 
     /**
      * Return time zone relative to given DateTime
      *
      * @return DateTimeZone Returns a DateTimeZone object on success .
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function getTimezone(){}
 
     /**
      * Creates a new object with modified timestamp
      *
      * Creates a new DateTimeImmutable object with modified timestamp. The
      * original object is not modified.
      *
      * @param string $modifier
      * @return DateTimeImmutable Returns the newly created object.
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function modify($modifier){}
 
     /**
      * Sets the date
      *
      * Like DateTime::setDate but works with DateTimeImmutable.
      *
      * @param int $year
      * @param int $month
      * @param int $day
      * @return DateTimeImmutable
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function setDate($year, $month, $day){}
 
     /**
      * Sets the ISO date
      *
      * Like DateTime::setISODate but works with DateTimeImmutable.
      *
      * @param int $year
      * @param int $week
      * @param int $day
      * @return DateTimeImmutable
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function setISODate($year, $week, $day){}
 
     /**
      * Sets the time
      *
      * Like DateTime::setTime but works with DateTimeImmutable.
      *
      * @param int $hour
      * @param int $minute
      * @param int $second
      * @param int $microsecond
      * @return DateTimeImmutable
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function setTime($hour, $minute, $second, $microsecond){}
 
     /**
      * Sets the date and time based on a Unix timestamp
      *
      * Like DateTime::setTimestamp but works with DateTimeImmutable.
      *
      * @param int $timestamp
      * @return DateTimeImmutable
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function setTimestamp($timestamp){}
 
     /**
      * Sets the time zone
      *
      * Like DateTime::setTimezone but works with DateTimeImmutable.
      *
      * @param DateTimeZone $timezone
      * @return DateTimeImmutable
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function setTimezone($timezone){}
 
     /**
      * Subtracts an amount of days, months, years, hours, minutes and seconds
      *
      * Like DateTime::sub but works with DateTimeImmutable.
      *
      * @param DateInterval $interval
      * @return DateTimeImmutable
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function sub($interval){}
 
     /**
      * The __set_state handler
      *
      * Like DateTime::__set_state but works with DateTimeImmutable.
      *
      * @param array $array
      * @return DateTimeImmutable
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public static function __set_state($array){}
 
     /**
      * The __wakeup handler
      *
      * The __wakeup() handler.
      *
      * @since PHP 5 >= 5.5.0, PHP 7
      **/
     public function __wakeup(){}
 
 }
 /**
  * DateTimeInterface is meant so that both DateTime and DateTimeImmutable
  * can be type hinted for. It is not possible to implement this interface
  * with userland classes. 7.2.0 The class constants of DateTime are now
  * defined on DateTimeInterface. 5.5.8 Trying to implement
  * DateTimeInterface raises a fatal error now. Formerly implementing the
  * interface didn't raise an error, but the behavior was erroneous.
  **/
 interface DateTimeInterface {
     /**
      * @var string
      **/
     const ATOM = '';
 
     /**
      * @var string
      **/
     const COOKIE = '';
 
     /**
      * @var string
      **/
     const ISO8601 = '';
 
     /**
      * @var string
      **/
     const RFC822 = '';
 
     /**
      * @var string
      **/
     const RFC850 = '';
 
     /**
      * @var string
      **/
     const RFC1036 = '';
 
     /**
      * @var string
      **/
     const RFC1123 = '';
 
     /**
      * @var string
      **/
     const RFC2822 = '';
 
     /**
      * @var string
      **/
     const RFC3339 = '';
 
     /**
      * @var string
      **/
     const RFC3339_EXTENDED = '';
 
     /**
      * @var string
      **/
     const RFC7231 = '';
 
     /**
      * @var string
      **/
     const RSS = '';
 
     /**
      * @var string
      **/
     const W3C = '';
 
     /**
      * Returns the difference between two DateTime objects
      *
      * Returns the difference between two DateTimeInterface objects.
      *
      * @param DateTimeInterface $targetObject The date to compare to.
      * @param bool $absolute Should the interval be forced to be positive?
      * @return DateInterval The DateInterval object represents the
      *   difference between the two dates.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function diff($targetObject, $absolute);
 
     /**
      * Returns date formatted according to given format
      *
      * @param string $format The format of the outputted date string. See
      *   the formatting options below. There are also several predefined date
      *   constants that may be used instead, so for example DATE_RSS contains
      *   the format string 'D, d M Y H:i:s'.
      *   
      *   The following characters are recognized in the {@link format}
      *   parameter string {@link format} character Description Example
      *   returned values Day --- --- d Day of the month, 2 digits with
      *   leading zeros 01 to 31 D A textual representation of a day, three
      *   letters Mon through Sun j Day of the month without leading zeros 1
      *   to 31 l (lowercase 'L') A full textual representation of the day of
      *   the week Sunday through Saturday N ISO-8601 numeric representation
      *   of the day of the week (added in PHP 5.1.0) 1 (for Monday) through 7
      *   (for Sunday) S English ordinal suffix for the day of the month, 2
      *   characters st, nd, rd or th. Works well with j w Numeric
      *   representation of the day of the week 0 (for Sunday) through 6 (for
      *   Saturday) z The day of the year (starting from 0) 0 through 365 Week
      *   --- --- W ISO-8601 week number of year, weeks starting on Monday
      *   Example: 42 (the 42nd week in the year) Month --- --- F A full
      *   textual representation of a month, such as January or March January
      *   through December m Numeric representation of a month, with leading
      *   zeros 01 through 12 M A short textual representation of a month,
      *   three letters Jan through Dec n Numeric representation of a month,
      *   without leading zeros 1 through 12 t Number of days in the given
      *   month 28 through 31 Year --- --- L Whether it's a leap year 1 if it
      *   is a leap year, 0 otherwise. o ISO-8601 week-numbering year. This
      *   has the same value as Y, except that if the ISO week number (W)
      *   belongs to the previous or next year, that year is used instead.
      *   (added in PHP 5.1.0) Examples: 1999 or 2003 Y A full numeric
      *   representation of a year, 4 digits Examples: 1999 or 2003 y A two
      *   digit representation of a year Examples: 99 or 03 Time --- --- a
      *   Lowercase Ante meridiem and Post meridiem am or pm A Uppercase Ante
      *   meridiem and Post meridiem AM or PM B Swatch Internet time 000
      *   through 999 g 12-hour format of an hour without leading zeros 1
      *   through 12 G 24-hour format of an hour without leading zeros 0
      *   through 23 h 12-hour format of an hour with leading zeros 01 through
      *   12 H 24-hour format of an hour with leading zeros 00 through 23 i
      *   Minutes with leading zeros 00 to 59 s Seconds with leading zeros 00
      *   through 59 u Microseconds (added in PHP 5.2.2). Note that {@link
      *   date} will always generate 000000 since it takes an integer
      *   parameter, whereas DateTime::format does support microseconds if
      *   DateTime was created with microseconds. Example: 654321 v
      *   Milliseconds (added in PHP 7.0.0). Same note applies as for u.
      *   Example: 654 Timezone --- --- e Timezone identifier (added in PHP
      *   5.1.0) Examples: UTC, GMT, Atlantic/Azores I (capital i) Whether or
      *   not the date is in daylight saving time 1 if Daylight Saving Time, 0
      *   otherwise. O Difference to Greenwich time (GMT) without colon
      *   between hours and minutes Example: +0200 P Difference to Greenwich
      *   time (GMT) with colon between hours and minutes (added in PHP 5.1.3)
      *   Example: +02:00 T Timezone abbreviation Examples: EST, MDT ... Z
      *   Timezone offset in seconds. The offset for timezones west of UTC is
      *   always negative, and for those east of UTC is always positive.
      *   -43200 through 50400 Full Date/Time --- --- c ISO 8601 date (added
      *   in PHP 5) 2004-02-12T15:19:21+00:00 r RFC 2822 formatted date
      *   Example: Thu, 21 Dec 2000 16:01:07 +0200 U Seconds since the Unix
      *   Epoch (January 1 1970 00:00:00 GMT) See also {@link time}
      *   Unrecognized characters in the format string will be printed as-is.
      *   The Z format will always return 0 when using {@link gmdate}.
      * @return string Returns the formatted date string on success.
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function format($format);
 
     /**
      * Returns the timezone offset
      *
      * @return int Returns the timezone offset in seconds from UTC on
      *   success .
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function getOffset();
 
     /**
      * Gets the Unix timestamp
      *
      * @return int Returns the Unix timestamp representing the date.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function getTimestamp();
 
     /**
      * Return time zone relative to given DateTime
      *
      * @return DateTimeZone Returns a DateTimeZone object on success .
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function getTimezone();
 
     /**
      * The __wakeup handler
      *
      * The __wakeup() handler.
      *
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function __wakeup();
 
 }
 /**
  * Representation of time zone.
  **/
 class DateTimeZone {
     /**
      * Africa time zones.
      *
      * @var integer
      **/
     const AFRICA = 0;
 
     /**
      * All time zones.
      *
      * @var integer
      **/
     const ALL = 0;
 
     /**
      * @var integer
      **/
     const ALL_WITH_BC = 0;
 
     /**
      * America time zones.
      *
      * @var integer
      **/
     const AMERICA = 0;
 
     /**
      * Antarctica time zones.
      *
      * @var integer
      **/
     const ANTARCTICA = 0;
 
     /**
      * Arctic time zones.
      *
      * @var integer
      **/
     const ARCTIC = 0;
 
     /**
      * Asia time zones.
      *
      * @var integer
      **/
     const ASIA = 0;
 
     /**
      * Atlantic time zones.
      *
      * @var integer
      **/
     const ATLANTIC = 0;
 
     /**
      * Australia time zones.
      *
      * @var integer
      **/
     const AUSTRALIA = 0;
 
     /**
      * Europe time zones.
      *
      * @var integer
      **/
     const EUROPE = 0;
 
     /**
      * Indian time zones.
      *
      * @var integer
      **/
     const INDIAN = 0;
 
     /**
      * Pacific time zones.
      *
      * @var integer
      **/
     const PACIFIC = 0;
 
     /**
      * @var integer
      **/
     const PER_COUNTRY = 0;
 
     /**
      * UTC time zones.
      *
      * @var integer
      **/
     const UTC = 0;
 
     /**
      * Returns location information for a timezone
      *
      * Returns location information for a timezone, including country code,
      * latitude/longitude and comments.
      *
      * @return array Array containing location information about timezone.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function getLocation(){}
 
     /**
      * Returns the name of the timezone
      *
      * @return string One of the timezone names in the list of timezones.
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function getName(){}
 
     /**
      * Returns the timezone offset from GMT
      *
      * This function returns the offset to GMT for the date/time specified in
      * the {@link datetime} parameter. The GMT offset is calculated with the
      * timezone information contained in the DateTimeZone object being used.
      *
      * @param DateTimeInterface $datetime DateTime that contains the
      *   date/time to compute the offset from.
      * @return int Returns time zone offset in seconds on success.
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function getOffset($datetime){}
 
     /**
      * Returns all transitions for the timezone
      *
      * @param int $timestampBegin Begin timestamp.
      * @param int $timestampEnd End timestamp.
      * @return array Returns numerically indexed array containing
      *   associative array with all transitions on success.
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function getTransitions($timestampBegin, $timestampEnd){}
 
     /**
      * Returns associative array containing dst, offset and the timezone name
      *
      * @return array Returns array on success.
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public static function listAbbreviations(){}
 
     /**
      * Returns a numerically indexed array containing all defined timezone
      * identifiers
      *
      * @param int $timezoneGroup One of the DateTimeZone class constants
      *   (or a combination).
      * @param string $countryCode A two-letter ISO 3166-1 compatible
      *   country code.
      * @return array Returns array on success.
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public static function listIdentifiers($timezoneGroup, $countryCode){}
 
 }
 /**
  * Created by {@link dir}.
  **/
 class Directory {
     /**
      * Can be used with other directory functions such as {@link readdir},
      * {@link rewinddir} and {@link closedir}.
      *
      * @var resource
      **/
     public $handle;
 
     /**
      * The directory that was opened.
      *
      * @var string
      **/
     public $path;
 
     /**
      * Close directory handle
      *
      * Same as {@link closedir}, only dir_handle defaults to $this->handle.
      *
      * @param resource $dir_handle
      * @return void
      * @since PHP 4, PHP 5, PHP 7
      **/
     public function close($dir_handle){}
 
     /**
      * Read entry from directory handle
      *
      * Same as {@link readdir}, only dir_handle defaults to $this->handle.
      *
      * @param resource $dir_handle
      * @return string
      * @since PHP 4, PHP 5, PHP 7
      **/
     public function read($dir_handle){}
 
     /**
      * Rewind directory handle
      *
      * Same as {@link rewinddir}, only dir_handle defaults to $this->handle.
      *
      * @param resource $dir_handle
      * @return void
      * @since PHP 4, PHP 5, PHP 7
      **/
     public function rewind($dir_handle){}
 
 }
 /**
  * The DirectoryIterator class provides a simple interface for viewing
  * the contents of filesystem directories. 5.1.2 DirectoryIterator
  * extends SplFileInfo.
  **/
 class DirectoryIterator extends SplFileInfo implements SeekableIterator {
     /**
      * Return the current DirectoryIterator item
      *
      * Get the current DirectoryIterator item.
      *
      * @return DirectoryIterator The current DirectoryIterator item.
      * @since PHP 5, PHP 7
      **/
     public function current(){}
 
     /**
      * Get last access time of the current DirectoryIterator item
      *
      * Get the last access time of the current DirectoryIterator item.
      *
      * @return int Returns the time the file was last accessed, as a Unix
      *   timestamp.
      * @since PHP 5, PHP 7
      **/
     public function getATime(){}
 
     /**
      * Get base name of current DirectoryIterator item
      *
      * Get the base name of the current DirectoryIterator item.
      *
      * @param string $suffix If the base name ends in {@link suffix}, this
      *   will be cut.
      * @return string The base name of the current DirectoryIterator item.
      * @since PHP 5 >= 5.2.2, PHP 7
      **/
     public function getBasename($suffix){}
 
     /**
      * Get inode change time of the current DirectoryIterator item
      *
      * Get the inode change time for the current DirectoryIterator item.
      *
      * @return int Returns the last change time of the file, as a Unix
      *   timestamp.
      * @since PHP 5, PHP 7
      **/
     public function getCTime(){}
 
     /**
      * Gets the file extension
      *
      * Retrieves the file extension.
      *
      * @return string Returns a string containing the file extension, or an
      *   empty string if the file has no extension.
      * @since PHP 5 >= 5.3.6, PHP 7
      **/
     public function getExtension(){}
 
     /**
      * Return file name of current DirectoryIterator item
      *
      * Get the file name of the current DirectoryIterator item.
      *
      * @return string Returns the file name of the current
      *   DirectoryIterator item.
      * @since PHP 5, PHP 7
      **/
     public function getFilename(){}
 
     /**
      * Get group for the current DirectoryIterator item
      *
      * Get the group id of the file.
      *
      * @return int Returns the group id of the current DirectoryIterator
      *   item in numerical format.
      * @since PHP 5, PHP 7
      **/
     public function getGroup(){}
 
     /**
      * Get inode for the current DirectoryIterator item
      *
      * Get the inode number for the current DirectoryIterator item.
      *
      * @return int Returns the inode number for the file.
      * @since PHP 5, PHP 7
      **/
     public function getInode(){}
 
     /**
      * Get last modification time of current DirectoryIterator item
      *
      * Get the last modification time of the current DirectoryIterator item,
      * as a Unix timestamp.
      *
      * @return int The last modification time of the file, as a Unix
      *   timestamp.
      * @since PHP 5, PHP 7
      **/
     public function getMTime(){}
 
     /**
      * Get owner of current DirectoryIterator item
      *
      * Get the owner of the current DirectoryIterator item, in numerical
      * format.
      *
      * @return int The file owner of the file, in numerical format.
      * @since PHP 5, PHP 7
      **/
     public function getOwner(){}
 
     /**
      * Get path of current Iterator item without filename
      *
      * Get the path to the current DirectoryIterator item.
      *
      * @return string Returns the path to the file, omitting the file name
      *   and any trailing slash.
      * @since PHP 5, PHP 7
      **/
     public function getPath(){}
 
     /**
      * Return path and file name of current DirectoryIterator item
      *
      * Get the path and file name of the current file.
      *
      * @return string Returns the path and file name of current file.
      *   Directories do not have a trailing slash.
      * @since PHP 5, PHP 7
      **/
     public function getPathname(){}
 
     /**
      * Get the permissions of current DirectoryIterator item
      *
      * Get the permissions of the current DirectoryIterator item.
      *
      * @return int Returns the permissions of the file, as a decimal
      *   integer.
      * @since PHP 5, PHP 7
      **/
     public function getPerms(){}
 
     /**
      * Get size of current DirectoryIterator item
      *
      * Get the file size for the current DirectoryIterator item.
      *
      * @return int Returns the size of the file, in bytes.
      * @since PHP 5, PHP 7
      **/
     public function getSize(){}
 
     /**
      * Determine the type of the current DirectoryIterator item
      *
      * Determines which file type the current DirectoryIterator item belongs
      * to. One of file, link, or dir.
      *
      * @return string Returns a string representing the type of the file.
      *   May be one of file, link, or dir.
      * @since PHP 5, PHP 7
      **/
     public function getType(){}
 
     /**
      * Determine if current DirectoryIterator item is a directory
      *
      * Determines if the current DirectoryIterator item is a directory.
      *
      * @return bool Returns TRUE if it is a directory, otherwise FALSE
      * @since PHP 5, PHP 7
      **/
     public function isDir(){}
 
     /**
      * Determine if current DirectoryIterator item is '.' or '..'
      *
      * Determines if the current DirectoryIterator item is a directory and
      * either . or ..
      *
      * @return bool TRUE if the entry is . or .., otherwise FALSE
      * @since PHP 5, PHP 7
      **/
     public function isDot(){}
 
     /**
      * Determine if current DirectoryIterator item is executable
      *
      * Determines if the current DirectoryIterator item is executable.
      *
      * @return bool Returns TRUE if the entry is executable, otherwise
      *   FALSE
      * @since PHP 5, PHP 7
      **/
     public function isExecutable(){}
 
     /**
      * Determine if current DirectoryIterator item is a regular file
      *
      * Determines if the current DirectoryIterator item is a regular file.
      *
      * @return bool Returns TRUE if the file exists and is a regular file
      *   (not a link or dir), otherwise FALSE
      * @since PHP 5, PHP 7
      **/
     public function isFile(){}
 
     /**
      * Determine if current DirectoryIterator item is a symbolic link
      *
      * Determines if the current DirectoryIterator item is a symbolic link.
      *
      * @return bool Returns TRUE if the item is a symbolic link, otherwise
      *   FALSE
      * @since PHP 5, PHP 7
      **/
     public function isLink(){}
 
     /**
      * Determine if current DirectoryIterator item can be read
      *
      * Determines if the current DirectoryIterator item is readable.
      *
      * @return bool Returns TRUE if the file is readable, otherwise FALSE
      * @since PHP 5, PHP 7
      **/
     public function isReadable(){}
 
     /**
      * Determine if current DirectoryIterator item can be written to
      *
      * Determines if the current DirectoryIterator item is writable.
      *
      * @return bool Returns TRUE if the file/directory is writable,
      *   otherwise FALSE
      * @since PHP 5, PHP 7
      **/
     public function isWritable(){}
 
     /**
      * Return the key for the current DirectoryIterator item
      *
      * Get the key for the current DirectoryIterator item.
      *
      * @return string The key for the current DirectoryIterator item.
      * @since PHP 5, PHP 7
      **/
     public function key(){}
 
     /**
      * Move forward to next DirectoryIterator item
      *
      * Move forward to the next DirectoryIterator item.
      *
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function next(){}
 
     /**
      * Rewind the DirectoryIterator back to the start
      *
      * Rewind the DirectoryIterator back to the start.
      *
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function rewind(){}
 
     /**
      * Seek to a DirectoryIterator item
      *
      * Seek to a given position in the DirectoryIterator.
      *
      * @param int $position The zero-based numeric position to seek to.
      * @return void
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function seek($position){}
 
     /**
      * Check whether current DirectoryIterator position is a valid file
      *
      * Check whether current DirectoryIterator position is a valid file.
      *
      * @return bool Returns TRUE if the position is valid, otherwise FALSE
      * @since PHP 5, PHP 7
      **/
     public function valid(){}
 
     /**
      * Get file name as a string
      *
      * Get the file name of the current DirectoryIterator item.
      *
      * @return string Returns the file name of the current
      *   DirectoryIterator item.
      * @since PHP 5, PHP 7
      **/
     public function __toString(){}
 
 }
 /**
  * DivisionByZeroError is thrown when an attempt is made to divide a
  * number by zero.
  **/
 class DivisionByZeroError extends ArithmeticError {
 }
 /**
  * Exception thrown if a value does not adhere to a defined valid data
  * domain.
  **/
 class DomainException extends LogicException {
 }
 /**
  * DOMAttr represents an attribute in the DOMElement object.
  **/
 class DomAttr extends DOMNode {
     /**
      * The name of the attribute
      *
      * @var string
      **/
     public $name;
 
     /**
      * @var DOMElement
      **/
     public $ownerElement;
 
     /**
      * @var bool
      **/
     public $schemaTypeInfo;
 
     /**
      * Not implemented yet, always is NULL
      *
      * @var bool
      **/
     public $specified;
 
     /**
      * The value of the attribute
      *
      * @var string
      **/
     public $value;
 
     /**
      * Checks if attribute is a defined ID
      *
      * This function checks if the attribute is a defined ID.
      *
      * According to the DOM standard this requires a DTD which defines the
      * attribute ID to be of type ID. You need to validate your document with
      * or DOMDocument::validateOnParse before using this function.
      *
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function isId(){}
 
     /**
      * Creates a new object
      *
      * Creates a new DOMAttr object. This object is read only. It may be
      * appended to a document, but additional nodes may not be appended to
      * this node until the node is associated with a document. To create a
      * writable node, use .
      *
      * @param string $name The tag name of the attribute.
      * @param string $value The value of the attribute.
      * @since PHP 5, PHP 7
      **/
     public function __construct($name, $value){}
 
 }
 /**
  * The DOMCdataSection inherits from DOMText for textural representation
  * of CData constructs.
  **/
 class DOMCdataSection extends DOMText {
 }
 /**
  * Represents nodes with character data. No nodes directly correspond to
  * this class, but other nodes do inherit from it.
  **/
 class DomCharacterData extends DOMNode {
     /**
      * The contents of the node.
      *
      * @var string
      **/
     public $data;
 
     /**
      * The length of the contents.
      *
      * @var int
      **/
     public $length;
 
     /**
      * Append the string to the end of the character data of the node
      *
      * Append the string {@link data} to the end of the character data of the
      * node.
      *
      * @param string $data The string to append.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function appendData($data){}
 
     /**
      * Remove a range of characters from the node
      *
      * Deletes {@link count} characters starting from position {@link
      * offset}.
      *
      * @param int $offset The offset from which to start removing.
      * @param int $count The number of characters to delete. If the sum of
      *   {@link offset} and {@link count} exceeds the length, then all
      *   characters to the end of the data are deleted.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function deleteData($offset, $count){}
 
     /**
      * Insert a string at the specified 16-bit unit offset
      *
      * Inserts string {@link data} at position {@link offset}.
      *
      * @param int $offset The character offset at which to insert.
      * @param string $data The string to insert.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function insertData($offset, $data){}
 
     /**
      * Replace a substring within the DOMCharacterData node
      *
      * Replace {@link count} characters starting from position {@link offset}
      * with {@link data}.
      *
      * @param int $offset The offset from which to start replacing.
      * @param int $count The number of characters to replace. If the sum of
      *   {@link offset} and {@link count} exceeds the length, then all
      *   characters to the end of the data are replaced.
      * @param string $data The string with which the range must be
      *   replaced.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function replaceData($offset, $count, $data){}
 
     /**
      * Extracts a range of data from the node
      *
      * Returns the specified substring.
      *
      * @param int $offset Start offset of substring to extract.
      * @param int $count The number of characters to extract.
      * @return string The specified substring. If the sum of {@link offset}
      *   and {@link count} exceeds the length, then all 16-bit units to the
      *   end of the data are returned.
      * @since PHP 5, PHP 7
      **/
     public function substringData($offset, $count){}
 
 }
 /**
  * Represents comment nodes, characters delimited by .
  **/
 class DomComment extends DOMCharacterData {
     /**
      * Creates a new DOMComment object
      *
      * Creates a new DOMComment object. This object is read only. It may be
      * appended to a document, but additional nodes may not be appended to
      * this node until the node is associated with a document. To create a
      * writeable node, use .
      *
      * @param string $value The value of the comment.
      * @since PHP 5, PHP 7
      **/
     public function __construct($value){}
 
 }
 /**
  * Represents an entire HTML or XML document; serves as the root of the
  * document tree.
  **/
 class DomDocument extends DOMNode {
     /**
      * @var string
      **/
     public $actualEncoding;
 
     /**
      * Deprecated. Configuration used when {@link
      * DOMDocument::normalizeDocument} is invoked.
      *
      * @var DOMConfiguration
      **/
     public $config;
 
     /**
      * The Document Type Declaration associated with this document.
      *
      * @var DOMDocumentType
      **/
     public $doctype;
 
     /**
      * @var DOMElement
      **/
     public $documentElement;
 
     /**
      * @var string
      **/
     public $documentURI;
 
     /**
      * Encoding of the document, as specified by the XML declaration. This
      * attribute is not present in the final DOM Level 3 specification, but
      * is the only way of manipulating XML document encoding in this
      * implementation.
      *
      * @var string
      **/
     public $encoding;
 
     /**
      * @var bool
      **/
     public $formatOutput;
 
     /**
      * The DOMImplementation object that handles this document.
      *
      * @var DOMImplementation
      **/
     public $implementation;
 
     /**
      * @var bool
      **/
     public $preserveWhiteSpace;
 
     /**
      * Proprietary. Enables recovery mode, i.e. trying to parse non-well
      * formed documents. This attribute is not part of the DOM specification
      * and is specific to libxml.
      *
      * @var bool
      **/
     public $recover;
 
     /**
      * @var bool
      **/
     public $resolveExternals;
 
     /**
      * Deprecated. Whether or not the document is standalone, as specified by
      * the XML declaration, corresponds to xmlStandalone.
      *
      * @var bool
      **/
     public $standalone;
 
     /**
      * @var bool
      **/
     public $strictErrorChecking;
 
     /**
      * @var bool
      **/
     public $substituteEntities;
 
     /**
      * @var bool
      **/
     public $validateOnParse;
 
     /**
      * Deprecated. Version of XML, corresponds to xmlVersion.
      *
      * @var string
      **/
     public $version;
 
     /**
      * @var string
      **/
     public $xmlEncoding;
 
     /**
      * @var bool
      **/
     public $xmlStandalone;
 
     /**
      * @var string
      **/
     public $xmlVersion;
 
     /**
      * Create new attribute
      *
      * This function creates a new instance of class DOMAttr.
      *
      * @param string $name The name of the attribute.
      * @return DOMAttr The new DOMAttr or FALSE if an error occurred.
      * @since PHP 5, PHP 7
      **/
     public function createAttribute($name){}
 
     /**
      * Create new attribute node with an associated namespace
      *
      * This function creates a new instance of class DOMAttr.
      *
      * @param string $namespaceURI The URI of the namespace.
      * @param string $qualifiedName The tag name and prefix of the
      *   attribute, as prefix:tagname.
      * @return DOMAttr The new DOMAttr or FALSE if an error occurred.
      * @since PHP 5, PHP 7
      **/
     public function createAttributeNS($namespaceURI, $qualifiedName){}
 
     /**
      * Create new cdata node
      *
      * This function creates a new instance of class DOMCDATASection.
      *
      * @param string $data The content of the cdata.
      * @return DOMCDATASection The new DOMCDATASection or FALSE if an error
      *   occurred.
      * @since PHP 5, PHP 7
      **/
     public function createCDATASection($data){}
 
     /**
      * Create new comment node
      *
      * This function creates a new instance of class DOMComment.
      *
      * @param string $data The content of the comment.
      * @return DOMComment The new DOMComment or FALSE if an error occurred.
      * @since PHP 5, PHP 7
      **/
     public function createComment($data){}
 
     /**
      * Create new document fragment
      *
      * This function creates a new instance of class DOMDocumentFragment.
      *
      * @return DOMDocumentFragment The new DOMDocumentFragment or FALSE if
      *   an error occurred.
      * @since PHP 5, PHP 7
      **/
     public function createDocumentFragment(){}
 
     /**
      * Create new element node
      *
      * This function creates a new instance of class DOMElement.
      *
      * @param string $name The tag name of the element.
      * @param string $value The value of the element. By default, an empty
      *   element will be created. The value can also be set later with
      *   DOMElement::$nodeValue. The value is used verbatim except that the <
      *   and > entity references will escaped. Note that & has to be manually
      *   escaped; otherwise it is regarded as starting an entity reference.
      *   Also " won't be escaped.
      * @return DOMElement Returns a new instance of class DOMElement or
      *   FALSE if an error occurred.
      * @since PHP 5, PHP 7
      **/
     public function createElement($name, $value){}
 
     /**
      * Create new element node with an associated namespace
      *
      * This function creates a new element node with an associated namespace.
      *
      * @param string $namespaceURI The URI of the namespace.
      * @param string $qualifiedName The qualified name of the element, as
      *   prefix:tagname.
      * @param string $value The value of the element. By default, an empty
      *   element will be created. You can also set the value later with
      *   DOMElement::$nodeValue.
      * @return DOMElement The new DOMElement or FALSE if an error occurred.
      * @since PHP 5, PHP 7
      **/
     public function createElementNS($namespaceURI, $qualifiedName, $value){}
 
     /**
      * Create new entity reference node
      *
      * This function creates a new instance of class DOMEntityReference.
      *
      * @param string $name The content of the entity reference, e.g. the
      *   entity reference minus the leading & and the trailing ; characters.
      * @return DOMEntityReference The new DOMEntityReference or FALSE if an
      *   error occurred.
      * @since PHP 5, PHP 7
      **/
     public function createEntityReference($name){}
 
     /**
      * Creates new PI node
      *
      * This function creates a new instance of class
      * DOMProcessingInstruction.
      *
      * @param string $target The target of the processing instruction.
      * @param string $data The content of the processing instruction.
      * @return DOMProcessingInstruction The new DOMProcessingInstruction or
      *   FALSE if an error occurred.
      * @since PHP 5, PHP 7
      **/
     public function createProcessingInstruction($target, $data){}
 
     /**
      * Create new text node
      *
      * This function creates a new instance of class DOMText.
      *
      * @param string $content The content of the text.
      * @return DOMText The new DOMText or FALSE if an error occurred.
      * @since PHP 5, PHP 7
      **/
     public function createTextNode($content){}
 
     /**
      * Searches for an element with a certain id
      *
      * This function is similar to but searches for an element with a given
      * id.
      *
      * For this function to work, you will need either to set some ID
      * attributes with or a DTD which defines an attribute to be of type ID.
      * In the later case, you will need to validate your document with or
      * DOMDocument::$validateOnParse before using this function.
      *
      * @param string $elementId The unique id value for an element.
      * @return DOMElement Returns the DOMElement or NULL if the element is
      *   not found.
      * @since PHP 5, PHP 7
      **/
     public function getElementById($elementId){}
 
     /**
      * Searches for all elements with given local tag name
      *
      * This function returns a new instance of class DOMNodeList containing
      * all the elements with a given local tag name.
      *
      * @param string $name The local name (without namespace) of the tag to
      *   match on. The special value * matches all tags.
      * @return DOMNodeList A new DOMNodeList object containing all the
      *   matched elements.
      * @since PHP 5, PHP 7
      **/
     public function getElementsByTagName($name){}
 
     /**
      * Searches for all elements with given tag name in specified namespace
      *
      * Returns a DOMNodeList of all elements with a given local name and a
      * namespace URI.
      *
      * @param string $namespaceURI The namespace URI of the elements to
      *   match on. The special value * matches all namespaces.
      * @param string $localName The local name of the elements to match on.
      *   The special value * matches all local names.
      * @return DOMNodeList A new DOMNodeList object containing all the
      *   matched elements.
      * @since PHP 5, PHP 7
      **/
     public function getElementsByTagNameNS($namespaceURI, $localName){}
 
     /**
      * Import node into current document
      *
      * This function returns a copy of the node to import and associates it
      * with the current document.
      *
      * @param DOMNode $importedNode The node to import.
      * @param bool $deep If set to TRUE, this method will recursively
      *   import the subtree under the {@link importedNode}.
      * @return DOMNode The copied node or FALSE, if it cannot be copied.
      * @since PHP 5, PHP 7
      **/
     public function importNode($importedNode, $deep){}
 
     /**
      * Load XML from a file
      *
      * Loads an XML document from a file.
      *
      * @param string $filename The path to the XML document.
      * @param int $options Bitwise OR of the libxml option constants.
      * @return mixed If called statically, returns a DOMDocument.
      * @since PHP 5, PHP 7
      **/
     public function load($filename, $options){}
 
     /**
      * Load HTML from a string
      *
      * The function parses the HTML contained in the string {@link source}.
      * Unlike loading XML, HTML does not have to be well-formed to load. This
      * function may also be called statically to load and create a
      * DOMDocument object. The static invocation may be used when no
      * DOMDocument properties need to be set prior to loading.
      *
      * @param string $source The HTML string.
      * @param int $options Since PHP 5.4.0 and Libxml 2.6.0, you may also
      *   use the {@link options} parameter to specify additional Libxml
      *   parameters.
      * @return bool If called statically, returns a DOMDocument.
      * @since PHP 5, PHP 7
      **/
     public function loadHTML($source, $options){}
 
     /**
      * Load HTML from a file
      *
      * The function parses the HTML document in the file named {@link
      * filename}. Unlike loading XML, HTML does not have to be well-formed to
      * load.
      *
      * @param string $filename The path to the HTML file.
      * @param int $options Since PHP 5.4.0 and Libxml 2.6.0, you may also
      *   use the {@link options} parameter to specify additional Libxml
      *   parameters.
      * @return bool If called statically, returns a DOMDocument.
      * @since PHP 5, PHP 7
      **/
     public function loadHTMLFile($filename, $options){}
 
     /**
      * Load XML from a string
      *
      * Loads an XML document from a string.
      *
      * @param string $source The string containing the XML.
      * @param int $options Bitwise OR of the libxml option constants.
      * @return mixed If called statically, returns a DOMDocument.
      * @since PHP 5, PHP 7
      **/
     public function loadXML($source, $options){}
 
     /**
      * Normalizes the document
      *
      * This method acts as if you saved and then loaded the document, putting
      * the document in a "normal" form.
      *
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function normalizeDocument(){}
 
     /**
      * Register extended class used to create base node type
      *
      * This method allows you to register your own extended DOM class to be
      * used afterward by the PHP DOM extension.
      *
      * This method is not part of the DOM standard.
      *
      * @param string $baseclass The DOM class that you want to extend. You
      *   can find a list of these classes in the chapter introduction.
      * @param string $extendedclass Your extended class name. If NULL is
      *   provided, any previously registered class extending {@link
      *   baseclass} will be removed.
      * @return bool
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function registerNodeClass($baseclass, $extendedclass){}
 
     /**
      * Performs relaxNG validation on the document
      *
      * Performs relaxNG validation on the document based on the given RNG
      * schema.
      *
      * @param string $filename The RNG file.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function relaxNGValidate($filename){}
 
     /**
      * Performs relaxNG validation on the document
      *
      * Performs relaxNG validation on the document based on the given RNG
      * source.
      *
      * @param string $source A string containing the RNG schema.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function relaxNGValidateSource($source){}
 
     /**
      * Dumps the internal XML tree back into a file
      *
      * Creates an XML document from the DOM representation. This function is
      * usually called after building a new dom document from scratch as in
      * the example below.
      *
      * @param string $filename The path to the saved XML document.
      * @param int $options Additional Options. Currently only
      *   LIBXML_NOEMPTYTAG is supported.
      * @return int Returns the number of bytes written or FALSE if an error
      *   occurred.
      * @since PHP 5, PHP 7
      **/
     public function save($filename, $options){}
 
     /**
      * Dumps the internal document into a string using HTML formatting
      *
      * Creates an HTML document from the DOM representation. This function is
      * usually called after building a new dom document from scratch as in
      * the example below.
      *
      * @param DOMNode $node Optional parameter to output a subset of the
      *   document.
      * @return string Returns the HTML, or FALSE if an error occurred.
      * @since PHP 5, PHP 7
      **/
     public function saveHTML($node){}
 
     /**
      * Dumps the internal document into a file using HTML formatting
      *
      * Creates an HTML document from the DOM representation. This function is
      * usually called after building a new dom document from scratch as in
      * the example below.
      *
      * @param string $filename The path to the saved HTML document.
      * @return int Returns the number of bytes written or FALSE if an error
      *   occurred.
      * @since PHP 5, PHP 7
      **/
     public function saveHTMLFile($filename){}
 
     /**
      * Dumps the internal XML tree back into a string
      *
      * Creates an XML document from the DOM representation. This function is
      * usually called after building a new dom document from scratch as in
      * the example below.
      *
      * @param DOMNode $node Use this parameter to output only a specific
      *   node without XML declaration rather than the entire document.
      * @param int $options Additional Options. Currently only
      *   LIBXML_NOEMPTYTAG is supported.
      * @return string Returns the XML, or FALSE if an error occurred.
      * @since PHP 5, PHP 7
      **/
     public function saveXML($node, $options){}
 
     /**
      * Validates a document based on a schema
      *
      * Validates a document based on the given schema file.
      *
      * @param string $filename The path to the schema.
      * @param int $flags A bitmask of Libxml schema validation flags.
      *   Currently the only supported value is LIBXML_SCHEMA_CREATE.
      *   Available since PHP 5.5.2 and Libxml 2.6.14.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function schemaValidate($filename, $flags){}
 
     /**
      * Validates a document based on a schema
      *
      * Validates a document based on a schema defined in the given string.
      *
      * @param string $source A string containing the schema.
      * @param int $flags A bitmask of Libxml schema validation flags.
      *   Currently the only supported value is LIBXML_SCHEMA_CREATE.
      *   Available since PHP 5.5.2 and Libxml 2.6.14.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function schemaValidateSource($source, $flags){}
 
     /**
      * Validates the document based on its DTD
      *
      * Validates the document based on its DTD.
      *
      * You can also use the validateOnParse property of DOMDocument to make a
      * DTD validation.
      *
      * @return bool If the document has no DTD attached, this method will
      *   return FALSE.
      * @since PHP 5, PHP 7
      **/
     public function validate(){}
 
     /**
      * Substitutes XIncludes in a DOMDocument Object
      *
      * This method substitutes XIncludes in a DOMDocument object.
      *
      * @param int $options libxml parameters. Available since PHP 5.1.0 and
      *   Libxml 2.6.7.
      * @return int Returns the number of XIncludes in the document, -1 if
      *   some processing failed, or FALSE if there were no substitutions.
      * @since PHP 5, PHP 7
      **/
     public function xinclude($options){}
 
     /**
      * Creates a new DOMDocument object
      *
      * Creates a new DOMDocument object.
      *
      * @param string $version The version number of the document as part of
      *   the XML declaration.
      * @param string $encoding The encoding of the document as part of the
      *   XML declaration.
      * @since PHP 5, PHP 7
      **/
     public function __construct($version, $encoding){}
 
 }
 class DOMDocumentFragment extends DOMNode {
     /**
      * Append raw XML data
      *
      * Appends raw XML data to a DOMDocumentFragment.
      *
      * This method is not part of the DOM standard. It was created as a
      * simpler approach for appending an XML DocumentFragment in a
      * DOMDocument.
      *
      * If you want to stick to the standards, you will have to create a
      * temporary DOMDocument with a dummy root and then loop through the
      * child nodes of the root of your XML data to append them.
      *
      * @param string $data XML to append.
      * @return bool
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function appendXML($data){}
 
 }
 /**
  * Each DOMDocument has a doctype attribute whose value is either NULL or
  * a DOMDocumentType object.
  **/
 class DOMDocumentType extends DOMNode {
     /**
      * A DOMNamedNodeMap containing the general entities, both external and
      * internal, declared in the DTD.
      *
      * @var DOMNamedNodeMap
      **/
     public $entities;
 
     /**
      * @var string
      **/
     public $internalSubset;
 
     /**
      * The name of DTD; i.e., the name immediately following the DOCTYPE
      * keyword.
      *
      * @var string
      **/
     public $name;
 
     /**
      * A DOMNamedNodeMap containing the notations declared in the DTD.
      *
      * @var DOMNamedNodeMap
      **/
     public $notations;
 
     /**
      * @var string
      **/
     public $publicId;
 
     /**
      * @var string
      **/
     public $systemId;
 
 }
 class DomElement extends DOMNode {
     /**
      * Returns value of attribute
      *
      * Gets the value of the attribute with name {@link name} for the current
      * node.
      *
      * @param string $name The name of the attribute.
      * @return string The value of the attribute, or an empty string if no
      *   attribute with the given {@link name} is found.
      * @since PHP 5, PHP 7
      **/
     public function getAttribute($name){}
 
     /**
      * Returns attribute node
      *
      * Returns the attribute node with name {@link name} for the current
      * element.
      *
      * @param string $name The name of the attribute.
      * @return DOMAttr The attribute node. Note that for XML namespace
      *   declarations (xmlns and xmlns:* attributes) an instance of
      *   DOMNameSpaceNode is returned instead of a DOMAttr.
      * @since PHP 5, PHP 7
      **/
     public function getAttributeNode($name){}
 
     /**
      * Returns attribute node
      *
      * Returns the attribute node in namespace {@link namespaceURI} with
      * local name {@link localName} for the current node.
      *
      * @param string $namespaceURI The namespace URI.
      * @param string $localName The local name.
      * @return DOMAttr The attribute node. Note that for XML namespace
      *   declarations (xmlns and xmlns:* attributes) an instance of
      *   DOMNameSpaceNode is returned instead of a DOMAttr object.
      * @since PHP 5, PHP 7
      **/
     public function getAttributeNodeNS($namespaceURI, $localName){}
 
     /**
      * Returns value of attribute
      *
      * Gets the value of the attribute in namespace {@link namespaceURI} with
      * local name {@link localName} for the current node.
      *
      * @param string $namespaceURI The namespace URI.
      * @param string $localName The local name.
      * @return string The value of the attribute, or an empty string if no
      *   attribute with the given {@link localName} and {@link namespaceURI}
      *   is found.
      * @since PHP 5, PHP 7
      **/
     public function getAttributeNS($namespaceURI, $localName){}
 
     /**
      * Gets elements by tagname
      *
      * This function returns a new instance of the class DOMNodeList of all
      * descendant elements with a given tag {@link name}, in the order in
      * which they are encountered in a preorder traversal of this element
      * tree.
      *
      * @param string $name The tag name. Use * to return all elements
      *   within the element tree.
      * @return DOMNodeList This function returns a new instance of the
      *   class DOMNodeList of all matched elements.
      * @since PHP 5, PHP 7
      **/
     public function getElementsByTagName($name){}
 
     /**
      * Get elements by namespaceURI and localName
      *
      * This function fetch all the descendant elements with a given {@link
      * localName} and {@link namespaceURI}.
      *
      * @param string $namespaceURI The namespace URI.
      * @param string $localName The local name. Use * to return all
      *   elements within the element tree.
      * @return DOMNodeList This function returns a new instance of the
      *   class DOMNodeList of all matched elements in the order in which they
      *   are encountered in a preorder traversal of this element tree.
      * @since PHP 5, PHP 7
      **/
     public function getElementsByTagNameNS($namespaceURI, $localName){}
 
     /**
      * Checks to see if attribute exists
      *
      * Indicates whether attribute named {@link name} exists as a member of
      * the element.
      *
      * @param string $name The attribute name.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function hasAttribute($name){}
 
     /**
      * Checks to see if attribute exists
      *
      * Indicates whether attribute in namespace {@link namespaceURI} named
      * {@link localName} exists as a member of the element.
      *
      * @param string $namespaceURI The namespace URI.
      * @param string $localName The local name.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function hasAttributeNS($namespaceURI, $localName){}
 
     /**
      * Removes attribute
      *
      * Removes attribute named {@link name} from the element.
      *
      * @param string $name The name of the attribute.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function removeAttribute($name){}
 
     /**
      * Removes attribute
      *
      * Removes attribute {@link oldnode} from the element.
      *
      * @param DOMAttr $oldnode The attribute node.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function removeAttributeNode($oldnode){}
 
     /**
      * Removes attribute
      *
      * Removes attribute {@link localName} in namespace {@link namespaceURI}
      * from the element.
      *
      * @param string $namespaceURI The namespace URI.
      * @param string $localName The local name.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function removeAttributeNS($namespaceURI, $localName){}
 
     /**
      * Adds new attribute
      *
      * Sets an attribute with name {@link name} to the given value. If the
      * attribute does not exist, it will be created.
      *
      * @param string $name The name of the attribute.
      * @param string $value The value of the attribute.
      * @return DOMAttr The new DOMAttr or FALSE if an error occurred.
      * @since PHP 5, PHP 7
      **/
     public function setAttribute($name, $value){}
 
     /**
      * Adds new attribute node to element
      *
      * Adds new attribute node {@link attr} to element.
      *
      * @param DOMAttr $attr The attribute node.
      * @return DOMAttr Returns old node if the attribute has been replaced
      *   or NULL.
      * @since PHP 5, PHP 7
      **/
     public function setAttributeNode($attr){}
 
     /**
      * Adds new attribute node to element
      *
      * Adds new attribute node {@link attr} to element.
      *
      * @param DOMAttr $attr The attribute node.
      * @return DOMAttr Returns the old node if the attribute has been
      *   replaced.
      * @since PHP 5, PHP 7
      **/
     public function setAttributeNodeNS($attr){}
 
     /**
      * Adds new attribute
      *
      * Sets an attribute with namespace {@link namespaceURI} and name {@link
      * name} to the given value. If the attribute does not exist, it will be
      * created.
      *
      * @param string $namespaceURI The namespace URI.
      * @param string $qualifiedName The qualified name of the attribute, as
      *   prefix:tagname.
      * @param string $value The value of the attribute.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function setAttributeNS($namespaceURI, $qualifiedName, $value){}
 
     /**
      * Declares the attribute specified by name to be of type ID
      *
      * Declares the attribute {@link name} to be of type ID.
      *
      * @param string $name The name of the attribute.
      * @param bool $isId Set it to TRUE if you want {@link name} to be of
      *   type ID, FALSE otherwise.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function setIdAttribute($name, $isId){}
 
     /**
      * Declares the attribute specified by node to be of type ID
      *
      * Declares the attribute specified by {@link attr} to be of type ID.
      *
      * @param DOMAttr $attr The attribute node.
      * @param bool $isId Set it to TRUE if you want {@link name} to be of
      *   type ID, FALSE otherwise.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function setIdAttributeNode($attr, $isId){}
 
     /**
      * Declares the attribute specified by local name and namespace URI to be
      * of type ID
      *
      * Declares the attribute specified by {@link localName} and {@link
      * namespaceURI} to be of type ID.
      *
      * @param string $namespaceURI The namespace URI of the attribute.
      * @param string $localName The local name of the attribute, as
      *   prefix:tagname.
      * @param bool $isId Set it to TRUE if you want {@link name} to be of
      *   type ID, FALSE otherwise.
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function setIdAttributeNS($namespaceURI, $localName, $isId){}
 
     /**
      * Creates a new DOMElement object
      *
      * Creates a new DOMElement object. This object is read only. It may be
      * appended to a document, but additional nodes may not be appended to
      * this node until the node is associated with a document. To create a
      * writeable node, use or .
      *
      * @param string $name The tag name of the element. When also passing
      *   in namespaceURI, the element name may take a prefix to be associated
      *   with the URI.
      * @param string $value The value of the element.
      * @param string $namespaceURI A namespace URI to create the element
      *   within a specific namespace.
      * @since PHP 5, PHP 7
      **/
     public function __construct($name, $value, $namespaceURI){}
 
 }
 /**
  * This interface represents a known entity, either parsed or unparsed,
  * in an XML document.
  **/
 class DOMEntity extends DOMNode {
     /**
      * @var string
      **/
     public $actualEncoding;
 
     /**
      * An attribute specifying, as part of the text declaration, the encoding
      * of this entity, when it is an external parsed entity. This is NULL
      * otherwise.
      *
      * @var string
      **/
     public $encoding;
 
     /**
      * @var string
      **/
     public $notationName;
 
     /**
      * @var string
      **/
     public $publicId;
 
     /**
      * @var string
      **/
     public $systemId;
 
     /**
      * An attribute specifying, as part of the text declaration, the version
      * number of this entity, when it is an external parsed entity. This is
      * NULL otherwise.
      *
      * @var string
      **/
     public $version;
 
 }
 class DomEntityReference extends DOMNode {
     /**
      * Creates a new DOMEntityReference object
      *
      * Creates a new DOMEntityReference object.
      *
      * @param string $name The name of the entity reference.
      * @since PHP 5, PHP 7
      **/
     public function __construct($name){}
 
 }
 /**
  * DOM operations raise exceptions under particular circumstances, i.e.,
  * when an operation is impossible to perform for logical reasons. See
  * also .
  **/
 class DOMException extends Exception {
     /**
      * An integer indicating the type of error generated
      *
      * @var int
      **/
     public $code;
 
 }
 /**
  * The DOMImplementation class provides a number of methods for
  * performing operations that are independent of any particular instance
  * of the document object model.
  **/
 class DOMImplementation {
     /**
      * Creates a DOMDocument object of the specified type with its document
      * element
      *
      * Creates a DOMDocument object of the specified type with its document
      * element.
      *
      * @param string $namespaceURI The namespace URI of the document
      *   element to create.
      * @param string $qualifiedName The qualified name of the document
      *   element to create.
      * @param DOMDocumentType $doctype The type of document to create or
      *   NULL.
      * @return DOMDocument A new DOMDocument object. If {@link
      *   namespaceURI}, {@link qualifiedName}, and {@link doctype} are null,
      *   the returned DOMDocument is empty with no document element
      * @since PHP 5, PHP 7
      **/
     public function createDocument($namespaceURI, $qualifiedName, $doctype){}
 
     /**
      * Creates an empty DOMDocumentType object
      *
      * Creates an empty DOMDocumentType object. Entity declarations and
      * notations are not made available. Entity reference expansions and
      * default attribute additions do not occur.
      *
      * @param string $qualifiedName The qualified name of the document type
      *   to create.
      * @param string $publicId The external subset public identifier.
      * @param string $systemId The external subset system identifier.
      * @return DOMDocumentType A new DOMDocumentType node with its
      *   ownerDocument set to NULL.
      * @since PHP 5, PHP 7
      **/
     public function createDocumentType($qualifiedName, $publicId, $systemId){}
 
     /**
      * Test if the DOM implementation implements a specific feature
      *
      * Test if the DOM implementation implements a specific {@link feature}.
      *
      * You can find a list of all features in the Conformance section of the
      * DOM specification.
      *
      * @param string $feature The feature to test.
      * @param string $version The version number of the {@link feature} to
      *   test. In level 2, this can be either 2.0 or 1.0.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function hasFeature($feature, $version){}
 
     /**
      * Creates a new DOMImplementation object
      *
      * Creates a new DOMImplementation object.
      *
      * @since PHP 5, PHP 7
      **/
     function __construct(){}
 
 }
 class DomNamedNodeMap implements Traversable, Countable {
     /**
      * Get number of nodes in the map
      *
      * Gets the number of nodes in the map.
      *
      * @return int Returns the number of nodes in the map, which is
      *   identical to the length property.
      * @since PHP 7 >= 7.2.0
      **/
     public function count(){}
 
     /**
      * Retrieves a node specified by name
      *
      * Retrieves a node specified by its nodeName.
      *
      * @param string $name The nodeName of the node to retrieve.
      * @return DOMNode A node (of any type) with the specified nodeName, or
      *   NULL if no node is found.
      * @since PHP 5, PHP 7
      **/
     function getNamedItem($name){}
 
     /**
      * Retrieves a node specified by local name and namespace URI
      *
      * Retrieves a node specified by {@link localName} and {@link
      * namespaceURI}.
      *
      * @param string $namespaceURI The namespace URI of the node to
      *   retrieve.
      * @param string $localName The local name of the node to retrieve.
      * @return DOMNode A node (of any type) with the specified local name
      *   and namespace URI, or NULL if no node is found.
      * @since PHP 5, PHP 7
      **/
     function getNamedItemNS($namespaceURI, $localName){}
 
     /**
      * Retrieves a node specified by index
      *
      * Retrieves a node specified by {@link index} within the DOMNamedNodeMap
      * object.
      *
      * @param int $index Index into this map.
      * @return DOMNode The node at the {@link index}th position in the map,
      *   or NULL if that is not a valid index (greater than or equal to the
      *   number of nodes in this map).
      * @since PHP 5, PHP 7
      **/
     function item($index){}
 
 }
 class DOMNode {
     /**
      * Adds new child at the end of the children
      *
      * This function appends a child to an existing list of children or
      * creates a new list of children. The child can be created with e.g.
      * DOMDocument::createElement, DOMDocument::createTextNode etc. or simply
      * by using any other node.
      *
      * @param DOMNode $newnode The appended child.
      * @return DOMNode The node added.
      * @since PHP 5, PHP 7
      **/
     public function appendChild($newnode){}
 
     /**
      * Canonicalize nodes to a string
      *
      * @param bool $exclusive Enable exclusive parsing of only the nodes
      *   matched by the provided xpath or namespace prefixes.
      * @param bool $with_comments Retain comments in output.
      * @param array $xpath An array of xpaths to filter the nodes by.
      * @param array $ns_prefixes An array of namespace prefixes to filter
      *   the nodes by.
      * @return string Returns canonicalized nodes as a string
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function C14N($exclusive, $with_comments, $xpath, $ns_prefixes){}
 
     /**
      * Canonicalize nodes to a file
      *
      * @param string $uri Path to write the output to.
      * @param bool $exclusive Enable exclusive parsing of only the nodes
      *   matched by the provided xpath or namespace prefixes.
      * @param bool $with_comments Retain comments in output.
      * @param array $xpath An array of xpaths to filter the nodes by.
      * @param array $ns_prefixes An array of namespace prefixes to filter
      *   the nodes by.
      * @return int Number of bytes written
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function C14NFile($uri, $exclusive, $with_comments, $xpath, $ns_prefixes){}
 
     /**
      * Clones a node
      *
      * Creates a copy of the node.
      *
      * @param bool $deep Indicates whether to copy all descendant nodes.
      *   This parameter is defaulted to FALSE.
      * @return DOMNode The cloned node.
      * @since PHP 5, PHP 7
      **/
     public function cloneNode($deep){}
 
     /**
      * Get line number for a node
      *
      * Gets line number for where the node is defined.
      *
      * @return int Always returns the line number where the node was
      *   defined in.
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function getLineNo(){}
 
     /**
      * Get an XPath for a node
      *
      * Gets an XPath location path for the node.
      *
      * @return string Returns a string containing the XPath, or NULL in
      *   case of an error.
      * @since PHP 5 >= 5.2.0, PHP 7
      **/
     public function getNodePath(){}
 
     /**
      * Checks if node has attributes
      *
      * This method checks if the node has attributes. The tested node has to
      * be an XML_ELEMENT_NODE.
      *
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function hasAttributes(){}
 
     /**
      * Checks if node has children
      *
      * This function checks if the node has children.
      *
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function hasChildNodes(){}
 
     /**
      * Adds a new child before a reference node
      *
      * This function inserts a new node right before the reference node. If
      * you plan to do further modifications on the appended child you must
      * use the returned node.
      *
      * @param DOMNode $newnode The new node.
      * @param DOMNode $refnode The reference node. If not supplied, {@link
      *   newnode} is appended to the children.
      * @return DOMNode The inserted node.
      * @since PHP 5, PHP 7
      **/
     public function insertBefore($newnode, $refnode){}
 
     /**
      * Checks if the specified namespaceURI is the default namespace or not
      *
      * Tells whether {@link namespaceURI} is the default namespace.
      *
      * @param string $namespaceURI The namespace URI to look for.
      * @return bool Return TRUE if {@link namespaceURI} is the default
      *   namespace, FALSE otherwise.
      * @since PHP 5, PHP 7
      **/
     public function isDefaultNamespace($namespaceURI){}
 
     /**
      * Indicates if two nodes are the same node
      *
      * This function indicates if two nodes are the same node. The comparison
      * is not based on content
      *
      * @param DOMNode $node The compared node.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function isSameNode($node){}
 
     /**
      * Checks if feature is supported for specified version
      *
      * Checks if the asked {@link feature} is supported for the specified
      * {@link version}.
      *
      * @param string $feature The feature to test. See the example of
      *   DOMImplementation::hasFeature for a list of features.
      * @param string $version The version number of the {@link feature} to
      *   test.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function isSupported($feature, $version){}
 
     /**
      * Gets the namespace URI of the node based on the prefix
      *
      * Gets the namespace URI of the node based on the {@link prefix}.
      *
      * @param string $prefix The prefix of the namespace.
      * @return string The namespace URI of the node.
      * @since PHP 5, PHP 7
      **/
     public function lookupNamespaceUri($prefix){}
 
     /**
      * Gets the namespace prefix of the node based on the namespace URI
      *
      * Gets the namespace prefix of the node based on the namespace URI.
      *
      * @param string $namespaceURI The namespace URI.
      * @return string The prefix of the namespace.
      * @since PHP 5, PHP 7
      **/
     public function lookupPrefix($namespaceURI){}
 
     /**
      * Normalizes the node
      *
      * Remove empty text nodes and merge adjacent text nodes in this node and
      * all its children.
      *
      * @return void
      * @since PHP 5, PHP 7
      **/
     public function normalize(){}
 
     /**
      * Removes child from list of children
      *
      * This functions removes a child from a list of children.
      *
      * @param DOMNode $oldnode The removed child.
      * @return DOMNode If the child could be removed the function returns
      *   the old child.
      * @since PHP 5, PHP 7
      **/
     public function removeChild($oldnode){}
 
     /**
      * Replaces a child
      *
      * This function replaces the child {@link oldnode} with the passed new
      * node. If the {@link newnode} is already a child it will not be added a
      * second time. If the replacement succeeds the old node is returned.
      *
      * @param DOMNode $newnode The new node. It must be a member of the
      *   target document, i.e. created by one of the DOMDocument->createXXX()
      *   methods or imported in the document by .
      * @param DOMNode $oldnode The old node.
      * @return DOMNode The old node or FALSE if an error occur.
      * @since PHP 5, PHP 7
      **/
     public function replaceChild($newnode, $oldnode){}
 
 }
 /**
  * 7.2.0 The Countable interface is implemented and returns the value of
  * the length property.
  **/
 class DomNodeList implements Traversable, Countable {
     /**
      * Get number of nodes in the list
      *
      * Gets the number of nodes in the list.
      *
      * @return int Returns the number of nodes in the list, which is
      *   identical to the length property.
      * @since PHP 7 >= 7.2.0
      **/
     public function count(){}
 
     /**
      * Retrieves a node specified by index
      *
      * Retrieves a node specified by {@link index} within the DOMNodeList
      * object.
      *
      * @param int $index Index of the node into the collection.
      * @return DOMNode The node at the {@link index}th position in the
      *   DOMNodeList, or NULL if that is not a valid index.
      * @since PHP 5, PHP 7
      **/
     function item($index){}
 
 }
 class DOMNotation extends DOMNode {
 }
 class DomProcessingInstruction extends DOMNode {
     /**
      * Creates a new object
      *
      * Creates a new DOMProcessingInstruction object. This object is read
      * only. It may be appended to a document, but additional nodes may not
      * be appended to this node until the node is associated with a document.
      * To create a writeable node, use .
      *
      * @param string $name The tag name of the processing instruction.
      * @param string $value The value of the processing instruction.
      * @since PHP 5, PHP 7
      **/
     public function __construct($name, $value){}
 
 }
 /**
  * The DOMText class inherits from DOMCharacterData and represents the
  * textual content of a DOMElement or DOMAttr.
  **/
 class DOMText extends DOMCharacterData {
     /**
      * @var string
      **/
     public $wholeText;
 
     /**
      * Returns whether this text node contains whitespace in element content
      *
      * @return bool
      **/
     public function isElementContentWhitespace(){}
 
     /**
      * Indicates whether this text node contains whitespace
      *
      * Indicates whether this text node contains only whitespace or it is
      * empty. The text node is determined to contain whitespace in element
      * content during the load of the document.
      *
      * @return bool Returns TRUE if node contains zero or more whitespace
      *   characters and nothing else. Returns FALSE otherwise.
      * @since PHP 5, PHP 7
      **/
     public function isWhitespaceInElementContent(){}
 
     /**
      * Breaks this node into two nodes at the specified offset
      *
      * Breaks this node into two nodes at the specified {@link offset},
      * keeping both in the tree as siblings.
      *
      * After being split, this node will contain all the content up to the
      * {@link offset}. If the original node had a parent node, the new node
      * is inserted as the next sibling of the original node. When the {@link
      * offset} is equal to the length of this node, the new node has no data.
      *
      * @param int $offset The offset at which to split, starting from 0.
      * @return DOMText The new node of the same type, which contains all
      *   the content at and after the {@link offset}.
      * @since PHP 5, PHP 7
      **/
     public function splitText($offset){}
 
 }
 /**
  * Supports XPath 1.0
  **/
 class DomXPath {
     /**
      * @var DOMDocument
      **/
     public $document;
 
     /**
      * Evaluates the given XPath expression and returns a typed result if
      * possible
      *
      * Executes the given XPath {@link expression} and returns a typed result
      * if possible.
      *
      * @param string $expression The XPath expression to execute.
      * @param DOMNode $contextnode The optional {@link contextnode} can be
      *   specified for doing relative XPath queries. By default, the queries
      *   are relative to the root element.
      * @param bool $registerNodeNS The optional {@link registerNodeNS} can
      *   be specified to disable automatic registration of the context node.
      * @return mixed Returns a typed result if possible or a DOMNodeList
      *   containing all nodes matching the given XPath {@link expression}.
      * @since PHP 5 >= 5.1.0, PHP 7
      **/
     public function evaluate($expression, $contextnode, $registerNodeNS){}
 
     /**
      * Evaluates the given XPath expression
      *
      * Executes the given XPath {@link expression}.
      *
      * @param string $expression The XPath expression to execute.
      * @param DOMNode $contextnode The optional {@link contextnode} can be
      *   specified for doing relative XPath queries. By default, the queries
      *   are relative to the root element.
      * @param bool $registerNodeNS The optional {@link registerNodeNS} can
      *   be specified to disable automatic registration of the context node.
      * @return DOMNodeList Returns a DOMNodeList containing all nodes
      *   matching the given XPath {@link expression}. Any expression which
      *   does not return nodes will return an empty DOMNodeList.
      * @since PHP 5, PHP 7
      **/
     public function query($expression, $contextnode, $registerNodeNS){}
 
     /**
      * Registers the namespace with the object
      *
      * Registers the {@link namespaceURI} and {@link prefix} with the
      * DOMXPath object.
      *
      * @param string $prefix The prefix.
      * @param string $namespaceURI The URI of the namespace.
      * @return bool
      * @since PHP 5, PHP 7
      **/
     public function registerNamespace($prefix, $namespaceURI){}
 
     /**
      * Register PHP functions as XPath functions
      *
      * This method enables the ability to use PHP functions within XPath
      * expressions.
      *
      * @param mixed $restrict Use this parameter to only allow certain
      *   functions to be called from XPath. This parameter can be either a
      *   string (a function name) or an array of function names.
      * @return void
      * @since PHP 5 >= 5.3.0, PHP 7
      **/
     public function registerPhpFunctions($restrict){}
 
     /**
      * Creates a new object
      *
      * Creates a new DOMXPath object.
      *
      * @param DOMDocument $doc The DOMDocument associated with the
      *   DOMXPath.
      * @since PHP 5, PHP 7
      **/
     public function __construct($doc){}
 
 }
 /**
  * The dotnet class allows you to instantiate a class from a .Net
  * assembly and call its methods and access its properties, if the class
  * and the methods and properties are visible to COM. Neither
  * instantiating static classes nor calling static methods is supported.
  * Some .Net classes do not implement IDispatch, so while they can be
  * instantiated, calling methods or accessing properties on these classes
  * is not supported.
  **/
 class dotnet extends variant {
 }
 namespace Ds {
 interface Collection extends Traversable, Countable, JsonSerializable {
     /**
      * Removes all values
      *
      * Removes all values from the collection.
      *
      * @return void
      **/
     public function clear();
 
     /**
      * Returns a shallow copy of the collection
      *
      * @return Ds\Collection Returns a shallow copy of the collection.
      **/
     public function copy();
 
     /**
      * Returns whether the collection is empty
      *
      * @return bool Returns TRUE if the collection is empty, FALSE
      *   otherwise.
      **/
     public function isEmpty();
 
     /**
      * Converts the collection to an
      *
      * Converts the collection to an .
      *
      * @return array An containing all the values in the same order as the
      *   collection.
      **/
     public function toArray();
 
 }
 }
 namespace Ds {
 class Deque implements Ds\Sequence {
     /**
      * Allocates enough memory for a required capacity
      *
      * Ensures that enough memory is allocated for a required capacity. This
      * removes the need to reallocate the internal as values are added.
      *
      * @param int $capacity The number of values for which capacity should
      *   be allocated.
      * @return void
      **/
     public function allocate($capacity){}
 
     /**
      * Updates all values by applying a callback function to each value
      *
      * Updates all values by applying a {@link callback} function to each
      * value in the deque.
      *
      * @param callable $callback mixed callback mixed{@link value} A
      *   callable to apply to each value in the deque. The callback should
      *   return what the value should be replaced by.
      * @return void
      **/
     public function apply($callback){}
 
     /**
      * Returns the current capacity
      *
      * @return int The current capacity.
      **/
     public function capacity(){}
 
     /**
      * Removes all values from the deque
      *
      * @return void
      **/
     public function clear(){}
 
     /**
      * Determines if the deque contains given values
      *
      * Determines if the deque contains all values.
      *
      * @param mixed ...$values Values to check.
      * @return bool FALSE if any of the provided {@link values} are not in
      *   the deque, TRUE otherwise.
      **/
     public function contains(...$values){}
 
     /**
      * Returns a shallow copy of the deque
      *
      * @return Ds\Deque A shallow copy of the deque.
      **/
     public function copy(){}
 
     /**
      * Creates a new deque using a to determine which values to include
      *
      * Creates a new deque using a callable to determine which values to
      * include.
      *
      * @param callable $callback bool callback mixed{@link value} Optional
      *   callable which returns TRUE if the value should be included, FALSE
      *   otherwise. If a callback is not provided, only values which are TRUE
      *   (see converting to boolean) will be included.
      * @return Ds\Deque A new deque containing all the values for which
      *   either the {@link callback} returned TRUE, or all values that
      *   convert to TRUE if a {@link callback} was not provided.
      **/
     public function filter($callback){}
 
     /**
      * Attempts to find a value's index
      *
      * Returns the index of the {@link value}, or FALSE if not found.
      *
      * @param mixed $value The value to find.
      * @return mixed The index of the value, or FALSE if not found.
      **/
     public function find($value){}
 
     /**
      * Returns the first value in the deque
      *
      * @return mixed The first value in the deque.
      **/
     public function first(){}
 
     /**
      * Returns the value at a given index
      *
      * @param int $index The index to access, starting at 0.
      * @return mixed The value at the requested index.
      **/
     public function get($index){}
 
     /**
      * Inserts values at a given index
      *
      * Inserts values into the deque at a given index.
      *
      * @param int $index The index at which to insert. 0 <= index <= count
      * @param mixed ...$values The value or values to insert.
      * @return void
      **/
     public function insert($index, ...$values){}
 
     /**
      * Returns whether the deque is empty
      *
      * @return bool Returns TRUE if the deque is empty, FALSE otherwise.
      **/
     public function isEmpty(){}
 
     /**
      * Joins all values together as a string
      *
      * Joins all values together as a string using an optional separator
      * between each value.
      *
      * @param string $glue An optional string to separate each value.
      * @return string All values of the deque joined together as a string.
      **/
     public function join($glue){}
 
     /**
      * Returns the last value
      *
      * Returns the last value in the deque.
      *
      * @return mixed The last value in the deque.
      **/
     public function last(){}
 
     /**
      * Returns the result of applying a callback to each value
      *
      * Returns the result of applying a {@link callback} function to each
      * value in the deque.
      *
      * @param callable $callback mixed callback mixed{@link value} A
      *   callable to apply to each value in the deque. The callable should
      *   return what the new value will be in the new deque.
      * @return Ds\Deque The result of applying a {@link callback} to each
      *   value in the deque.
      **/
     public function map($callback){}
 
     /**
      * Returns the result of adding all given values to the deque
      *
      * @param mixed $values A traversable object or an .
      * @return Ds\Deque The result of adding all given values to the deque,
      *   effectively the same as adding the values to a copy, then returning
      *   that copy.
      **/
     public function merge($values){}
 
     /**
      * Removes and returns the last value
      *
      * @return mixed The removed last value.
      **/
     public function pop(){}
 
     /**
      * Adds values to the end of the deque
      *
      * @param mixed ...$values The values to add.
      * @return void
      **/
     public function push(...$values){}
 
     /**
      * Reduces the deque to a single value using a callback function
      *
      * @param callable $callback
      * @param mixed $initial The return value of the previous callback, or
      *   {@link initial} if it's the first iteration.
      * @return mixed The return value of the final callback.
      **/
     public function reduce($callback, $initial){}
 
     /**
      * Removes and returns a value by index
      *
      * @param int $index The index of the value to remove.
      * @return mixed The value that was removed.
      **/
     public function remove($index){}
 
     /**
      * Reverses the deque in-place
      *
      * Reverses the deque in-place.
      *
      * @return void
      **/
     public function reverse(){}
 
     /**
      * Returns a reversed copy
      *
      * Returns a reversed copy of the deque.
      *
      * @return Ds\Deque A reversed copy of the deque.
      *   
      *   The current instance is not affected.
      **/
     public function reversed(){}
 
     /**
      * Rotates the deque by a given number of rotations
      *
      * Rotates the deque by a given number of rotations, which is equivalent
      * to successively calling $deque->push($deque->shift()) if the number of
      * rotations is positive, or $deque->unshift($deque->pop()) if negative.
      *
      * @param int $rotations The number of times the deque should be
      *   rotated.
      * @return void . The deque of the current instance will be rotated.
      **/
     public function rotate($rotations){}
 
     /**
      * Updates a value at a given index
      *
      * @param int $index The index of the value to update.
      * @param mixed $value The new value.
      * @return void
      **/
     public function set($index, $value){}
 
     /**
      * Removes and returns the first value
      *
      * @return mixed The first value, which was removed.
      **/
     public function shift(){}
 
     /**
      * Returns a sub-deque of a given range
      *
      * Creates a sub-deque of a given range.
      *
      * @param int $index The index at which the sub-deque starts. If
      *   positive, the deque will start at that index in the deque. If
      *   negative, the deque will start that far from the end.
      * @param int $length If a length is given and is positive, the
      *   resulting deque will have up to that many values in it.
      *   
      *   If the length results in an overflow, only values up to the end of
      *   the deque will be included.
      *   
      *   If a length is given and is negative, the deque will stop that many
      *   values from the end.
      *   
      *   If a length is not provided, the resulting deque will contain all
      *   values between the index and the end of the deque.
      * @return Ds\Deque A sub-deque of the given range.
      **/
     public function slice($index, $length){}
 
     /**
      * Sorts the deque in-place
      *
      * Sorts the deque in-place, using an optional {@link comparator}
      * function.
      *
      * @param callable $comparator
      * @return void
      **/
     public function sort($comparator){}
 
     /**
      * Returns a sorted copy
      *
      * Returns a sorted copy, using an optional {@link comparator} function.
      *
      * @param callable $comparator
      * @return Ds\Deque Returns a sorted copy of the deque.
      **/
     public function sorted($comparator){}
 
     /**
      * Returns the sum of all values in the deque
      *
      * @return number The sum of all the values in the deque as either a
      *   float or int depending on the values in the deque.
      **/
     public function sum(){}
 
     /**
      * Converts the deque to an
      *
      * Converts the deque to an .
      *
      * @return array An containing all the values in the same order as the
      *   deque.
      **/
     public function toArray(){}
 
     /**
      * Adds values to the front of the deque
      *
      * Adds values to the front of the deque, moving all the current values
      * forward to make room for the new values.
      *
      * @param mixed $values The values to add to the front of the deque.
      *   Multiple values will be added in the same order that they are
      *   passed.
      * @return void
      **/
     public function unshift($values){}
 
 }
 }
 namespace Ds {
 interface Hashable {
     /**
      * Determines whether an object is equal to the current instance
      *
      * Determines whether another object is equal to the current instance.
      *
      * This method allows objects to be used as keys in structures such as
      * Ds\Map and Ds\Set, or any other lookup structure that honors this
      * interface.
      *
      * @param object $obj The object to compare the current instance to,
      *   which is always an instance of the same class.
      * @return bool TRUE if equal, FALSE otherwise.
      **/
     public function equals($obj);
 
     /**
      * Returns a scalar value to be used as a hash value
      *
      * Returns a scalar value to be used as the hash value of the objects.
      *
      * While the hash value does not define equality, all objects that are
      * equal according to {@link Ds\Hashable::equals} must have the same hash
      * value. Hash values of equal objects don't have to be unique, for
      * example you could just return TRUE for all objects and nothing would
      * break - the only implication would be that hash tables then turn into
      * linked lists because all your objects will be hashed to the same
      * bucket. It's therefore very important that you pick a good hash value,
      * such as an ID or email address.
      *
      * This method allows objects to be used as keys in structures such as
      * Ds\Map and Ds\Set, or any other lookup structure that honors this
      * interface.
      *
      * @return mixed A scalar value to be used as this object's hash value.
      **/
     public function hash();
 
 }
 }
 namespace Ds {
 class Map implements Ds\Collection {
     /**
      * Allocates enough memory for a required capacity
      *
      * @param int $capacity The number of values for which capacity should
      *   be allocated.
      * @return void
      **/
     public function allocate($capacity){}
 
     /**
      * Updates all values by applying a callback function to each value
      *
      * Updates all values by applying a {@link callback} function to each
      * value in the map.
      *
      * @param callable $callback mixed callback mixed{@link key}
      *   mixed{@link value} A callable to apply to each value in the map. The
      *   callback should return what the value should be replaced by.
      * @return void
      **/
     public function apply($callback){}
 
     /**
      * Returns the current capacity
      *
      * @return int The current capacity.
      **/
     public function capacity(){}
 
     /**
      * Removes all values
      *
      * Removes all values from the map.
      *
      * @return void
      **/
     public function clear(){}
 
     /**
      * Returns a shallow copy of the map
      *
      * @return Ds\Map Returns a shallow copy of the map.
      **/
     public function copy(){}
 
     /**
      * Creates a new map using keys that aren't in another map
      *
      * Returns the result of removing all keys from the current instance that
      * are present in a given {@link map}.
      *
      * A \ B = {x ∈ A | x ∉ B}
      *
      * @param Ds\Map $map The map containing the keys to exclude in the
      *   resulting map.
      * @return Ds\Map The result of removing all keys from the current
      *   instance that are present in a given {@link map}.
      **/
     public function diff($map){}
 
     /**
      * Creates a new map using a to determine which pairs to include
      *
      * Creates a new map using a callable to determine which pairs to
      * include.
      *
      * @param callable $callback bool callback mixed{@link key} mixed{@link
      *   value} Optional callable which returns TRUE if the pair should be
      *   included, FALSE otherwise. If a callback is not provided, only
      *   values which are TRUE (see converting to boolean) will be included.
      * @return Ds\Map A new map containing all the pairs for which either
      *   the {@link callback} returned TRUE, or all values that convert to
      *   TRUE if a {@link callback} was not provided.
      **/
     public function filter($callback){}
 
     /**
      * Returns the first pair in the map
      *
      * @return Ds\Pair The first pair in the map.
      **/
     public function first(){}
 
     /**
      * Returns the value for a given key
      *
      * Returns the value for a given key, or an optional default value if the
      * key could not be found.
      *
      * @param mixed $key The key to look up.
      * @param mixed $default The optional default value, returned if the
      *   key could not be found.
      * @return mixed The value mapped to the given {@link key}, or the
      *   {@link default} value if provided a