/**
 * @var string
 */
protected domain;

/**
 * @var int
 */
protected expire;

//
protected filter;

/**
 * @var bool
 */
protected httpOnly;

/**
 * @var string
 */
protected name;

/**
 * @var array
 */
protected options;

/**
 * @var string
 */
protected path;

/**
 * @var bool
 */
protected read = false;

/**
 * @var bool
 */
protected restored = false;

/**
 * @var bool
 */
protected secure;

/**
 * The cookie's sign key.
 * @var string|null
 */
protected signKey;

/**
 * @var bool
 */
protected useEncryption = false;

/**
 * @var mixed
 */
protected value;

public function __construct( string $name, mixed $value = null, int $expire = int, string $path = string, bool $secure = null, string $domain = null, bool $httpOnly = bool, array $options = [] );

public function __toString(): string;

public function delete();

public function getDomain(): string;

public function getExpiration(): string;

public function getHttpOnly(): bool;

public function getName(): string;

public function getOptions(): array;

public function getPath(): string;

public function getSecure(): bool;

public function getValue( mixed $filters = null, mixed $defaultValue = null ): mixed;

public function isUsingEncryption(): bool;

public function restore(): CookieInterface;

public function send(): CookieInterface;

public function setDomain( string $domain ): CookieInterface;

public function setExpiration( int $expire ): CookieInterface;

public function setHttpOnly( bool $httpOnly ): CookieInterface;

public function setOptions( array $options ): CookieInterface;

public function setPath( string $path ): CookieInterface;

public function setSecure( bool $secure ): CookieInterface;

public function setSignKey( string $signKey = null ): CookieInterface;

public function setValue( mixed $value ): CookieInterface;

public function useEncryption( bool $useEncryption ): CookieInterface;

protected function assertSignKeyIsLongEnough( string $signKey ): void;

public function delete();

public function getDomain(): string;

public function getExpiration(): string;

public function getHttpOnly(): bool;

public function getName(): string;

public function getOptions(): array;

public function getPath(): string;

public function getSecure(): bool;

public function getValue( mixed $filters = null, mixed $defaultValue = null ): mixed;

public function isUsingEncryption(): bool;

public function send(): CookieInterface;

public function setDomain( string $domain ): CookieInterface;

public function setExpiration( int $expire ): CookieInterface;

public function setHttpOnly( bool $httpOnly ): CookieInterface;

public function setOptions( array $options ): CookieInterface;

public function setPath( string $path ): CookieInterface;

public function setSecure( bool $secure ): CookieInterface;

public function setValue( mixed $value ): CookieInterface;

public function useEncryption( bool $useEncryption ): CookieInterface;

final protected function checkStringParameter( mixed $element ): void;

final protected function cloneInstance( mixed $element, string $property ): mixed;

final protected function processWith( mixed $element, string $property ): mixed;

/**
 * Gets the body of the message.
 *
 * @var StreamInterface
 */
protected body;

/**
 * @var Collection|CollectionInterface
 */
protected headers;

/**
 * Retrieves the HTTP protocol version as a string.
 *
 * The string MUST contain only the HTTP version number (e.g., '1.1',
 * '1.0').
 *
 * @return string HTTP protocol version.
 *
 * @var string
 */
protected protocolVersion = 1.1;

/**
 * Retrieves the URI instance.
 *
 * This method MUST return a UriInterface instance.
 *
 * @see https://tools.ietf.org/html/rfc3986#section-4.3
 *
 * @var UriInterface
 */
protected uri;

public function getBody(): StreamInterface

public function getHeader( mixed $name ): array;

public function getHeaderLine( mixed $name ): string;

public function getHeaders(): array;

// Represent the headers as a string
foreach ($message->getHeaders() as $name => $values) {
    echo $name . ': ' . implode(', ', $values);
}

// Emit headers iteratively:
foreach ($message->getHeaders() as $name => $values) {
    foreach ($values as $value) {
        header(sprintf('%s: %s', $name, $value), false);
    }
}

public function getProtocolVersion(): string

public function getUri(): UriInterface

public function hasHeader( mixed $name ): bool;

public function withAddedHeader( mixed $name, mixed $value ): mixed;

public function withBody( StreamInterface $body ): mixed;

public function withHeader( mixed $name, mixed $value ): mixed;

public function withProtocolVersion( mixed $version ): mixed;

public function withoutHeader( mixed $name ): mixed;

final protected function checkHeaderHost( CollectionInterface $collection ): CollectionInterface;

final protected function checkHeaderName( mixed $name ): void;

final protected function checkHeaderValue( mixed $value ): void;

token          = 1*tchar

tchar          = '!' / '#' / '$' / '%' / '&' / ''' / '*'
               / '+' / '-' / '.' / '^' / '_' / '`' / '|' / '~'
               / DIGIT / ALPHA
               ; any VCHAR, except delimiters

quoted-string  = DQUOTE( qdtext / quoted-pair ) DQUOTE
qdtext         = HTAB / SP /%x21 / %x23-5B / %x5D-7E / obs-text
obs-text       = %x80-FF

comment        = '('( ctext / quoted-pair / comment ) ')'
ctext          = HTAB / SP / %x21-27 / %x2A-5B / %x5D-7E / obs-text

quoted-pair    = '\' ( HTAB / SP / VCHAR / obs-text )

final protected function getHeaderValue( mixed $values ): array;

final protected function getUriHost( UriInterface $uri ): string;

final protected function populateHeaderCollection( array $headers ): CollectionInterface;

final protected function processBody( mixed $body = string, string $mode = string ): StreamInterface;

final protected function processHeaders( mixed $headers ): CollectionInterface;

final protected function processProtocol( mixed $protocol = string ): string;

/**
 * Retrieves the HTTP method of the request.
 *
 * @var string
 */
protected method = GET;

/**
 * The request-target, if it has been provided or calculated.
 *
 * @var null|string
 */
protected requestTarget;

/**
 * Retrieves the URI instance.
 *
 * This method MUST return a UriInterface instance.
 *
 * @see https://tools.ietf.org/html/rfc3986#section-4.3
 *
 * @var UriInterface
 */
protected uri;

public function getMethod(): string

public function getRequestTarget(): string;

public function getUri(): UriInterface

public function withMethod( mixed $method ): mixed;

public function withRequestTarget( mixed $requestTarget ): mixed;

public function withUri( UriInterface $uri, mixed $preserveHost = bool ): mixed;

final protected function processMethod( mixed $method = string ): string;

final protected function processUri( mixed $uri ): UriInterface;

public function __construct( string $method = string, mixed $uri = null, mixed $body = string, mixed $headers = [] );

public function createRequest( string $method, mixed $uri ): RequestInterface;

/**
 * Gets the response reason phrase associated with the status code.
 *
 * Because a reason phrase is not a required element in a response
 * status line, the reason phrase value MAY be empty. Implementations MAY
 * choose to return the default RFC 7231 recommended reason phrase (or
 * those
 * listed in the IANA HTTP Status Code Registry) for the response's
 * status code.
 *
 * @see https://tools.ietf.org/html/rfc7231#section-6
 * @see https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
 *
 * @var string
 */
protected reasonPhrase = ;

/**
 * Gets the response status code.
 *
 * The status code is a 3-digit integer result code of the server's attempt
 * to understand and satisfy the request.
 *
 * @var int
 */
protected statusCode = 200;

public function __construct( mixed $body = string, int $code = int, array $headers = [] );

public function getReasonPhrase(): string

public function getStatusCode(): int

public function withStatus( mixed $code, mixed $reasonPhrase = string ): Response;

protected function getPhrases(): array;

protected function processCode( mixed $code, mixed $phrase = string ): void;

public function createResponse( int $code = int, string $reasonPhrase = string ): ResponseInterface;

/**
 * @var Collection|CollectionInterface
 */
protected attributes;

/**
 * Retrieve cookies.
 *
 * Retrieves cookies sent by the client to the server.
 *
 * The data MUST be compatible with the structure of the $_COOKIE
 * superglobal.
 *
 * @var array
 */
protected cookieParams;

/**
 * Retrieve any parameters provided in the request body.
 *
 * If the request Content-Type is either application/x-www-form-urlencoded
 * or multipart/form-data, and the request method is POST, this method MUST
 * return the contents of $_POST.
 *
 * Otherwise, this method may return any results of deserializing
 * the request body content; as parsing returns structured content, the
 * potential types MUST be arrays or objects only. A null value indicates
 * the absence of body content.
 *
 * @var mixed
 */
protected parsedBody;

/**
 * Retrieve query string arguments.
 *
 * Retrieves the deserialized query string arguments, if any.
 *
 * Note: the query params might not be in sync with the URI or server
 * params. If you need to ensure you are only getting the original
 * values, you may need to parse the query string from
 * `getUri()->getQuery()` or from the `QUERY_STRING` server param.
 *
 * @var array
 */
protected queryParams;

/**
 * Retrieve server parameters.
 *
 * Retrieves data related to the incoming request environment,
 * typically derived from PHP's $_SERVER superglobal. The data IS NOT
 * REQUIRED to originate from $_SERVER.
 *
 * @var array
 */
protected serverParams;

/**
 * Retrieve normalized file upload data.
 *
 * This method returns upload metadata in a normalized tree, with each leaf
 * an instance of Psr\Http\Message\UploadedFileInterface.
 *
 * These values MAY be prepared from $_FILES or the message body during
 * instantiation, or MAY be injected via withUploadedFiles().
 *
 * @var array
 */
protected uploadedFiles;

public function __construct( string $method = string, mixed $uri = null, array $serverParams = [], mixed $body = string, mixed $headers = [], array $cookies = [], array $queryParams = [], array $uploadFiles = [], mixed $parsedBody = null, string $protocol = string );

public function getAttribute( mixed $name, mixed $defaultValue = null ): mixed;

public function getAttributes(): array;

public function getCookieParams(): array

public function getParsedBody(): mixed

public function getQueryParams(): array

public function getServerParams(): array

public function getUploadedFiles(): array

public function withAttribute( mixed $name, mixed $value ): ServerRequest;

public function withCookieParams( array $cookies ): ServerRequest;

public function withParsedBody( mixed $data ): ServerRequest;

public function withQueryParams( array $query ): ServerRequest;

public function withUploadedFiles( array $uploadedFiles ): ServerRequest;

public function withoutAttribute( mixed $name ): ServerRequest;

public function createServerRequest( string $method, mixed $uri, array $serverParams = [] ): ServerRequestInterface;

public function load( array $server = null, array $get = null, array $post = null, array $cookies = null, array $files = null ): ServerRequest;

protected function getHeaders();

/**
 * @var resource | null
 */
protected handle;

/**
 * @var resource | string
 */
protected stream;

public function __construct( mixed $stream, string $mode = string );

public function __destruct();

public function __toString(): string;

public function close(): void;

public function detach(): resource | null;

public function eof(): bool;

public function getContents(): string;

public function getMetadata( mixed $key = null );

public function getSize(): null | int;

public function isReadable(): bool;

public function isSeekable(): bool;

public function isWritable(): bool;

public function read( mixed $length ): string;

public function rewind(): void;

public function seek( mixed $offset, mixed $whence = int ): void;

public function setStream( mixed $stream, string $mode = string ): void;

public function tell(): int;

public function write( mixed $data ): int;

/**
 * @var string
 */
private data = ;

/**
 * @var bool
 */
private eof = false;

public function __construct();

public function __toString(): string;

public function getContents( int $length = int ): string;

public function isWritable(): bool;

public function read( mixed $length ): string;

public function __construct( mixed $mode = string );

public function __construct( mixed $mode = string );

public function createStream( string $content = string ): StreamInterface;

public function createStreamFromFile( string $filename, string $mode = string ): StreamInterface;

public function createStreamFromResource( mixed $phpResource ): StreamInterface;

/**
 * If the file has already been moved, we hold that status here
 *
 * @var bool
 */
private alreadyMoved = false;

/**
 * Retrieve the filename sent by the client.
 *
 * Do not trust the value returned by this method. A client could send
 * a malicious filename with the intention to corrupt or hack your
 * application.
 *
 * Implementations SHOULD return the value stored in the 'name' key of
 * the file in the $_FILES array.
 *
 * @var string | null
 */
private clientFilename;

/**
 * Retrieve the media type sent by the client.
 *
 * Do not trust the value returned by this method. A client could send
 * a malicious media type with the intention to corrupt or hack your
 * application.
 *
 * Implementations SHOULD return the value stored in the 'type' key of
 * the file in the $_FILES array.
 *
 * @var string | null
 */
private clientMediaType;

/**
 * Retrieve the error associated with the uploaded file.
 *
 * The return value MUST be one of PHP's UPLOAD_ERR_XXX constants.
 *
 * If the file was uploaded successfully, this method MUST return
 * UPLOAD_ERR_OK.
 *
 * Implementations SHOULD return the value stored in the 'error' key of
 * the file in the $_FILES array.
 *
 * @see https://php.net/manual/en/features.file-upload.errors.php
 *
 * @var int
 */
private error = 0;

/**
 * If the stream is a string (file name) we store it here
 *
 * @var string
 */
private fileName = ;

/**
 * Retrieve the file size.
 *
 * Implementations SHOULD return the value stored in the 'size' key of
 * the file in the $_FILES array if available, as PHP calculates this based
 * on the actual size transmitted.
 *
 * @var int | null
 */
private size;

/**
 * Holds the stream/string for the uploaded file
 *
 * @var StreamInterface|string|null
 */
private stream;

public function __construct( mixed $stream, int $size = null, int $error = int, string $clientFilename = null, string $clientMediaType = null );

public function getClientFilename(): string | null

public function getClientMediaType(): string | null

public function getError(): int

public function getSize(): int | null

public function getStream(): mixed;

public function moveTo( mixed $targetPath ): void;

public function createUploadedFile( StreamInterface $stream, int $size = null, int $error = int, string $clientFilename = null, string $clientMediaType = null ): UploadedFileInterface;

/**
 * Returns the fragment of the URL
 *
 * @return string
 */
protected fragment = ;

/**
 * Retrieve the host component of the URI.
 *
 * If no host is present, this method MUST return an empty string.
 *
 * The value returned MUST be normalized to lowercase, per RFC 3986
 * Section 3.2.2.
 *
 * @see https://tools.ietf.org/html/rfc3986#section-3.2.2
 *
 * @return string
 */
protected host = ;

/**
 * @var string
 */
protected pass = ;

/**
 * Returns the path of the URL
 *
 * @return string
 */
protected path = ;

/**
 * Retrieve the port component of the URI.
 *
 * If a port is present, and it is non-standard for the current scheme,
 * this method MUST return it as an integer. If the port is the standard
 * port used with the current scheme, this method SHOULD return null.
 *
 * If no port is present, and no scheme is present, this method MUST return
 * a null value.
 *
 * If no port is present, but a scheme is present, this method MAY return
 * the standard port for that scheme, but SHOULD return null.
 *
 * @return int|null
 */
protected port;

/**
 * Returns the query of the URL
 *
 * @return string
 */
protected query = ;

/**
 * Retrieve the scheme component of the URI.
 *
 * If no scheme is present, this method MUST return an empty string.
 *
 * The value returned MUST be normalized to lowercase, per RFC 3986
 * Section 3.1.
 *
 * The trailing ":" character is not part of the scheme and MUST NOT be
 * added.
 *
 * @see https://tools.ietf.org/html/rfc3986#section-3.1
 *
 * @return string
 */
protected scheme = https;

/**
 * @var string
 */
protected user = ;

public function __construct( string $uri = string );

public function __toString(): string;

public function getAuthority(): string;

public function getFragment()

public function getHost()

public function getPath()

public function getPort()

public function getQuery()

public function getScheme()

public function getUserInfo(): string;

public function withFragment( mixed $fragment ): Uri;

public function withHost( mixed $host ): Uri;

public function withPath( mixed $path ): Uri;

public function withPort( mixed $port ): Uri;

public function withQuery( mixed $query ): Uri;

public function withScheme( mixed $scheme ): Uri;

public function withUserInfo( mixed $user, mixed $password = null ): Uri;

public function createUri( string $uri = string ): UriInterface;

use Phalcon\Http\Request;

$request = new Request();

if ($request->isPost() && $request->isAjax()) {
    echo "Request was made using POST and AJAX";
}

// Retrieve SERVER variables
$request->getServer("HTTP_HOST");

// GET, POST, PUT, DELETE, HEAD, OPTIONS, PATCH, PURGE, TRACE, CONNECT
$request->getMethod();

// An array of languages the client accepts
$request->getLanguages();

//
private filterService;

/**
 * @var bool
 */
private httpMethodParameterOverride = false;

/**
 * @var array
 */
private queryFilters;

//
private putCache;

//
private rawBody;

/**
 * @var bool
 */
private strictHostCheck = false;

public function get( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

// Returns value from $_REQUEST["user_email"] without sanitizing
$userEmail = $request->get("user_email");

// Returns value from $_REQUEST["user_email"] with sanitizing
$userEmail = $request->get("user_email", "email");

public function getAcceptableContent(): array;

public function getBasicAuth(): array | null;

public function getBestAccept(): string;

public function getBestCharset(): string;

public function getBestLanguage(): string;

public function getClientAddress( bool $trustForwardedHeader = bool ): string | bool;

public function getClientCharsets(): array;

public function getContentType(): string | null;

public function getDigestAuth(): array;

public function getFilteredPost( string $name = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

public function getFilteredPut( string $name = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

public function getFilteredQuery( string $name = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

public function getHTTPReferer(): string;

final public function getHeader( string $header ): string;

public function getHeaders(): array;

public function getHttpHost(): string;

use Phalcon\Http\Request;

$request = new Request;

$_SERVER["HTTP_HOST"] = "example.com";
$request->getHttpHost(); // example.com

$_SERVER["HTTP_HOST"] = "example.com:8080";
$request->getHttpHost(); // example.com:8080

$request->setStrictHostCheck(true);
$_SERVER["HTTP_HOST"] = "ex=am~ple.com";
$request->getHttpHost(); // UnexpectedValueException

$_SERVER["HTTP_HOST"] = "ExAmPlE.com";
$request->getHttpHost(); // example.com

public function getHttpMethodParameterOverride(): bool

public function getJsonRawBody( bool $associative = bool ): \stdClass | array | bool;

public function getLanguages(): array;

final public function getMethod(): string;

public function getPort(): int;

public function getPost( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

// Returns value from $_POST["user_email"] without sanitizing
$userEmail = $request->getPost("user_email");

// Returns value from $_POST["user_email"] with sanitizing
$userEmail = $request->getPost("user_email", "email");

public function getPreferredIsoLocaleVariant(): string;

public function getPut( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

// Returns value from $_PUT["user_email"] without sanitizing
$userEmail = $request->getPut("user_email");

// Returns value from $_PUT["user_email"] with sanitizing
$userEmail = $request->getPut("user_email", "email");

public function getQuery( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

// Returns value from $_GET["id"] without sanitizing
$id = $request->getQuery("id");

// Returns value from $_GET["id"] with sanitizing
$id = $request->getQuery("id", "int");

// Returns value from $_GET["id"] with a default value
$id = $request->getQuery("id", null, 150);

public function getRawBody(): string;

public function getScheme(): string;

public function getServer( string $name ): string | null;

public function getServerAddress(): string;

public function getServerName(): string;

final public function getURI( bool $onlyPath = bool ): string;

// Returns /some/path?with=queryParams
$uri = $request->getURI();

// Returns /some/path
$uri = $request->getURI(true);

public function getUploadedFiles( bool $onlySuccessful = bool, bool $namedKeys = bool ): FileInterface[];

public function getUserAgent(): string;

public function has( string $name ): bool;

public function hasFiles(): bool;

final public function hasHeader( string $header ): bool;

public function hasPost( string $name ): bool;

public function hasPut( string $name ): bool;

public function hasQuery( string $name ): bool;

final public function hasServer( string $name ): bool;

public function isAjax(): bool;

public function isConnect(): bool;

public function isDelete(): bool;

public function isGet(): bool;

public function isHead(): bool;

public function isMethod( mixed $methods, bool $strict = bool ): bool;

public function isOptions(): bool;

public function isPatch(): bool;

public function isPost(): bool;

public function isPurge(): bool;

public function isPut(): bool;

public function isSecure(): bool;

public function isSoap(): bool;

public function isStrictHostCheck(): bool;

public function isTrace(): bool;

public function isValidHttpMethod( string $method ): bool;

public function numFiles( bool $onlySuccessful = bool ): long;

public function setHttpMethodParameterOverride( bool $httpMethodParameterOverride )

public function setParameterFilters( string $name, array $filters = [], array $scope = [] ): RequestInterface;

public function setStrictHostCheck( bool $flag = bool ): RequestInterface;

final protected function getBestQuality( array $qualityParts, string $name ): string;

final protected function getHelper( array $source, string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

final protected function getQualityHeader( string $serverIndex, string $name ): array;

final protected function hasFileHelper( mixed $data, bool $onlySuccessful ): long;

protected function resolveAuthorizationHeaders(): array;

final protected function smoothFiles( array $names, array $types, array $tmp_names, array $sizes, array $errors, string $prefix ): array;

use Phalcon\Mvc\Controller;

class PostsController extends Controller
{
    public function uploadAction()
    {
        // Check if the user has uploaded files
        if ($this->request->hasFiles() == true) {
            // Print the real file names and their sizes
            foreach ($this->request->getUploadedFiles() as $file) {
                echo $file->getName(), " ", $file->getSize(), "\n";
            }
        }
    }
}

/**
 * @var string|null
 */
protected error;

/**
 * @var string
 */
protected extension;

/**
 * @var string|null
 */
protected key;

//
protected name;

//
protected realType;

//
protected size;

//
protected tmp;

//
protected type;

public function __construct( array $file, mixed $key = null );

public function getError(): string|null

public function getExtension(): string

public function getKey(): string|null

public function getName(): string;

public function getRealType(): string;

public function getSize(): int;

public function getTempName(): string;

public function getType(): string;

public function isUploadedFile(): bool;

public function moveTo( string $destination ): bool;

public function getError(): string | null;

public function getName(): string;

public function getRealType(): string;

public function getSize(): int;

public function getTempName(): string;

public function getType(): string;

public function moveTo( string $destination ): bool;

public function get( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

// Returns value from $_REQUEST["user_email"] without sanitizing
$userEmail = $request->get("user_email");

// Returns value from $_REQUEST["user_email"] with sanitizing
$userEmail = $request->get("user_email", "email");

public function getAcceptableContent(): array;

public function getBasicAuth(): array | null;

public function getBestAccept(): string;

public function getBestCharset(): string;

public function getBestLanguage(): string;

public function getClientAddress( bool $trustForwardedHeader = bool ): string | bool;

public function getClientCharsets(): array;

public function getContentType(): string | null;

public function getDigestAuth(): array;

public function getHTTPReferer(): string;

public function getHeader( string $header ): string;

public function getHeaders(): array;

$_SERVER = [
    "PHP_AUTH_USER" => "phalcon",
    "PHP_AUTH_PW"   => "secret",
];

$headers = $request->getHeaders();

echo $headers["Authorization"]; // Basic cGhhbGNvbjpzZWNyZXQ=

public function getHttpHost(): string;

use Phalcon\Http\Request;

$request = new Request;

$_SERVER["HTTP_HOST"] = "example.com";
$request->getHttpHost(); // example.com

$_SERVER["HTTP_HOST"] = "example.com:8080";
$request->getHttpHost(); // example.com:8080

$request->setStrictHostCheck(true);
$_SERVER["HTTP_HOST"] = "ex=am~ple.com";
$request->getHttpHost(); // UnexpectedValueException

$_SERVER["HTTP_HOST"] = "ExAmPlE.com";
$request->getHttpHost(); // example.com

public function getJsonRawBody( bool $associative = bool ): stdClass | array | bool;

public function getLanguages(): array;

public function getMethod(): string;

public function getPort(): int;

public function getPost( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

// Returns value from $_POST["user_email"] without sanitizing
$userEmail = $request->getPost("user_email");

// Returns value from $_POST["user_email"] with sanitizing
$userEmail = $request->getPost("user_email", "email");

public function getPut( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

// Returns value from $_PUT["user_email"] without sanitizing
$userEmail = $request->getPut("user_email");

// Returns value from $_PUT["user_email"] with sanitizing
$userEmail = $request->getPut("user_email", "email");

public function getQuery( string $name = null, mixed $filters = null, mixed $defaultValue = null, bool $notAllowEmpty = bool, bool $noRecursive = bool ): mixed;

// Returns value from $_GET["id"] without sanitizing
$id = $request->getQuery("id");

// Returns value from $_GET["id"] with sanitizing
$id = $request->getQuery("id", "int");

// Returns value from $_GET["id"] with a default value
$id = $request->getQuery("id", null, 150);

public function getRawBody(): string;

public function getScheme(): string;

public function getServer( string $name ): string | null;

public function getServerAddress(): string;

public function getServerName(): string;

public function getURI( bool $onlyPath = bool ): string;

// Returns /some/path?with=queryParams
$uri = $request->getURI();

// Returns /some/path
$uri = $request->getURI(true);

public function getUploadedFiles( bool $onlySuccessful = bool, bool $namedKeys = bool ): FileInterface[];

public function getUserAgent(): string;

public function has( string $name ): bool;

public function hasFiles(): bool;

public function hasHeader( string $header ): bool;

public function hasPost( string $name ): bool;

public function hasPut( string $name ): bool;

public function hasQuery( string $name ): bool;

public function hasServer( string $name ): bool;

public function isAjax(): bool;

public function isConnect(): bool;

public function isDelete(): bool;

public function isGet(): bool;

public function isHead(): bool;

public function isMethod( mixed $methods, bool $strict = bool ): bool;

public function isOptions(): bool;

public function isPost(): bool;

public function isPurge(): bool;

public function isPut(): bool;

public function isSecure(): bool;

public function isSoap(): bool;

public function isTrace(): bool;

public function numFiles( bool $onlySuccessful = bool ): long;

$response = new \Phalcon\Http\Response();

$response->setStatusCode(200, "OK");
$response->setContent("<html><body>Hello</body></html>");

$response->send();

//
protected container;

//
protected content;

//
protected cookies;

//
protected eventsManager;

//
protected file;

//
protected headers;

/**
 * @var bool
 */
protected sent = false;

//
protected statusCodes;

public function __construct( string $content = null, mixed $code = null, mixed $status = null );

public function appendContent( mixed $content ): ResponseInterface;

public function getContent(): string;

public function getCookies(): CookiesInterface;

public function getDI(): DiInterface;

public function getEventsManager(): ManagerInterface;

public function getHeaders(): HeadersInterface;

public function getReasonPhrase(): string | null;

echo $response->getReasonPhrase();

public function getStatusCode(): int | null;

echo $response->getStatusCode();

public function hasHeader( string $name ): bool;

$response->hasHeader("Content-Type");

public function isSent(): bool;

public function redirect( mixed $location = null, bool $externalRedirect = bool, int $statusCode = int ): ResponseInterface;

// Using a string redirect (internal/external)
$response->redirect("posts/index");
$response->redirect("http://en.wikipedia.org", true);
$response->redirect("http://www.example.com/new-location", true, 301);

// Making a redirection based on a named route
$response->redirect(
    [
        "for"        => "index-lang",
        "lang"       => "jp",
        "controller" => "index",
    ]
);

public function removeHeader( string $name ): ResponseInterface;

$response->removeHeader("Expires");

public function resetHeaders(): ResponseInterface;

public function send(): ResponseInterface;

public function sendCookies(): ResponseInterface;

public function sendHeaders(): ResponseInterface | bool;

public function setCache( int $minutes ): ResponseInterface;

$this->response->setCache(60);

public function setContent( string $content ): ResponseInterface;

$response->setContent("<h1>Hello!</h1>");

public function setContentLength( int $contentLength ): ResponseInterface;

$response->setContentLength(2048);

public function setContentType( string $contentType, mixed $charset = null ): ResponseInterface;

$response->setContentType("application/pdf");
$response->setContentType("text/plain", "UTF-8");

public function setCookies( CookiesInterface $cookies ): ResponseInterface;

public function setDI( DiInterface $container ): void;

public function setEtag( string $etag ): ResponseInterface;

$response->setEtag(
    md5(
        time()
    )
);

public function setEventsManager( ManagerInterface $eventsManager ): void;

public function setExpires( DateTime $datetime ): ResponseInterface;

$this->response->setExpires(
    new DateTime()
);

public function setFileToSend( string $filePath, mixed $attachmentName = null, mixed $attachment = bool ): ResponseInterface;

public function setHeader( string $name, mixed $value ): ResponseInterface;

$response->setHeader("Content-Type", "text/plain");

public function setHeaders( HeadersInterface $headers ): ResponseInterface;