Remove validator(s)

@param string|array $validatorName
3960
public function removeValidator($validatorName)
    {
        $validators = Arr::wrap($validatorName);
        $this->resolver->remove($validators);

        foreach ($validators as $validator) {
            if (array_key_exists($validator, $this->validators)) {
                unset($this->validators[$validator]);
            }
        }
    }
515699
protected function invalidateUsername($username)
    {
        $this->_mixer->set('body', AnHelperString::str_ireplace('@'.$username, $username, $this->_mixer->body));
    }
334013
public function removeListeners(string $eventName): void
    {
        foreach ($this->dispatcher->getListeners($eventName) as $listener) {
            $this->removeListener($eventName, $listener);
        }
    }
258112
public function validateInput($inputName, $rules)
    {
        foreach ($rules as $rule) {
            $this->validateRule($rule, $inputName);
        }
    }
187853
public function remove($collectionName, array $criteria = [], array $options = []) {
		$collection = $this->getCollection($collectionName);
		
		if ($this->_profilerEnabled) {
			$message = 'db.remove(' . json_encode($criteria) . ');';
			$event   = $this->getProfiler()->startDelete($message);
		}

		$result  = $collection->remove($criteria, $options);
		$success = (bool) $result['ok'];
		
		if ($this->_profilerEnabled) {
			$success
				? $event->stopSuccess()
				: $event->stopError();
		}
		
		return $success;
	}
464842
public function remove_element($elementname) {
        if ($this->_form->elementExists($elementname)) {
            return $this->_form->removeElement($elementname);
        } else {
            return false;
        }
    }
41259
public function removeListeners($eventName = null)
    {
        if (null !== $eventName) {
            $eventName = $this->cleanEventName($eventName);
        }

        if (array_key_exists($eventName, $this->_list)) {
            unset($this->_list[$eventName]);
        } else {
            $this->_list = array();
        }
    }
1040740
protected function remove($filterOrName)
    {
        $name = $this->getNameByFilter($filterOrName);

        if ($this->has($name)) {
            unset($this->collection[$name]);

            return true;
        }

        return false;
    }
788436
public function removeAllListeners(string $eventName = null)
    {
        if (\is_null($eventName)) {
            $this->listeners = [];
            $this->wildcardListeners = [];
        } else {
            if ('*' === $eventName[\strlen($eventName) - 1]) {
                // Wildcard event
                unset($this->wildcardListeners[\substr($eventName, 0, -1)]);
            } else {
                unset($this->listeners[$eventName]);
            }
        }

        // Reset index
        $this->listenerIndex = [];
    }
165557
public function removeAttr($name)
    {
        $remove_names = \is_array($name) ? $name : explode(' ', $name);

        foreach ($this->getElements() as $node) {
            foreach ($remove_names as $remove_name) {
                $node->removeAttribute($remove_name);
            }
        }

        return $this;
    }
283189
protected function validate($name, $value, $validators = null)
    {
        if (empty($validators)) {
            $validators = @$this->fieldValidators[$name];
        }
        $failedValidations = array();

        if (!empty($validators)) {
            foreach ($validators as $type) {
                Logger::get()->debug("Validating $name with $type...");
                $validator = Validators::get($type);
                if (!$validator->isValid($value)) {
                    Logger::get()->debug('Failed!');
                    // The validation has failed, report its data.
                    $failedValidations[] = $validator->getFailMessage();
                }
            }
        }

        return $failedValidations;
    }
40579
public function remove($fieldName)
    {
        $key = array_search($fieldName, $this->fieldList);

        if ($key !== false) {
            unset($this->fieldList[$key]);
        }
    }
674752
public function removeGroup($groupName)
    {

		if(isset($this->groups[$groupName])){
			foreach($this->groups[$groupName]['elements'] as $element){
				$this->removeElement($element);
			}
			unset($this->groups[$groupName]);
		}

    }
467314
public function validate($model, $validators = null)
    {
        if (isset($validators) && is_array($validators)) {
            $validation = $this->validateArray($model, $validators);
        } else {
            $validation = $this->validateModel($model);
        }
        if ($validation) {
            $errors = $validation->validate($model);
            if (count($errors)) {
                throw new ValidationException($errors);
            }
        }
    }
591107
public function remove($validator = ''): Chain
    {
        if (!\is_string($validator)) {
            throw new InvalidArgumentException('Validator name must be a string');
        }
        if (isset($this->chain[$validator])) {
            unset($this->chain[$validator]);
        }
        return $this;
    }
638872
public function remove($name)
    {
        $names = (array)$name;

        foreach ($names as $name) {
            if (Arr::key($name, $this->_assets)) {
                unset($this->_assets[$name]);
            }
        }
    }
1289778
public function hasValidator($validators, $attribute)
    {
        $validators = is_array($validators) ? $validators : [$validators];

        foreach ($this->rules() as $rule){
            $attributes = is_array($rule[0]) ? $rule[0] : [$rule[0]];
            if(in_array($attribute, $attributes) && in_array($rule[1], $validators)){
                return true;
            }
        }

        return false;
    }