Indica si este input se debe evaluar para alguno de los tipos dados

@param string ...$types

@return bool
11745
public function isEvaluableForTypes(string ...$types): bool
    {
        if (!$this->isValid()) {
            return false;
        }

        if (is_empty($types)) {
            return true;
        }

        return Data::make($this->value)->isTypeOf(...$types);
    }
199354
private function validateType(int $type): bool
    {
        return $type === Node\Stmt\Use_::TYPE_NORMAL || $type === Node\Stmt\Use_::TYPE_UNKNOWN;
    }
841989
public static function getTypeMap(...$types): array
    {
        $map = [];
        foreach ($types as $type) {
            $map[$type] = self::getTypeDescription($type);
        }

        return $map;
    }
104006
public function hasAnyDynamicType($types)
    {
        if (\is_string($types)) {
            return isset($this->dynamicTypes[$types]);
        } else {
            foreach ($types as $type) {
                if (isset($this->dynamicTypes[$type])) {
                    return true;
                }
            }
        }

        return false;
    }
1004166
public function isType($tokenTypes)
    {
        if (is_array($tokenTypes)) {
            return in_array($this->getType(), $tokenTypes);
        }

        return $this->getType() === $tokenTypes;
    }
1160783
public function type( $types )
	{
		if( !empty( $types ) ) {
			$this->conditions[] = $this->filter->compare( '==', 'stock.type', $types );
		}

		return $this;
	}
793716
protected function supportedType($type)
    {
        $supportedType = false;

        $baseType = substr($type, 0, strpos($type, '-'));

        if (array_key_exists($baseType, $this->supportedTypes)) {
            $supportedType = $baseType;
        }

        return $supportedType;
    }
232894
public static function isOneOf($instance, array $types)
    {
        $possible = self::$typeCompatibility[gettype($instance)];

        foreach ($types as $type) {
            if (isset($possible[$type])) {
                return true;
            }
        }

        return false;
    }
130077
public function isNextAny(array $types)
    {
        if (null === $this->next) {
            return false;
        }

        foreach ($types as $type) {
            if ($type === $this->next[2]) {
                return true;
            }
        }

        return false;
    }
1170031
private static function isInternalPhpType(string $type): bool
    {
        return in_array(strtolower($type), self::$internalPhpTypes, true);
    }
1018751
private function allowedTypeExist(string $type):bool
    {
        foreach ($this->allowed_text_render as $one) {
            if ($one["type"] === $type) {
                return (true);
            }
        }
        return (false);
    }
219919
public static function isString($type): bool
    {
        return (
            \is_int($type) &&
            $type >= self::TYPE_STRING &&
            $type <= self::TYPE_VARCHAR
        );
    }
700865
private function checkType($type)
    {
        if (!empty($this->allowTypes)) {
            return in_array(strtolower($type), $this->allowTypes);
        }
        return true;
    }
439186
public function isPrimitive($types) : bool
    {
        if (!is_array($types)) {
            $types = [$types];
        }

        $primitive = false;
        $primitiveType = [
            'int',
            'int32',
            'integer',
            'float',
            'double',
            'string',
            'bool',
            'boolean',
            'array',
            '\\Cawa\\SwaggerServer\\DateTime',
        ];

        foreach ($types as $type) {
            if (in_array($type, $primitiveType)) {
                $primitive = true;
            }
        }

        return $primitive;
    }
961338
public static function isValidType($type)
    {
        if ($type === '') {
            $result = true;
        } else {
            $valid = self::getTypesInfo();
            $result = isset($valid[$type]);
        }

        return $result;
    }
588859
public function is_type($name, $value, $types){
        if(! $this->not_empty($name, $value)){
            return TRUE;
        }
        $types= explode(',', $types);
        $ok= TRUE;
        if($this->isMultiple($value)){
            foreach ($value['type'] as $type) {
                if (in_array($type, $types)){
                    $ok= FALSE;
                    break;
                }
            }
        }else{
            $ok= in_array($value['type'], $types);
        }        
        
        if($ok){
            return TRUE;
        }else{
            $this->add_message($name, 'is_type', array('types' => $types));
            return FALSE;
        }
    }
418263
public function nextIfAnyOf(array $types): bool
    {
        if (!$this->current->typeEqualsAnyOf($types)) {
            return false;
        }

        $this->next();
        return true;
    }