@param int $type

@return bool
773319
public static function isValid(int $type) : bool
    {
        return in_array($type, [self::UNKNOWN, self::STANDARD, self::FULL, self::LITE], true);
    }
269830
private function isEquivalentTo(string $type): bool
    {
        $equivalents = self::EQUIVALENT_TYPES_METHODS;

        if (!isset($equivalents[$type])) {
            return false;
        }

        $method = $equivalents[$type];

        return call_user_func([$this, $method]);
    }
169297
public function has(string $type): bool
    {
        return isset($this->values[$type]) && \count($this->values[$type]) > 0;
    }
485282
private function isFixableReturnType(string $type): bool
    {
        // $type === null is not valid in our slevomat helper.
        return TypeHintHelper::isSimpleTypeHint($type) || $type === 'null' || $this->isCustomArrayType($type);
    }
405474
public function removeDeniedMimeType($type)
    {
        $key = array_search($type, $this->deniedMimeTypes);
        if ($key !== false) {
            unset($this->deniedMimeTypes[$key]);
            return true;
        }

        return false;
    }
998677
public function removeAllowedMimeType($type)
    {
        $key = array_search($type, $this->allowedMimeTypes);
        if ($key !== false) {
            unset($this->allowedMimeTypes[$key]);
            return true;
        }


        return false;
    }
902367
public function isValidType(?string $type): bool
    {
        return
            null === $type ||
            \class_exists($type) ||
            \interface_exists($type) ||
            \in_array($type, $this->getValidTypes());
    }
956531
public function isSatisfiedBy(ReturnType\TypeInterface $type)
    {
        return $this->left->isSatisfiedBy($type) && $this->right->isSatisfiedBy($type);
    }
219919
public static function isString($type): bool
    {
        return (
            \is_int($type) &&
            $type >= self::TYPE_STRING &&
            $type <= self::TYPE_VARCHAR
        );
    }
827652
public static function isAllowed($type){
        return (!empty($type) && (in_array($type, self::$allowedTypes))) || self::isAssessmentItem($type) || self::isAssessmentTest($type);
    }
1355291
private function isSimpleType(string $type): bool
    {
        $validTypes = [
            'int',
            'string',
            'bool',
            'double',
            'float',
            'array',
            'DataProviderInterface',
            'DataProviderInterface[]',
            DataProviderInterface::class,
            DataProviderInterface::class . '[]'
        ];

        return \in_array($type, $validTypes, true);
    }
510779
public function nextIfLookahead(int $type): bool
    {
        if (!isset($this->tokens[$this->position]) || !$this->tokens[$this->position]->typeEquals($type)) {
            return false;
        }

        $this->next();
        return true;
    }
1226938
public function hasFlagsOfType($type)
    {
        if ($this->flags === null) {
            return false;
        }

        foreach ($this->flags as $flag) {
            if ($flag->type == $type) {
                return true;
            }
        }

        return false;
    }
1083972
private function hasHandlers(string $type): bool
    {
        return isset($this->handlers[$type]) && count($this->handlers[$type]) > 0;
    }
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));
    }
894310
public function setType($type = '')
    {
        $this->type = empty($type) ? RouteType::NORMAL : $type;
        return true;
    }
237997
private function isContainer(Type $type): bool
    {
        foreach ($type->getReferencedClasses() as $referencedClass) {
            $isClassOrInterface = class_exists($referencedClass) || interface_exists($referencedClass);
            if ($isClassOrInterface && (new ReflectionClass($referencedClass))->implementsInterface(Container::class)) {
                return true;
            }
        }

        return false;
    }