Verify if a type exist.

@param string $name

@return bool
334476
public function typeExist($name)
    {
        $type = $this->type->findOneBy(['name' => $name]);

        if (is_object($type)) {
            return true;
        }

        return false;
    }
732848
public function exists($name)
    {
        $loader = $this->environment->getLoader();

        try {
            $loader->getSource((string) $name);
        } catch (\Twig_Error_Loader $e) {
            return false;
        }

        return true;
    }
506861
public function hasProperty($name)
    {
        if (strstr($name, '.')) {
            $exists = false;
            @eval('$exists = @isset('.$this->resolveArrayPath($name).');');

            return $exists;
        }

        if ($this->isArray()) {
            return @isset($this->object[$name]);
        } else {
            return @isset($this->object->$name);
        }
    }
710259
public function isArgument($name) {
        if (!is_string($name)) throw new IllegalTypeException('Illegal type of parameter $name: '.gettype($name));
        if (!$this->docoptResult)
            return false;

        if (!($len=strlen($name)) || !isset($this->docoptResult[$name]))
            return false;

        $isBracketed = ('<'==$name[0] && $name[$len-1]=='>');
        $isUpperCase = ($name == strtoupper($name));

        return ($isBracketed || $isUpperCase);
    }
354479
private function hasProperty(string $name): bool
    {
        if (!isset($this->index[PropertyBinding::TYPE])) {
            return false;
        }

        return $this->index[PropertyBinding::TYPE]->hasProperty($name);
    }
1230091
public function has($name)
    {
        foreach ($this->filters() as $filter) {
            if ($filter->id() === $name) {
                return true;
            }
        }

        return false;
    }
1226528
public function has($name)
    {
        if (! isset($this->instances[$name])) {
            return isset($this->registry[$name]);
        }

        return true;
    }
893996
public function exists($name)
    {
        $viewblocks = $this->get('viewblocks', []);

        return !empty($viewblocks[$name]) || $this->Blocks->exists($name);
    }
721938
public function has($name)
    {
        $tid = $this->getTid($name);
        if (!isset($this->_containers[$tid])) {
            return false;
        }
        return $this->_containers[$tid]->has($name);
    }
528312
protected function exists($name): bool
    {
        return
            isset($this->___data___[$name]) ||
            \array_key_exists($name, $this->___data___);
    }
367487
public function nestedTypes($name)
    {
        if (!is_string($name)) {
            throw new InvalidArgumentException('nestedTypes name must string.');
        }
        $matches = [];

        if (preg_match_all('/(\[[0-9]*\])/', $name, $matches, PREG_PATTERN_ORDER) >= 1) {
            return $matches[0];
        }
        return false;
    }
24194
public static function exists( string $name ): bool
	{
		if( $name === "@core" )
		{
			return true;
		}

		try {
			$row = self::getModuleScheme($name, false, ["id"]);
		}
		catch(NotFoundException $e) {
			return false;
		}

		return $row->id > 0;
	}
603849
public function exists(?string $name = null): bool
    {
        if ($name != null) {
            $fileInfo = new MFileInfo($name);
            return $fileInfo->exists();
        }

        return $this->fileInfo->exists();
    }
505334
public function has($name)
    {
        Types::assert(['string' => [$name]]);

        return array_key_exists(strtolower($name), $this->headers);
    }
145639
public function has(string $name) : bool
    {
        foreach ($this->tags as $tag) {
            if ($tag->name == $name) {
                return true;
            }
        }

        return false;
    }
659049
public static function has($name)
    {
        //convert FQN into type,
        //allowing the use of FQN for GraphQL scalar types
        if (class_exists($name) || interface_exists($name)) {
            if (\in_array($name, self::$typesMap, true)) {
                $name = array_flip(self::$typesMap)[$name];
            }
        }

        if (!array_key_exists($name, self::$types) && array_key_exists($name, self::$typesMap)) {
            static::create($name);
        }

        return array_key_exists($name, self::$types);
    }
28978
public function hasProperty($name)
    {
        static $vars = null;
        if (! $vars) {
            $vars = get_object_vars($this);
        }

        return array_key_exists($name, $vars);
    }