Copied!

This trait provides nurllOr*, all* and allNullOr* variants of assertion base methods.

Do not use this trait directly: it will change, and is not designed for reuse.

Trait
Methods
public static allAlnum( $value, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allAlpha( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allBoolean( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<bool> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allClassExists( $value, $message = '')
 
  • psalm-assert iterable<class-string> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allCount( $array, $number, $message = '')
 
  • param iterable<\Countable|array> $array
  • param int $number
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allCountBetween( $array, $min, $max, $message = '')
 
  • param iterable<\Countable|array> $array
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allDigits( $value, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allDirectory( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allEmail( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allFalse( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<false> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allFile( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allFileExists( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allFloat( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<float> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allGreaterThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allGreaterThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allImplementsInterface( $value, $interface, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $interface
  • psalm-assert iterable<class-string<ExpectedType>> $value
  • param mixed $value
  • param mixed $interface
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allInArray( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<int> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIntegerish( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<numeric> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allInterfaceExists( $value, $message = '')
 
  • psalm-assert iterable<class-string> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIp( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIpv4( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIpv6( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsAnyOf( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param iterable<object|string> $value
  • param string[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsAOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<ExpectedType|class-string<ExpectedType>> $value
  • param iterable<object|string> $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsArray( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsArrayAccessible( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array|ArrayAccess> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsCallable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<callable> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsCountable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<countable> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<empty> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<ExpectedType> $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsInstanceOfAny( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param mixed $value
  • param (object|string)[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsIterable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<iterable> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<list> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param iterable<mixed|array<T>> $array
  • psalm-assert iterable<array<string, T>> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsNonEmptyList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<non-empty-list> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsNonEmptyMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param iterable<mixed|array<T>> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsNotA( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template UnexpectedType of object
  • psalm-param class-string<UnexpectedType> $class
  • param iterable<object|string> $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsTraversable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<iterable> $value
  • deprecated use "isIterable" or "isInstanceOf" instead
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allKeyExists( $array, $key, $message = '')
 
  • psalm-pure
  • param iterable<array> $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allKeyNotExists( $array, $key, $message = '')
 
  • psalm-pure
  • param iterable<array> $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allLength( $value, $length, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param int $length
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allLengthBetween( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allLessThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allLessThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allLower( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<lowercase-string> $value
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMaxCount( $array, $max, $message = '')
 
  • param iterable<\Countable|array> $array
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMaxLength( $value, $max, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMethodExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object> $classOrObject
  • param iterable<string|object> $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMethodNotExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object> $classOrObject
  • param iterable<string|object> $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMinCount( $array, $min, $message = '')
 
  • param iterable<\Countable|array> $array
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMinLength( $value, $min, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNatural( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<positive-int|0> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotEmpty( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotFalse( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotNull( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotWhitespaceOnly( $value, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNull( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrAlnum( $value, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrAlpha( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrBoolean( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<bool|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrClassExists( $value, $message = '')
 
  • psalm-assert iterable<class-string|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrCount( $array, $number, $message = '')
 
  • param iterable<\Countable|array|null> $array
  • param int $number
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrCountBetween( $array, $min, $max, $message = '')
 
  • param iterable<\Countable|array|null> $array
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrDigits( $value, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrDirectory( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrEmail( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrFalse( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<false|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrFile( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrFileExists( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrFloat( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<float|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrGreaterThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrGreaterThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrImplementsInterface( $value, $interface, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $interface
  • psalm-assert iterable<class-string<ExpectedType>|null> $value
  • param mixed $value
  • param mixed $interface
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrInArray( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<int|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIntegerish( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<numeric|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrInterfaceExists( $value, $message = '')
 
  • psalm-assert iterable<class-string|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIp( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIpv4( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIpv6( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsAnyOf( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param iterable<object|string|null> $value
  • param string[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsAOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<ExpectedType|class-string<ExpectedType>|null> $value
  • param iterable<object|string|null> $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsArray( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsArrayAccessible( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array|ArrayAccess|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsCallable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<callable|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsCountable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<countable|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<empty|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<ExpectedType|null> $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsInstanceOfAny( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param mixed $value
  • param (object|string)[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsIterable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<iterable|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<list|null> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param iterable<mixed|array<T>|null> $array
  • psalm-assert iterable<array<string, T>|null> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsNonEmptyList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<non-empty-list|null> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsNonEmptyMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param iterable<mixed|array<T>|null> $array
  • psalm-assert iterable<array<string, T>|null> $array
  • psalm-assert iterable<!empty|null> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsNotA( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template UnexpectedType of object
  • psalm-param class-string<UnexpectedType> $class
  • psalm-assert iterable<!UnexpectedType|null> $value
  • psalm-assert iterable<!class-string<UnexpectedType>|null> $value
  • param iterable<object|string|null> $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsTraversable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<iterable|null> $value
  • deprecated use "isIterable" or "isInstanceOf" instead
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrKeyExists( $array, $key, $message = '')
 
  • psalm-pure
  • param iterable<array|null> $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrKeyNotExists( $array, $key, $message = '')
 
  • psalm-pure
  • param iterable<array|null> $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrLength( $value, $length, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param int $length
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrLengthBetween( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrLessThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrLessThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrLower( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<lowercase-string|null> $value
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMaxCount( $array, $max, $message = '')
 
  • param iterable<\Countable|array|null> $array
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMaxLength( $value, $max, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMethodExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object|null> $classOrObject
  • param iterable<string|object|null> $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMethodNotExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object|null> $classOrObject
  • param iterable<string|object|null> $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMinCount( $array, $min, $message = '')
 
  • param iterable<\Countable|array|null> $array
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMinLength( $value, $min, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNatural( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<positive-int|0|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<!empty|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotFalse( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<!false|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<!ExpectedType|null> $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotWhitespaceOnly( $value, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNumeric( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<numeric|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrObject( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<object|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrOneOf( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrPositiveInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<positive-int|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrPropertyExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object|null> $classOrObject
  • param iterable<string|object|null> $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrPropertyNotExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object|null> $classOrObject
  • param iterable<string|object|null> $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrRange( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $min
  • param mixed $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrReadable( $value, $message = '')
 
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrResource( $value, $type = NULL, $message = '')
 
public static allNullOrSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrScalar( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<scalar|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrStartsWithLetter( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrString( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<string|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrStringNotEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<non-empty-string|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrSubclassOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<class-string<ExpectedType>|ExpectedType|null> $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrThrows( $expression, $class = 'Exception', $message = '')
 
  • psalm-param class-string<Throwable> $class
  • param iterable<\Closure|null> $expression
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrTrue( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<true|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrUnicodeLetters( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrUniqueValues( $values, $message = '')
 
  • param iterable<array|null> $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrUpper( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<!lowercase-string|null> $value
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrUuid( $value, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrValidArrayKey( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array-key|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrWritable( $value, $message = '')
 
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNumeric( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<numeric> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allObject( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<object> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allOneOf( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allPositiveInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<positive-int> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allPropertyExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object> $classOrObject
  • param iterable<string|object> $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allPropertyNotExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object> $classOrObject
  • param iterable<string|object> $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allRange( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $min
  • param mixed $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allReadable( $value, $message = '')
 
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allResource( $value, $type = NULL, $message = '')
 
public static allSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allScalar( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<scalar> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allStartsWithLetter( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allString( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<string> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allStringNotEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<non-empty-string> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allSubclassOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<class-string<ExpectedType>|ExpectedType> $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allThrows( $expression, $class = 'Exception', $message = '')
 
  • psalm-param class-string<Throwable> $class
  • param iterable<\Closure> $expression
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allTrue( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<true> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allUnicodeLetters( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allUniqueValues( $values, $message = '')
 
  • param iterable<array> $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allUpper( $value, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allUuid( $value, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allValidArrayKey( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array-key> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allWritable( $value, $message = '')
 
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrAlnum( $value, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrAlpha( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrBoolean( $value, $message = '')
 
  • psalm-pure
  • psalm-assert bool|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrClassExists( $value, $message = '')
 
  • psalm-assert class-string|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrCount( $array, $number, $message = '')
 
  • param \Countable|array|null $array
  • param int $number
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrCountBetween( $array, $min, $max, $message = '')
 
  • param \Countable|array|null $array
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrDigits( $value, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrDirectory( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrEmail( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrFalse( $value, $message = '')
 
  • psalm-pure
  • psalm-assert false|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrFile( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrFileExists( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrFloat( $value, $message = '')
 
  • psalm-pure
  • psalm-assert float|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrGreaterThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrGreaterThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrImplementsInterface( $value, $interface, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $interface
  • psalm-assert class-string<ExpectedType>|null $value
  • param mixed $value
  • param mixed $interface
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrInArray( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert int|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIntegerish( $value, $message = '')
 
  • psalm-pure
  • psalm-assert numeric|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrInterfaceExists( $value, $message = '')
 
  • psalm-assert class-string|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIp( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIpv4( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIpv6( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsAnyOf( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param object|string|null $value
  • param string[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsAOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert ExpectedType|class-string<ExpectedType>|null $value
  • param object|string|null $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsArray( $value, $message = '')
 
  • psalm-pure
  • psalm-assert array|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsArrayAccessible( $value, $message = '')
 
  • psalm-pure
  • psalm-assert array|ArrayAccess|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsCallable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert callable|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsCountable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert countable|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert empty $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert ExpectedType|null $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsInstanceOfAny( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param mixed $value
  • param (object|string)[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsIterable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert list|null $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param mixed|array<T>|null $array
  • psalm-assert array<string, T>|null $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsNonEmptyList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert non-empty-list|null $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsNonEmptyMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param mixed|array<T>|null $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsNotA( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template UnexpectedType of object
  • psalm-param class-string<UnexpectedType> $class
  • param object|string|null $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsTraversable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable|null $value
  • deprecated use "isIterable" or "isInstanceOf" instead
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrKeyExists( $array, $key, $message = '')
 
  • psalm-pure
  • param array|null $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrKeyNotExists( $array, $key, $message = '')
 
  • psalm-pure
  • param array|null $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrLength( $value, $length, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param int $length
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrLengthBetween( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrLessThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrLessThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrLower( $value, $message = '')
 
  • psalm-pure
  • psalm-assert lowercase-string|null $value
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMaxCount( $array, $max, $message = '')
 
  • param \Countable|array|null $array
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMaxLength( $value, $max, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMethodExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object|null $classOrObject
  • param string|object|null $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMethodNotExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object|null $classOrObject
  • param string|object|null $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMinCount( $array, $min, $message = '')
 
  • param \Countable|array|null $array
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMinLength( $value, $min, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNatural( $value, $message = '')
 
  • psalm-pure
  • psalm-assert positive-int|0|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotEmpty( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotFalse( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotWhitespaceOnly( $value, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNumeric( $value, $message = '')
 
  • psalm-pure
  • psalm-assert numeric|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrObject( $value, $message = '')
 
  • psalm-pure
  • psalm-assert object|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrOneOf( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrPositiveInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert positive-int|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrPropertyExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object|null $classOrObject
  • param string|object|null $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrPropertyNotExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object|null $classOrObject
  • param string|object|null $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrRange( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $min
  • param mixed $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrReadable( $value, $message = '')
 
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrResource( $value, $type = NULL, $message = '')
 
public static nullOrSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrScalar( $value, $message = '')
 
  • psalm-pure
  • psalm-assert scalar|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrStartsWithLetter( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrString( $value, $message = '')
 
  • psalm-pure
  • psalm-assert string|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrStringNotEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert non-empty-string|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrSubclassOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert class-string<ExpectedType>|ExpectedType|null $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrThrows( $expression, $class = 'Exception', $message = '')
 
  • psalm-param class-string<Throwable> $class
  • param \Closure|null $expression
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrTrue( $value, $message = '')
 
  • psalm-pure
  • psalm-assert true|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrUnicodeLetters( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrUniqueValues( $values, $message = '')
 
  • param array|null $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrUpper( $value, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrUuid( $value, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrValidArrayKey( $value, $message = '')
 
  • psalm-pure
  • psalm-assert array-key|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrWritable( $value, $message = '')
 
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
Methods
public static allAlnum( $value, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allAlpha( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allBoolean( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<bool> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allClassExists( $value, $message = '')
 
  • psalm-assert iterable<class-string> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allCount( $array, $number, $message = '')
 
  • param iterable<\Countable|array> $array
  • param int $number
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allCountBetween( $array, $min, $max, $message = '')
 
  • param iterable<\Countable|array> $array
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allDigits( $value, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allDirectory( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allEmail( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allFalse( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<false> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allFile( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allFileExists( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allFloat( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<float> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allGreaterThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allGreaterThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allImplementsInterface( $value, $interface, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $interface
  • psalm-assert iterable<class-string<ExpectedType>> $value
  • param mixed $value
  • param mixed $interface
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allInArray( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<int> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIntegerish( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<numeric> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allInterfaceExists( $value, $message = '')
 
  • psalm-assert iterable<class-string> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIp( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIpv4( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIpv6( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsAnyOf( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param iterable<object|string> $value
  • param string[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsAOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<ExpectedType|class-string<ExpectedType>> $value
  • param iterable<object|string> $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsArray( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsArrayAccessible( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array|ArrayAccess> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsCallable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<callable> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsCountable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<countable> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<empty> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<ExpectedType> $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsInstanceOfAny( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param mixed $value
  • param (object|string)[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsIterable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<iterable> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<list> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param iterable<mixed|array<T>> $array
  • psalm-assert iterable<array<string, T>> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsNonEmptyList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<non-empty-list> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsNonEmptyMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param iterable<mixed|array<T>> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsNotA( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template UnexpectedType of object
  • psalm-param class-string<UnexpectedType> $class
  • param iterable<object|string> $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allIsTraversable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<iterable> $value
  • deprecated use "isIterable" or "isInstanceOf" instead
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allKeyExists( $array, $key, $message = '')
 
  • psalm-pure
  • param iterable<array> $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allKeyNotExists( $array, $key, $message = '')
 
  • psalm-pure
  • param iterable<array> $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allLength( $value, $length, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param int $length
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allLengthBetween( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allLessThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allLessThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allLower( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<lowercase-string> $value
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMaxCount( $array, $max, $message = '')
 
  • param iterable<\Countable|array> $array
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMaxLength( $value, $max, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMethodExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object> $classOrObject
  • param iterable<string|object> $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMethodNotExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object> $classOrObject
  • param iterable<string|object> $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMinCount( $array, $min, $message = '')
 
  • param iterable<\Countable|array> $array
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allMinLength( $value, $min, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNatural( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<positive-int|0> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotEmpty( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotFalse( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotNull( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNotWhitespaceOnly( $value, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNull( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrAlnum( $value, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrAlpha( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrBoolean( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<bool|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrClassExists( $value, $message = '')
 
  • psalm-assert iterable<class-string|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrCount( $array, $number, $message = '')
 
  • param iterable<\Countable|array|null> $array
  • param int $number
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrCountBetween( $array, $min, $max, $message = '')
 
  • param iterable<\Countable|array|null> $array
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrDigits( $value, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrDirectory( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrEmail( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrFalse( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<false|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrFile( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrFileExists( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrFloat( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<float|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrGreaterThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrGreaterThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrImplementsInterface( $value, $interface, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $interface
  • psalm-assert iterable<class-string<ExpectedType>|null> $value
  • param mixed $value
  • param mixed $interface
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrInArray( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<int|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIntegerish( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<numeric|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrInterfaceExists( $value, $message = '')
 
  • psalm-assert iterable<class-string|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIp( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIpv4( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIpv6( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsAnyOf( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param iterable<object|string|null> $value
  • param string[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsAOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<ExpectedType|class-string<ExpectedType>|null> $value
  • param iterable<object|string|null> $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsArray( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsArrayAccessible( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array|ArrayAccess|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsCallable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<callable|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsCountable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<countable|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<empty|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<ExpectedType|null> $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsInstanceOfAny( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param mixed $value
  • param (object|string)[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsIterable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<iterable|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<list|null> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param iterable<mixed|array<T>|null> $array
  • psalm-assert iterable<array<string, T>|null> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsNonEmptyList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<non-empty-list|null> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsNonEmptyMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param iterable<mixed|array<T>|null> $array
  • psalm-assert iterable<array<string, T>|null> $array
  • psalm-assert iterable<!empty|null> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsNotA( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template UnexpectedType of object
  • psalm-param class-string<UnexpectedType> $class
  • psalm-assert iterable<!UnexpectedType|null> $value
  • psalm-assert iterable<!class-string<UnexpectedType>|null> $value
  • param iterable<object|string|null> $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrIsTraversable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<iterable|null> $value
  • deprecated use "isIterable" or "isInstanceOf" instead
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrKeyExists( $array, $key, $message = '')
 
  • psalm-pure
  • param iterable<array|null> $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrKeyNotExists( $array, $key, $message = '')
 
  • psalm-pure
  • param iterable<array|null> $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrLength( $value, $length, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param int $length
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrLengthBetween( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrLessThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrLessThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrLower( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<lowercase-string|null> $value
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMaxCount( $array, $max, $message = '')
 
  • param iterable<\Countable|array|null> $array
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMaxLength( $value, $max, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMethodExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object|null> $classOrObject
  • param iterable<string|object|null> $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMethodNotExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object|null> $classOrObject
  • param iterable<string|object|null> $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMinCount( $array, $min, $message = '')
 
  • param iterable<\Countable|array|null> $array
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrMinLength( $value, $min, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNatural( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<positive-int|0|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<!empty|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotFalse( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<!false|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<!ExpectedType|null> $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNotWhitespaceOnly( $value, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrNumeric( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<numeric|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrObject( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<object|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrOneOf( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrPositiveInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<positive-int|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrPropertyExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object|null> $classOrObject
  • param iterable<string|object|null> $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrPropertyNotExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object|null> $classOrObject
  • param iterable<string|object|null> $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrRange( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $min
  • param mixed $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrReadable( $value, $message = '')
 
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrResource( $value, $type = NULL, $message = '')
 
public static allNullOrSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrScalar( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<scalar|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrStartsWithLetter( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrString( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<string|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrStringNotEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<non-empty-string|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrSubclassOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<class-string<ExpectedType>|ExpectedType|null> $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrThrows( $expression, $class = 'Exception', $message = '')
 
  • psalm-param class-string<Throwable> $class
  • param iterable<\Closure|null> $expression
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrTrue( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<true|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrUnicodeLetters( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrUniqueValues( $values, $message = '')
 
  • param iterable<array|null> $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrUpper( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<!lowercase-string|null> $value
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrUuid( $value, $message = '')
 
  • psalm-pure
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrValidArrayKey( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array-key|null> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNullOrWritable( $value, $message = '')
 
  • param iterable<string|null> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allNumeric( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<numeric> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allObject( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<object> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allOneOf( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allPositiveInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<positive-int> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allPropertyExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object> $classOrObject
  • param iterable<string|object> $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allPropertyNotExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param iterable<class-string|object> $classOrObject
  • param iterable<string|object> $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allRange( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $min
  • param mixed $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allReadable( $value, $message = '')
 
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allResource( $value, $type = NULL, $message = '')
 
public static allSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allScalar( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<scalar> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allStartsWithLetter( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allString( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<string> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allStringNotEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<non-empty-string> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allSubclassOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert iterable<class-string<ExpectedType>|ExpectedType> $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allThrows( $expression, $class = 'Exception', $message = '')
 
  • psalm-param class-string<Throwable> $class
  • param iterable<\Closure> $expression
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allTrue( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<true> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allUnicodeLetters( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allUniqueValues( $values, $message = '')
 
  • param iterable<array> $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allUpper( $value, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allUuid( $value, $message = '')
 
  • psalm-pure
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allValidArrayKey( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable<array-key> $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static allWritable( $value, $message = '')
 
  • param iterable<string> $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrAlnum( $value, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrAlpha( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrBoolean( $value, $message = '')
 
  • psalm-pure
  • psalm-assert bool|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrClassExists( $value, $message = '')
 
  • psalm-assert class-string|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrCount( $array, $number, $message = '')
 
  • param \Countable|array|null $array
  • param int $number
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrCountBetween( $array, $min, $max, $message = '')
 
  • param \Countable|array|null $array
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrDigits( $value, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrDirectory( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrEmail( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrFalse( $value, $message = '')
 
  • psalm-pure
  • psalm-assert false|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrFile( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrFileExists( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrFloat( $value, $message = '')
 
  • psalm-pure
  • psalm-assert float|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrGreaterThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrGreaterThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrImplementsInterface( $value, $interface, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $interface
  • psalm-assert class-string<ExpectedType>|null $value
  • param mixed $value
  • param mixed $interface
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrInArray( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert int|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIntegerish( $value, $message = '')
 
  • psalm-pure
  • psalm-assert numeric|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrInterfaceExists( $value, $message = '')
 
  • psalm-assert class-string|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIp( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIpv4( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIpv6( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsAnyOf( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param object|string|null $value
  • param string[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsAOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert ExpectedType|class-string<ExpectedType>|null $value
  • param object|string|null $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsArray( $value, $message = '')
 
  • psalm-pure
  • psalm-assert array|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsArrayAccessible( $value, $message = '')
 
  • psalm-pure
  • psalm-assert array|ArrayAccess|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsCallable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert callable|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsCountable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert countable|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert empty $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert ExpectedType|null $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsInstanceOfAny( $value, $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param mixed $value
  • param (object|string)[] $classes
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsIterable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert list|null $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param mixed|array<T>|null $array
  • psalm-assert array<string, T>|null $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsNonEmptyList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert non-empty-list|null $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsNonEmptyMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param mixed|array<T>|null $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsNotA( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template UnexpectedType of object
  • psalm-param class-string<UnexpectedType> $class
  • param object|string|null $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrIsTraversable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable|null $value
  • deprecated use "isIterable" or "isInstanceOf" instead
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrKeyExists( $array, $key, $message = '')
 
  • psalm-pure
  • param array|null $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrKeyNotExists( $array, $key, $message = '')
 
  • psalm-pure
  • param array|null $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrLength( $value, $length, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param int $length
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrLengthBetween( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrLessThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrLessThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrLower( $value, $message = '')
 
  • psalm-pure
  • psalm-assert lowercase-string|null $value
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMaxCount( $array, $max, $message = '')
 
  • param \Countable|array|null $array
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMaxLength( $value, $max, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMethodExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object|null $classOrObject
  • param string|object|null $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMethodNotExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object|null $classOrObject
  • param string|object|null $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMinCount( $array, $min, $message = '')
 
  • param \Countable|array|null $array
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrMinLength( $value, $min, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNatural( $value, $message = '')
 
  • psalm-pure
  • psalm-assert positive-int|0|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotEmpty( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotFalse( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNotWhitespaceOnly( $value, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrNumeric( $value, $message = '')
 
  • psalm-pure
  • psalm-assert numeric|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrObject( $value, $message = '')
 
  • psalm-pure
  • psalm-assert object|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrOneOf( $value, $values, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrPositiveInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert positive-int|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrPropertyExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object|null $classOrObject
  • param string|object|null $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrPropertyNotExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object|null $classOrObject
  • param string|object|null $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrRange( $value, $min, $max, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $min
  • param mixed $max
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrReadable( $value, $message = '')
 
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrResource( $value, $type = NULL, $message = '')
 
public static nullOrSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrScalar( $value, $message = '')
 
  • psalm-pure
  • psalm-assert scalar|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrStartsWithLetter( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrString( $value, $message = '')
 
  • psalm-pure
  • psalm-assert string|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrStringNotEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert non-empty-string|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrSubclassOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert class-string<ExpectedType>|ExpectedType|null $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrThrows( $expression, $class = 'Exception', $message = '')
 
  • psalm-param class-string<Throwable> $class
  • param \Closure|null $expression
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrTrue( $value, $message = '')
 
  • psalm-pure
  • psalm-assert true|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrUnicodeLetters( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrUniqueValues( $values, $message = '')
 
  • param array|null $values
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrUpper( $value, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrUuid( $value, $message = '')
 
  • psalm-pure
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrValidArrayKey( $value, $message = '')
 
  • psalm-pure
  • psalm-assert array-key|null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
public static nullOrWritable( $value, $message = '')
 
  • param string|null $value
  • param string $message
  • throws \InvalidArgumentException
  • return void
© 2024 Bruce Wells
Search Namespaces \ Classes
Configuration