<?php

namespace {

    /**
     * Creates an array.
     * @link https://php.net/manual/en/function.array.php
     * @param mixed $_ [optional] <p>
     * Syntax "index => values", separated by commas, define index and values.
     * index may be of type string or integer. When index is omitted, an integer index is automatically generated,
     * starting at 0. If index is an integer, next generated index will be the biggest integer index + 1.
     * Note that when two identical index are defined, the last overwrite the first.
     * </p>
     * <p>
     * Having a trailing comma after the last defined array entry, while unusual, is a valid syntax.
     * </p>
     * @return array an array of the parameters. The parameters can be given an index with the => operator.
     */
    function PS_UNRESERVE_PREFIX_array(...$_){};

    /**
     * Assigns a list of variables in one operation.
     * @link https://php.net/manual/en/function.list.php
     * @param mixed $var1 <p>A variable.</p>
     * @param mixed $_ [optional] <p>Another variable ...</p>
     * @return array the assigned array.
     */
    function PS_UNRESERVE_PREFIX_list($var1, ...$_){};

    /**
     * <p>Terminates execution of the script. Shutdown functions and object destructors will always be executed even if exit is called.</p>
     * <p>die is a language construct and it can be called without parentheses if no status is passed.</p>
     * @link https://php.net/manual/en/function.die.php
     * @param int|string $status [optional] <p>
     * If status is a string, this function prints the status just before exiting.
     * </p>
     * <p>
     * If status is an integer, that value will be used as the exit status and not printed. Exit statuses should be in the range 0 to 254,
     * the exit status 255 is reserved by PHP and shall not be used. The status 0 is used to terminate the program successfully.
     * </p>
     * <p>
     * Note: PHP >= 4.2.0 does NOT print the status if it is an integer.
     * </p>
     * @return void
     */
    function PS_UNRESERVE_PREFIX_die($status = ""){};

    /**
     * <p>Terminates execution of the script. Shutdown functions and object destructors will always be executed even if exit is called.</p>
     * <p>exit is a language construct and it can be called without parentheses if no status is passed.</p>
     * @link https://php.net/manual/en/function.exit.php
     * @param int|string $status [optional] <p>
     * If status is a string, this function prints the status just before exiting.
     * </p>
     * <p>
     * If status is an integer, that value will be used as the exit status and not printed. Exit statuses should be in the range 0 to 254,
     * the exit status 255 is reserved by PHP and shall not be used. The status 0 is used to terminate the program successfully.
     * </p>
     * <p>
     * Note: PHP >= 4.2.0 does NOT print the status if it is an integer.
     * </p>
     * @return void
     */
    function PS_UNRESERVE_PREFIX_exit($status = ""){};

    /**
     * Determine whether a variable is considered to be empty. A variable is considered empty if it does not exist or if its value
     * equals <b>FALSE</b>. <b>empty()</b> does not generate a warning if the variable does not exist.
     * @link https://php.net/manual/en/function.empty.php
     * @param mixed $var <p>Variable to be checked.</p>
     * <p>Note: Prior to PHP 5.5, <b>empty()</b> only supports variables; anything else will result in a parse error. In other words,
     * the following will not work: <b>empty(trim($name))</b>. Instead, use <b>trim($name) == false</b>.
     * </p>
     * <p>
     * No warning is generated if the variable does not exist. That means <b>empty()</b> is essentially the concise equivalent
     * to <b>!isset($var) || $var == false</b>.
     * </p>
     * @return bool <p><b>FALSE</b> if var exists and has a non-empty, non-zero value. Otherwise returns <b>TRUE</b>.<p>
     * <p>
     * The following things are considered to be empty:
     * <ul>
     * <li>"" (an empty string)</li>
     * <li>0 (0 as an integer)</li>
     * <li>0.0 (0 as a float)</li>
     * <li>"0" (0 as a string)</li>
     * <li><b>NULL</b></li>
     * <li><b>FALSE</b></li>
     * <li>array() (an empty array)</li>
     * <li>$var; (a variable declared, but without a value)</li>
     * </ul>
     * </p>
     */
    function PS_UNRESERVE_PREFIX_empty($var){};

    /**
     * <p>Determine if a variable is set and is not <b>NULL</b>.</p>
     * <p>If a variable has been unset with unset(), it will no longer be set. <b>isset()</b> will return <b>FALSE</b> if testing a variable
     * that has been set to <b>NULL</b>. Also note that a null character ("\0") is not equivalent to the PHP <b>NULL</b> constant.</p>
     * <p>If multiple parameters are supplied then <b>isset()</b> will return <b>TRUE</b> only if all of the parameters are set.
     * Evaluation goes from left to right and stops as soon as an unset variable is encountered.</p>
     * @link https://php.net/manual/en/function.isset.php
     * @param mixed $var <p>The variable to be checked.</p>
     * @param mixed $_ [optional] <p>Another variable ...</p>
     * @return bool Returns <b>TRUE</b> if var exists and has value other than <b>NULL</b>, <b>FALSE</b> otherwise.
     */
    function PS_UNRESERVE_PREFIX_isset($var, ...$_){};

    /**
     * <p>Destroys the specified variables.</p>
     * <p>The behavior of <b>unset()</b> inside of a function can vary depending on what type of variable you are attempting to destroy.</p>
     * @link https://php.net/manual/en/function.unset.php
     * @param mixed $var <p>The variable to be unset.</p>
     * @param mixed $_ [optional] <p>Another variable ...</p>
     * @return void
     */
    function PS_UNRESERVE_PREFIX_unset($var, ...$_){};

    /**
     * <p>Evaluates the given code as PHP.</p>
     * <p>Caution: The <b>eval()</b> language construct is very dangerous because it allows execution of arbitrary PHP code. Its use thus is
     * discouraged. If you have carefully verified that there is no other option than to use this construct, pay special attention not to
     * pass any user provided data into it without properly validating it beforehand.</p>
     * @link https://php.net/manual/en/function.eval.php
     * @param string $code <p>
     * Valid PHP code to be evaluated.
     * </p>
     * <p>
     * The code must not be wrapped in opening and closing PHP tags, i.e. 'echo "Hi!";' must be passed instead of '<?php echo "Hi!"; ?>'.
     * It is still possible to leave and re-enter PHP mode though using the appropriate PHP tags, e.g.
     * 'echo "In PHP mode!"; ?>In HTML mode!<?php echo "Back in PHP mode!";'.
     * </p>
     * <p>
     * Apart from that the passed code must be valid PHP. This includes that all statements must be properly terminated using a semicolon.
     * 'echo "Hi!"' for example will cause a parse error, whereas 'echo "Hi!";' will work.
     * </p>
     * <p>
     * A return statement will immediately terminate the evaluation of the code.
     * </p>
     * <p>
     * The code will be executed in the scope of the code calling <b>eval()</b>. Thus any variables defined or changed in the <b>eval()</b>
     * call will remain visible after it terminates.
     * </p>
     * @return mixed <b>NULL</b> unless return is called in the evaluated code, in which case the value passed to return is returned.
     * As of PHP 7, if there is a parse error in the evaluated code, <b>eval()</b> throws a ParseError exception. Before PHP 7, in this
     * case <b>eval()</b> returned <b>FALSE</b> and execution of the following code continued normally. It is not possible to catch a parse
     * error in <b>eval()</b> using set_error_handler().
     */
    function PS_UNRESERVE_PREFIX_eval($code){};

    /**
     * Generator objects are returned from generators, cannot be instantiated via new.
     * @link https://secure.php.net/manual/en/class.generator.php
     * @link https://wiki.php.net/rfc/generators
     */
    final class Generator implements Iterator {
        /**
         * Throws an exception if the generator is currently after the first yield.
         * @return void
         */
        function rewind() {}
        /**
         * Returns false if the generator has been closed, true otherwise.
         * @return bool
         */
        function valid() {}
        /**
         * Returns whatever was passed to yield or null if nothing was passed or the generator is already closed.
         * @return mixed
         */
        function current() {}
        /**
         * Returns the yielded key or, if none was specified, an auto-incrementing key or null if the generator is already closed.
         * @return string|float|int|bool|null
         */
        function key() {}
        /**
         * Resumes the generator (unless the generator is already closed).
         * @return void
         */
        function next() {}

        /**
         * Sets the return value of the yield expression and resumes the generator (unless the generator is already closed).
         * @param mixed $value
         * @return mixed
         */
        function send($value) {}

        /**
         * Throws an exception at the current suspension point in the generator.
         * @param Throwable $exception
         * @return mixed
         */
        function PS_UNRESERVE_PREFIX_throw(Throwable $exception) {}

        /**
         * Returns whatever was passed to return or null if nothing.
         * Throws an exception if the generator is still valid.
         * @link https://wiki.php.net/rfc/generator-return-expressions
         * @return mixed|null
         */
        function getReturn() {}

        /**
         * Serialize callback
         * Throws an exception as generators can't be serialized.
         * @link https://php.net/manual/en/generator.wakeup.php
         * @return void
         */
        public function __wakeup(){}
    }

    class ClosedGeneratorException extends Exception {}

}

namespace ___PHPSTORM_HELPERS {

class PS_UNRESERVE_PREFIX_this {}
class PS_UNRESERVE_PREFIX_static {}
class object {
  /**
   * PHP 5 allows developers to declare constructor methods for classes.
   * Classes which have a constructor method call this method on each newly-created object,
   * so it is suitable for any initialization that the object may need before it is used.
   *
   * Note: Parent constructors are not called implicitly if the child class defines a constructor.
   * In order to run a parent constructor, a call to parent::__construct() within the child constructor is required.
   *
   * param [ mixed $args [, $... ]]
   * @link https://php.net/manual/en/language.oop5.decon.php
   */
  public function __construct() {}

  /**
   * PHP 5 introduces a destructor concept similar to that of other object-oriented languages, such as C++.
   * The destructor method will be called as soon as all references to a particular object are removed or
   * when the object is explicitly destroyed or in any order in shutdown sequence.
   *
   * Like constructors, parent destructors will not be called implicitly by the engine.
   * In order to run a parent destructor, one would have to explicitly call parent::__destruct() in the destructor body.
   *
   * Note: Destructors called during the script shutdown have HTTP headers already sent.
   * The working directory in the script shutdown phase can be different with some SAPIs (e.g. Apache).
   *
   * Note: Attempting to throw an exception from a destructor (called in the time of script termination) causes a fatal error.
   *
   * @return void
   * @link https://php.net/manual/en/language.oop5.decon.php
   */
  public function __destruct() {}

  /**
   * is triggered when invoking inaccessible methods in an object context.
   *
   * @param $name string
   * @param $arguments array
   * @return mixed
   * @link https://php.net/manual/en/language.oop5.overloading.php#language.oop5.overloading.methods
   */
  public function __call($name, $arguments) {}

  /**
   * is triggered when invoking inaccessible methods in a static context.
   *
   * @param $name string
   * @param $arguments array
   * @return mixed
   * @link https://php.net/manual/en/language.oop5.overloading.php#language.oop5.overloading.methods
   */
  public static function __callStatic($name, $arguments) {}

  /**
   * is utilized for reading data from inaccessible members.
   *
   * @param $name string
   * @return mixed
   * @link https://php.net/manual/en/language.oop5.overloading.php#language.oop5.overloading.members
   */
  public function __get($name) {}

  /**
   * run when writing data to inaccessible members.
   *
   * @param $name string
   * @param $value mixed
   * @return void
   * @link https://php.net/manual/en/language.oop5.overloading.php#language.oop5.overloading.members
   */
  public function __set($name, $value) {}

  /**
   * is triggered by calling isset() or empty() on inaccessible members.
   *
   * @param $name string
   * @return bool
   * @link https://php.net/manual/en/language.oop5.overloading.php#language.oop5.overloading.members
   */
  public function __isset($name) {}
  /**
   * is invoked when unset() is used on inaccessible members.
   *
   * @param $name string
   * @return void
   * @link https://php.net/manual/en/language.oop5.overloading.php#language.oop5.overloading.members
   */
  public function __unset($name) {}

  /**
   * serialize() checks if your class has a function with the magic name __sleep.
   * If so, that function is executed prior to any serialization.
   * It can clean up the object and is supposed to return an array with the names of all variables of that object that should be serialized.
   * If the method doesn't return anything then NULL is serialized and E_NOTICE is issued.
   * The intended use of __sleep is to commit pending data or perform similar cleanup tasks.
   * Also, the function is useful if you have very large objects which do not need to be saved completely.
   *
   * @return string[]
   * @link https://php.net/manual/en/language.oop5.magic.php#language.oop5.magic.sleep
   */
  public function __sleep() {}

  /**
   * unserialize() checks for the presence of a function with the magic name __wakeup.
   * If present, this function can reconstruct any resources that the object may have.
   * The intended use of __wakeup is to reestablish any database connections that may have been lost during
   * serialization and perform other reinitialization tasks.
   *
   * @return void
   * @link https://php.net/manual/en/language.oop5.magic.php#language.oop5.magic.sleep
   */
  public function __wakeup() {}

  /**
   * The __toString method allows a class to decide how it will react when it is converted to a string.
   *
   * @return string
   * @link https://php.net/manual/en/language.oop5.magic.php#language.oop5.magic.tostring
   */
  public function __toString() {}

  /**
   * The __invoke method is called when a script tries to call an object as a function.
   *
   * @return mixed
   * @link https://php.net/manual/en/language.oop5.magic.php#language.oop5.magic.invoke
   */
  public function __invoke() {}

    /**
     * This method is called by var_dump() when dumping an object to get the properties that should be shown.
     * If the method isn't defined on an object, then all public, protected and private properties will be shown.
     * @since 5.6
     *
     * @return array
     * @link https://php.net/manual/en/language.oop5.magic.php#language.oop5.magic.debuginfo
     */
    public function __debugInfo(){}

  /**
   * This static method is called for classes exported by var_export() since PHP 5.1.0.
   * The only parameter of this method is an array containing exported properties in the form array('property' => value, ...).
   * @since 5.1
   *
   * @param $an_array array
   * @return mixed
   * @link https://php.net/manual/en/language.oop5.magic.php#language.oop5.magic.set-state
   */
  public static function __set_state($an_array) {}

  /**
   * When an object is cloned, PHP 5 will perform a shallow copy of all of the object's properties.
   * Any properties that are references to other variables, will remain references.
   * Once the cloning is complete, if a __clone() method is defined,
   * then the newly created object's __clone() method will be called, to allow any necessary properties that need to be changed.
   * NOT CALLABLE DIRECTLY.
   *
   * @return void
   * @link https://php.net/manual/en/language.oop5.cloning.php
   */
  public function __clone() {}

    /**
     * Returns array containing all the necessary state of the object.
     * @since 7.4
     * @link https://wiki.php.net/rfc/custom_object_serialization
     */
    public function __serialize(): array
    {
    }

    /**
     * Restores the object state from the given data array.
     * @since 7.4
     * @link https://wiki.php.net/rfc/custom_object_serialization
     */
    public function __unserialize(array $data): void
    {
    }

}
}
