Query whether or not the passed error type is fatal or not.

@param integer $type The type to query for

@return boolean TRUE if the passed type is a fatal error, else FALSE
342736
public function isFatal($type)
    {
        return in_array($type, array(E_EXCEPTION, E_PARSE,  E_ERROR, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR));
    }
1196061
public static function hasOuterArray(string $type) : bool
    {
        $type = self::normalise($type, true);

        return (substr($type, -2) === '[]');
    }
679440
public function exists($type)
    {
        foreach ($this->loaders as $loader) {
            if ($loader->exists($type)) {
                return true;
            }
        }

        return false;
    }
46056
public function isSatisfiedBy(ReturnType\TypeInterface $type)
    {
        return $type->isRealType() && Types::T_VOID == $type->getDataType();
    }
199354
private function validateType(int $type): bool
    {
        return $type === Node\Stmt\Use_::TYPE_NORMAL || $type === Node\Stmt\Use_::TYPE_UNKNOWN;
    }
169297
public function has(string $type): bool
    {
        return isset($this->values[$type]) && \count($this->values[$type]) > 0;
    }
1170031
private static function isInternalPhpType(string $type): bool
    {
        return in_array(strtolower($type), self::$internalPhpTypes, true);
    }
615455
public function errorLog($type = 'debug', $messageType = ErrorLogHandler::OPERATING_SYSTEM)
    {
        $this->pushHandler(new ErrorLogHandler($messageType, $this->getLevel($type)));
    }
275009
public function hasMessages($type)
    {
        return isset($_SESSION[$alias = $this->alias][$type]) && count($_SESSION[$alias][$type]) > 0;
    }
219919
public static function isString($type): bool
    {
        return (
            \is_int($type) &&
            $type >= self::TYPE_STRING &&
            $type <= self::TYPE_VARCHAR
        );
    }
985796
protected function logUncaughtErrors($type)
    {
        $this->logErrorTypes |= $type;

        $unhandled = E_ERROR | E_PARSE | E_CORE_ERROR | E_COMPILE_ERROR;

        if ($type & ~$unhandled) {
            $this->initErrorHandler();
        }

        if ($type & $unhandled) {
            $this->initShutdownFunction();
        }
    }
195659
public function lookaheadTypeIs(int $type): bool
    {
        return isset($this->tokens[$this->position]) && $this->tokens[$this->position]->typeEquals($type);
    }
745964
public function logUncaught($type)
    {
        if (is_int($type)) {
            $this->logUncaughtErrors($type);
        } elseif (is_string($type)) {
            $this->logUncaughtException($type);
        } else {
            throw new \InvalidArgumentException("Type should be an error code (int) or Exception class (string)");
        }
    }
560280
private function _isInheritanceType($type)
    {
        return $type == self::INHERITANCE_TYPE_NONE ||
                $type == self::INHERITANCE_TYPE_SINGLE_TABLE ||
                $type == self::INHERITANCE_TYPE_JOINED ||
                $type == self::INHERITANCE_TYPE_TABLE_PER_CLASS;
    }
560871
public function isNumeric( $type )
	{
		// BMS 2018-05-02 Changed to use resolvesToBaseType instead of relying on some property
		if ( $type instanceof QName )
		{
			// $type = $this->getType( $type->localName, $type->prefix );
			$type = "{$type->prefix}:{$type->localName}";
		}
		else if ( is_string( $type ) && isset( $this->types[ $type ] ) )
		{
			$type = $this->types[ $type ];
		}

		$result = $this->resolvesToBaseType( $type, array( 'xs:decimal', 'xs:double', 'xs:float' ) );
		return $result;

		// if ( is_array( $type ) )
		// {
		// 	return isset( $type['numeric'] ) && filter_var( $type['numeric'], FILTER_VALIDATE_BOOLEAN );
		// }
		// else
		// {
		// 	return false;
		// }
	}
293958
public static function isRefund($type)
    {
        $transactionTypesList = [
            self::REFUND,
            self::SDD_REFUND,
            self::KLARNA_REFUND,
            self::BITPAY_REFUND
        ];

        return in_array(strtolower($type), $transactionTypesList);
    }
841994
public function isType($type)
    {
        if (!$this->isTypeSupported($type)) {
            throw new Exception('Unsupported query type');
        }

        return isset($this->parsedSql[$type]);
    }