<?php
/**
 * This class represents a RAR archive, which may be formed by several volumes (parts) and which contains a number of
 * RAR entries (i.e., files, directories and other special objects such as symbolic links).
 *
 * Objects of this class can be traversed, yielding the entries stored in the respective RAR archive.
 * Those entries can also be obtained through {@see \RarArchive::getEntry} and {@see \RarArchive::getEntries}.
 *
 * @link https://php.net/manual/ru/class.rararchive.php
 */
final class RarArchive implements Traversable
{
    /**
     * Open RAR archive
     *
     * @param string $filename Path to the Rar archive
     * @param string $password A plain password, if needed to decrypt the headers. It will also be used by default if
     *      encrypted files are found. Note that the files may have different passwords in respect
     *      to the headers and among them
     * @param callable $volume_callback A function that receives one parameter – the path of the volume that was
     *      not found – and returns a string with the correct path for such volume or NULL if such volume does not
     *      exist or is not known. The programmer should ensure the passed function doesn't cause loops as this
     *      function is called repeatedly if the path returned in a previous call did not correspond to the needed
     *      volume. Specifying this parameter omits the notice that would otherwise be emitted whenever a volume is
     *      not found; an implementation that only returns NULL can therefore be used to merely omit such notices
     *
     * @link https://php.net/manual/en/rararchive.open.php
     *
     * @return RarArchive|false the requested RarArchive instance or FALSE on failure.
     */
    public static function open($filename, $password = null, callable $volume_callback = null)
    {
    }
    /**
     * Close RAR archive and free all resources
     *
     * @link https://php.net/manual/en/rararchive.close.php
     *
     * @return bool TRUE on success or FALSE on failure
     */
    public function close()
    {
    }
    /**
     * Get comment text from the RAR archive
     *
     * @link https://php.net/manual/en/rararchive.getcomment.php
     *
     * @return string|null the comment or NULL if there is none
     */
    public function getComment()
    {
    }
    /**
     * Get full list of entries from the RAR archive
     *
     * @return RarEntry[]|false array of {@see RarEntry} objects or FALSE on failure
     */
    public function getEntries()
    {
    }
    /**
     * Get entry object from the RAR archive
     *
     * Get entry object (file or directory) from the RAR archive
     *
     * @link https://php.net/manual/en/rararchive.getentry.php
     *
     * @param string $entryname Path to the entry within the RAR archive
     *
     * @return RarEntry|false the matching RarEntry object or FALSE on failure
     */
    public function getEntry($entryname)
    {
    }
    /**
     * Test whether an archive is broken (incomplete)
     *
     * This function determines whether an archive is incomplete, i.e., if a volume is missing or a volume is truncated.
     *
     * @link https://php.net/manual/en/rararchive.isbroken.php
     *
     * @return bool Returns TRUE if the archive is broken, FALSE otherwise. This function may also return FALSE if
     *         the passed file has already been closed. The only way to tell the two cases apart is to enable
     *         exceptions with {@see RarException::setUsingExceptions()}; however, this should be unnecessary as a program
     *         should not operate on closed files.
     */
    public function isBroken()
    {
    }
    /**
     * Check whether the RAR archive is solid
     *
     * Check whether the RAR archive is solid. Individual file extraction is slower on solid archives
     *
     * @link https://php.net/manual/enrararchive.issolid.php
     *
     * @return bool TRUE if the archive is solid, FALSE otherwise
     */
    public function  isSolid()
    {
    }
    /**
     * Whether opening broken archives is allowed
     *
     * This method defines whether broken archives can be read or all the operations that attempt to extract the
     * archive entries will fail. Broken archives are archives for which no error is detected when the file is
     * opened but an error occurs when reading the entries.
     *
     * @link https://php.net/manual/ru/rararchive.setallowbroken.php
     *
     * @param bool $allow_broken Whether to allow reading broken files (TRUE) or not (FALSE)
     *
     * @return bool TRUE или FALSE в случае возникновения ошибки. It will only fail if the file has already been closed
     */
    public function setAllowBroken($allow_broken)
    {
    }
    /**
     * Get text representation
     *
     * Provides a string representation for this RarArchive object. It currently shows the full path name of the
     * archive volume that was opened and whether the resource is valid or was already closed through a
     * call to {@see RarArchive::close()}.
     *
     * This method may be used only for debugging purposes, as there are no guarantees as to which information the
     * result contains or how it is formatted.
     *
     * @return string A textual representation of this RarArchive object. The content of this
     *          representation is unspecified.
     */
    public function  __toString()
    {
    }
}
/**
 * A RAR entry, representing a directory or a compressed file inside a RAR archive
 *
 * @link https://php.net/manual/en/class.rarentry.php
 */
final class RarEntry
{
    /**
     * If the return value of {@see RarEntry::getHostOs()} equals this constant, MS-DOS was used to add this entry.
     * Use instead of {@see RAR_HOST_MSDOS}.
     */
    const HOST_MSDOS = 0;
    /**
     * If the return value of {@see RarEntry::getHostOs()} equals this constant, OS/2 was used to add this entry.
     * Intended to replace {@see RAR_HOST_OS2}.
     */
    const HOST_OS2 = 1;
    /**
     * If the return value of {@see RarEntry::getHostOs()} equals this constant, Microsoft Windows was used to add this entry.
     * Intended to replace {@see RAR_HOST_WIN32}
     */
    const HOST_WIN32 = 2;
    /**
     * If the return value of {@see RarEntry::getHostOs()} equals this constant, an unspecified UNIX OS was used to add
     * this entry. Intended to replace {@see RAR_HOST_UNIX}.
     */
    const HOST_UNIX = 3;
    /**
     * If the return value of {@see RarEntry::getHostOs()} equals this constant, Mac OS was used to add this entry.
     */
    const HOST_MACOS = 4;
    /**
     * If the return value of {@see RarEntry::getHostOs()} equals this constant, BeOS was used to add this entry.
     * Intended to replace {@see RAR_HOST_BEOS}.
     */
    const HOST_BEOS = 5;
    /**
     * Bit that represents a Windows entry with a read-only attribute. To be used with {@see RarEntry::getAttr()} on
     * entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_READONLY = 1;
    /**
     * Bit that represents a Windows entry with a hidden attribute. To be used with {@see RarEntry::getAttr()} on
     * entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_HIDDEN = 2;
    /**
     * Bit that represents a Windows entry with a system attribute. To be used with {@see RarEntry::getAttr()} on
     * entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_SYSTEM = 4;
    /**
     * Bit that represents a Windows entry with a directory attribute (entry is a directory). To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is Microsoft Windows. See also
     * {@see RarEntry::isDirectory()}, which also works with entries that were not added in WinRAR.
     */
    const ATTRIBUTE_WIN_DIRECTORY = 16;
    /**
     * Bit that represents a Windows entry with an archive attribute. To be used with {@see RarEntry::getAttr()} on
     * entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_ARCHIVE = 32;
    /**
     * Bit that represents a Windows entry with a device attribute. To be used with {@see RarEntry::getAttr()} on
     * entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_DEVICE = 64;
    /**
     * Bit that represents a Windows entry with a normal file attribute (entry is NOT a directory). To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is Microsoft Windows. See also
     * {@see RarEntry::isDirectory()}, which also works with entries that were not added in WinRAR.
     */
    const ATTRIBUTE_WIN_NORMAL = 128;
    /**
     * Bit that represents a Windows entry with a temporary attribute. To be used with {@see RarEntry::getAttr()} on
     * entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_TEMPORARY = 256;
    /**
     * Bit that represents a Windows entry with a sparse file attribute (file is an NTFS sparse file). To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_SPARSE_FILE = 512;
    /**
     * Bit that represents a Windows entry with a reparse point attribute (entry is an NTFS reparse point, e.g. a
     * directory junction or a mount file system). To be used with {@see RarEntry::getAttr()} on entries whose host OS
     * is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_REPARSE_POINT = 1024;
    /**
     * Bit that represents a Windows entry with a compressed attribute (NTFS only). To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_COMPRESSED = 2048;
    /**
     * Bit that represents a Windows entry with an offline attribute (entry is offline and not accessible). To be used
     * with {@see RarEntry::getAttr()} on entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_OFFLINE = 4096;
    /**
     * Bit that represents a Windows entry with a not content indexed attribute (entry is to be indexed). To be used
     * with {@see RarEntry::getAttr()} on entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_NOT_CONTENT_INDEXED = 8192;
    /**
     * Bit that represents a Windows entry with an encrypted attribute (NTFS only). To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_ENCRYPTED = 16384;
    /**
     * Bit that represents a Windows entry with a virtual attribute. To be used with {@see RarEntry::getAttr()}
     * on entries whose host OS is Microsoft Windows.
     */
    const ATTRIBUTE_WIN_VIRTUAL = 65536;
    /**
     * Bit that represents a UNIX entry that is world executable. To be used with {@see RarEntry::getAttr()} on entries
     * whose host OS is UNIX.
     */
    const ATTRIBUTE_UNIX_WORLD_EXECUTE = 1;
    /**
     * Bit that represents a UNIX entry that is world writable. To be used with {@see RarEntry::getAttr()} on entries
     * whose host OS is UNIX.
     */
    const ATTRIBUTE_UNIX_WORLD_WRITE = 2;
    /**
     * Bit that represents a UNIX entry that is world readable. To be used with {@see RarEntry::getAttr()} on entries
     * whose host OS is UNIX.
     */
    const ATTRIBUTE_UNIX_WORLD_READ = 4;
    /**
     * Bit that represents a UNIX entry that is group executable. To be used with {@see RarEntry::getAttr()} on entries
     * whose host OS is UNIX.
     */
    const ATTRIBUTE_UNIX_GROUP_EXECUTE = 8;
    /**
     * Bit that represents a UNIX entry that is group writable. To be used with {@see RarEntry::getAttr()} on entries
     * whose host OS is UNIX.
     */
    const ATTRIBUTE_UNIX_GROUP_WRITE = 16;
    /**
     * Bit that represents a UNIX entry that is group readable. To be used with {@see RarEntry::getAttr()} on entries
     * whose host OS is UNIX.
     */
    const ATTRIBUTE_UNIX_GROUP_READ = 32;
    /**
     * Bit that represents a UNIX entry that is owner executable. To be used with {@see RarEntry::getAttr()} on entries
     * whose host OS is UNIX.
     */
    const ATTRIBUTE_UNIX_OWNER_EXECUTE = 64;
    /**
     * Bit that represents a UNIX entry that is owner writable. To be used with {@see RarEntry::getAttr()} on entries
     * whose host OS is UNIX.
     */
    const ATTRIBUTE_UNIX_OWNER_WRITE = 128;
    /**
     * Bit that represents a UNIX entry that is owner readable. To be used with {@see RarEntry::getAttr()} on entries
     * whose host OS is UNIX.
     */
    const ATTRIBUTE_UNIX_OWNER_READ = 256;
    /**
     * Bit that represents the UNIX sticky bit. To be used with {@see RarEntry::getAttr()} on entries whose host OS is
     * UNIX.
     */
    const ATTRIBUTE_UNIX_STICKY = 512;
    /**
     * Bit that represents the UNIX setgid attribute. To be used with {@see RarEntry::getAttr()} on entries whose host
     * OS is UNIX.
     */
    const ATTRIBUTE_UNIX_SETGID = 1024;
    /**
     * Bit that represents the UNIX setuid attribute. To be used with {@see RarEntry::getAttr()} on entries whose host
     * OS is UNIX.
     */
    const ATTRIBUTE_UNIX_SETUID = 2048;
    /**
     * Mask to isolate the last four bits (nibble) of UNIX attributes (_S_IFMT, the type of file mask). To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is UNIX and with the constants
     * {@see RarEntry::ATTRIBUTE_UNIX_FIFO}, {@see RarEntry::ATTRIBUTE_UNIX_CHAR_DEV},
     * {@see RarEntry::ATTRIBUTE_UNIX_DIRECTORY}, {@see RarEntry::ATTRIBUTE_UNIX_BLOCK_DEV},
     * {@see RarEntry::ATTRIBUTE_UNIX_REGULAR_FILE},
     * {@see RarEntry::ATTRIBUTE_UNIX_SYM_LINK} and {@see RarEntry::ATTRIBUTE_UNIX_SOCKET}.
     */
    const ATTRIBUTE_UNIX_FINAL_QUARTET = 61440;
    /**
     * Unix FIFOs will have attributes whose last four bits have this value. To be used with {@see RarEntry::getAttr()}
     * on entries whose host OS is UNIX and with the constant {@see RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET}.
     */
    const ATTRIBUTE_UNIX_FIFO = 4096;
    /**
     * Unix character devices will have attributes whose last four bits have this value. To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is UNIX and with the constant
     * {@see RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET}.
     */
    const ATTRIBUTE_UNIX_CHAR_DEV = 8192;
    /**
     * Unix directories will have attributes whose last four bits have this value. To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is UNIX and with the constant
     * {@see RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET}.
     *
     * See also {@see RarEntry::isDirectory()}, which also works with entries that were added in other operating
     * systems.
     */
    const ATTRIBUTE_UNIX_DIRECTORY = 16384;
    /**
     * Unix block devices will have attributes whose last four bits have this value. To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is UNIX and with the constant
     * {@see RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET}.
     */
    const ATTRIBUTE_UNIX_BLOCK_DEV = 24576;
    /**
     * Unix regular files (not directories) will have attributes whose last four bits have this value. To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is UNIX and with the constant
     * {@see RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET}. See also {@see RarEntry::isDirectory()}, which also works with
     * entries that were added in other operating systems.
     */
    const ATTRIBUTE_UNIX_REGULAR_FILE = 32768;
    /**
     * Unix symbolic links will have attributes whose last four bits have this value. To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is UNIX and with the constant
     * {@see RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET}.
     */
    const ATTRIBUTE_UNIX_SYM_LINK = 40960;
    /**
     * Unix sockets will have attributes whose last four bits have this value. To be used with
     * {@see RarEntry::getAttr()} on entries whose host OS is UNIX and with the constant
     * {@see RarEntry::ATTRIBUTE_UNIX_FINAL_QUARTET}.
     */
    const ATTRIBUTE_UNIX_SOCKET = 49152;
    /**
     * Extract entry from the archive
     *
     * extracts the entry's data. It will create new file in the specified dir with the name identical to the entry's
     * name, unless the second argument is specified.
     *
     * @link https://php.net/manual/en/rarentry.extract.php
     *
     * @param string $dir Path to the directory where files should be extracted. This parameter is considered if and
     *      only if filepath is not. If both parameters are empty an extraction to the current directory
     *      will be attempted.
     * @param string $filepath Path (relative or absolute) containing the directory and filename of the extracted file.
     *      This parameter overrides both the parameter dir and the original file name.
     * @param string $password The password used to encrypt this entry. If the entry is not encrypted, this value will
     *      not be used and can be omitted. If this parameter is omitted and the entry is encrypted, the password
     *      given to rar_open(), if any, will be used. If a wrong password is given, either explicitly or implicitly
     *      via rar_open(), CRC checking will fail and this method will fail and return FALSE. If no password is given
     *      and one is required, this method will fail and return FALSE. You can check whether an entry is encrypted
     *      with {@see RarEntry::isEncrypted()}.
     * @param bool $extended_data If TRUE, extended information such as NTFS ACLs and Unix owner information will be
     *      set in the extract files, as long as it's present in the archive.
     *
     * @return TRUE on success or FALSE on failure
     */
    public function  extract($dir, $filepath = "", $password = null, $extended_data = false)
    {
    }
    /**
     * Get attributes of the entry
     *
     * Returns the OS-dependent attributes of the archive entry
     *
     * @link https://php.net/manual/en/rarentry.getattr.php
     *
     * @return int|false the attributes or FALSE on error
     */
    public function getAttr()
    {
    }
    /**
     * Get CRC of the entry
     *
     * Returns an hexadecimal string representation of the CRC of the archive entry.
     *
     * @link https://php.net/manual/en/rarentry.getcrc.php
     *
     * @return string|false the CRC of the archive entry or FALSE on error
     */
    public function getCrc()
    {
    }
    /**
     * Get entry last modification time
     *
     * @link https://php.net/manual/en/rarentry.getfiletime.php
     *
     * @return string|false entry last modification time as string in format YYYY-MM-DD HH:II:SS, or FALSE on errors
     */
    public function getFileTime()
    {
    }
    /**
     * Get entry host OS
     *
     * Returns the code of the host OS of the archive entry
     *
     * @link https://php.net/manual/en/rarentry.gethostos.php
     *
     * @return int|false the code of the host OS, or FALSE on error
     */
    public function getHostOs()
    {
    }
    /**
     * Get pack method of the entry
     *
     * returns number of the method used when adding current archive entry
     *
     * @link https://php.net/manual/en/rarentry.getmethod.php
     *
     * @return int|false the method number or FALSE on error
     */
    public function getMethod()
    {
    }
    /**
     * Get name of the entry
     *
     * Returns the name (with path) of the archive entry.
     *
     * @link https://php.net/manual/en/rarentry.getname.php
     *
     * @return string|false the entry name as a string, or FALSE on error.
     */
    public function getName()
    {
    }
    /**
     * Get packed size of the entry
     *
     * @link https://php.net/manual/en/rarentry.getpackedsize.php
     *
     * @return int|false the packed size, or FALSE on error
     */
    public function getPackedSize()
    {
    }
    /**
     * Get file handler for entry
     *
     * Returns a file handler that supports read operations. This handler provides on-the-fly decompression for
     * this entry. The handler is not invalidated by calling {@see rar_close()}.
     *
     * @link https://php.net/manual/en/rarentry.getstream.php
     *
     * @param string $password The password used to encrypt this entry. If the entry is not encrypted, this value will
     *      not be used and can be omitted. If this parameter is omitted and the entry is encrypted,
     *      the password given to {@see rar_open()}, if any, will be used. If a wrong password is given, either
     *      explicitly or implicitly via {@see rar_open()}, this method's resulting stream will produce wrong output.
     *      If no password is given and one is required, this method will fail and return FALSE. You can check
     *      whether an entry is encrypted with {@see RarEntry::isEncrypted()}.
     *
     * @return resource|false file handler or FALSE on failure
     */
    public function getStream($password = '')
    {
    }
    /**
     * Get unpacked size of the entry
     * @link https://php.net/manual/en/rarentry.getunpackedsize.php
     * @return int|false the unpacked size, or FALSE on error
     */
    public function getUnpackedSize()
    {
    }
    /**
     * Get minimum version of RAR program required to unpack the entry
     *
     * Returns minimum version of RAR program (e.g. WinRAR) required to unpack the entry. It is encoded as
     * 10 * major version + minor version.
     *
     * @link https://php.net/manual/en/rarentry.getversion.php
     *
     * @return int|false the version or FALSE on error
     */
    public function getVersion()
    {
    }
    /**
     * Test whether an entry represents a directory
     *
     * @link https://php.net/manual/en/rarentry.isdirectory.php
     *
     * @return bool TRUE if this entry is a directory and FALSE otherwise.
     */
    public function isDirectory()
    {
    }
    /**
     * Test whether an entry is encrypted
     *
     * @link https://php.net/manual/en/rarentry.isencrypted.php
     *
     * @return bool TRUE if the current entry is encrypted and FALSE otherwise
     */
    public function isEncrypted()
    {
    }
    /**
     * Get text representation of entry
     *
     * Returns a textual representation for this entry. It includes whether the entry is a file or a directory
     * (symbolic links and other special objects will be treated as files), the UTF-8 name of the entry and its CRC.
     * The form and content of this representation may be changed in the future, so they cannot be relied upon.
     *
     * @link https://php.net/manual/en/rarentry.tostring.php
     *
     * @return string A textual representation for the entry
     */
    public function __toString()
    {
    }
}
/**
 * This class serves two purposes:
 * it is the type of the exceptions thrown by the RAR extension functions and methods and it allows, through static
 * methods to query and define the error behaviour of the extension, i.e., whether exceptions are thrown or only
 * warnings are emitted.<br>
 * The following error codes are used:<br><ul>
 * <li>-1 - error outside UnRAR library</li>
 * <li>11 - insufficient memory</li>
 * <li>12 - bad data</li>
 * <li>13 - bad archive</li>
 * <li>14 - unknown format</li>
 * <li>15 - file open error</li>
 * <li>16 - file create error</li>
 * <li>17 - file close error</li>
 * <li>18 - read error</li>
 * <li>19 - write error</li>
 * <li>20 - buffer too small</li>
 * <li>21 - unkown RAR error</li>
 * <li>22 - password required but not given</li>
 * </ul>
 *
 * @link https://php.net/manual/en/class.rarexception.php
 */
final class RarException extends Exception
{
    /**
     * Check whether error handling with exceptions is in use
     *
     * @link https://php.net/manual/en/rarexception.isusingexceptions.php
     *
     * @return bool TRUE if exceptions are being used, FALSE otherwise
     */
    public static function isUsingExceptions()
    {
    }
    /**
     * Activate and deactivate error handling with exceptions
     *
     * @link https://php.net/manual/en/rarexception.setusingexceptions.php
     *
     * @param bool $using_exceptions Should be TRUE to activate exception throwing, FALSE to deactivate (the default)
     */
    public static function setUsingExceptions($using_exceptions)
    {
    }
}