PHPFUI/InstaDoc
 
Copied!

Efficient assertions to validate the input/output of your methods.

Cloneable
Methods
public static __callStatic( $name, $arguments)
 
  • throws \BadMethodCallException
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 alnum( $value, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static alpha( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static boolean( $value, $message = '')
 
  • psalm-pure
  • psalm-assert bool $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static classExists( $value, $message = '')
 
  • psalm-assert class-string $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static contains( $value, $subString, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
public static count( $array, $number, $message = '')
 

Does not check if $array is countable, this can generate a warning on php versions after 7.2.

  • param \Countable|array $array
  • param int $number
  • param string $message
  • throws \InvalidArgumentException
public static countBetween( $array, $min, $max, $message = '')
 

Does not check if $array is countable, this can generate a warning on php versions after 7.2.

  • param \Countable|array $array
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
public static digits( $value, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static directory( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static email( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static endsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
public static eq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
public static false( $value, $message = '')
 
  • psalm-pure
  • psalm-assert false $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static file( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static fileExists( $value, $message = '')
 

Will also pass if $value is a directory, use Assert::file() instead if you need to be sure it is a file.

  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static float( $value, $message = '')
 
  • psalm-pure
  • psalm-assert float $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static greaterThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
public static greaterThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
public static implementsInterface( $value, $interface, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $interface
  • psalm-assert class-string<ExpectedType> $value
  • param mixed $value
  • param mixed $interface
  • param string $message
  • throws \InvalidArgumentException
public static inArray( $value, array $values, $message = '')
 

Does strict comparison, so Assert::inArray(3, ['3']) does not pass the assertion.

  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
public static integer( $value, $message = '')
 
  • psalm-pure
  • psalm-assert int $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static integerish( $value, $message = '')
 
  • psalm-pure
  • psalm-assert numeric $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static interfaceExists( $value, $message = '')
 
  • psalm-assert class-string $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static ip( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static ipv4( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static ipv6( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isAnyOf( $value, array $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param object|string $value
  • param string[] $classes
  • param string $message
  • throws \InvalidArgumentException
public static isAOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert ExpectedType|class-string<ExpectedType> $value
  • param object|string $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
public static isArray( $value, $message = '')
 
  • psalm-pure
  • psalm-assert array $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isArrayAccessible( $value, $message = '')
 
  • psalm-pure
  • psalm-assert array|ArrayAccess $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isCallable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert callable $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isCountable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert countable $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert empty $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert ExpectedType $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
public static isInstanceOfAny( $value, array $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param mixed $value
  • param (object|string)[] $classes
  • param string $message
  • throws \InvalidArgumentException
public static isIterable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert list $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
public static isMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param mixed|array<T> $array
  • psalm-assert array<string, T> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
public static isNonEmptyList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert non-empty-list $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
public static isNonEmptyMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param mixed|array<T> $array
  • psalm-assert array<string, T> $array
  • psalm-assert !empty $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
public static isNotA( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template UnexpectedType of object
  • psalm-param class-string<UnexpectedType> $class
  • psalm-assert !UnexpectedType $value
  • psalm-assert !class-string<UnexpectedType> $value
  • param object|string $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
public static isTraversable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable $value
  • deprecated use "isIterable" or "isInstanceOf" instead
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static keyExists( $array, $key, $message = '')
 
  • psalm-pure
  • param array $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
public static keyNotExists( $array, $key, $message = '')
 
  • psalm-pure
  • param array $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
public static length( $value, $length, $message = '')
 
  • psalm-pure
  • param string $value
  • param int $length
  • param string $message
  • throws \InvalidArgumentException
public static lengthBetween( $value, $min, $max, $message = '')
 

Inclusive , so Assert::lengthBetween('asd', 3, 5); passes the assertion.

  • psalm-pure
  • param string $value
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
public static lessThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
public static lessThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
public static lower( $value, $message = '')
 
  • psalm-pure
  • psalm-assert lowercase-string $value
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static maxCount( $array, $max, $message = '')
 

Does not check if $array is countable, this can generate a warning on php versions after 7.2.

  • param \Countable|array $array
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
public static maxLength( $value, $max, $message = '')
 

Inclusive max.

  • psalm-pure
  • param string $value
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
public static methodExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object $classOrObject
  • param string|object $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
public static methodNotExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object $classOrObject
  • param string|object $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
public static minCount( $array, $min, $message = '')
 

Does not check if $array is countable, this can generate a warning on php versions after 7.2.

  • param \Countable|array $array
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
public static minLength( $value, $min, $message = '')
 

Inclusive min.

  • psalm-pure
  • param string $value
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
public static natural( $value, $message = '')
 
  • psalm-pure
  • psalm-assert positive-int|0 $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static notContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
public static notEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert !empty $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static notEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
public static notEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
public static notFalse( $value, $message = '')
 
  • psalm-pure
  • psalm-assert !false $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static notInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert !ExpectedType $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
public static notNull( $value, $message = '')
 
  • psalm-pure
  • psalm-assert !null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static notRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
public static notSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
public static notStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
public static notWhitespaceOnly( $value, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static null( $value, $message = '')
 
  • psalm-pure
  • psalm-assert null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
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
public static numeric( $value, $message = '')
 
  • psalm-pure
  • psalm-assert numeric $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static object( $value, $message = '')
 
  • psalm-pure
  • psalm-assert object $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static oneOf( $value, array $values, $message = '')
 

A more human-readable alias of Assert::inArray().

  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
public static positiveInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert positive-int $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static propertyExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object $classOrObject
  • param string|object $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
public static propertyNotExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object $classOrObject
  • param string|object $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
public static range( $value, $min, $max, $message = '')
 

Inclusive range, so Assert::(3, 3, 5) passes.

  • psalm-pure
  • param mixed $value
  • param mixed $min
  • param mixed $max
  • param string $message
  • throws \InvalidArgumentException
public static readable( $value, $message = '')
 
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static regex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
public static resource( $value, $type = NULL, $message = '')
 
public static same( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
public static scalar( $value, $message = '')
 
  • psalm-pure
  • psalm-assert scalar $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static startsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
public static startsWithLetter( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static string( $value, $message = '')
 
  • psalm-pure
  • psalm-assert string $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static stringNotEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert non-empty-string $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static subclassOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert class-string<ExpectedType>|ExpectedType $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
public static throws(Closure $expression, $class = 'Exception', $message = '')
 
  • psalm-param class-string<Throwable> $class
  • param \Closure $expression
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
public static true( $value, $message = '')
 
  • psalm-pure
  • psalm-assert true $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static unicodeLetters( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static uniqueValues(array $values, $message = '')
 

Does non strict comparisons on the items, so ['3', 3] will not pass the assertion.

  • param array $values
  • param string $message
  • throws \InvalidArgumentException
public static upper( $value, $message = '')
 
  • psalm-pure
  • psalm-assert !lowercase-string $value
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static uuid( $value, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static validArrayKey( $value, $message = '')
 

Checks if a value is a valid array key (int or string).

  • psalm-pure
  • psalm-assert array-key $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static writable( $value, $message = '')
 
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
Methods
protected static reportInvalidArgument( $message)
 
  • param string $message
  • throws \InvalidArgumentException
  • psalm-pure this method is not supposed to perform side-effects
  • psalm-return never
protected static strlen( $value)
protected static typeToString( $value)
 
  • param mixed $value
  • return string
protected static valueToString( $value)
 
  • param mixed $value
  • return string
Methods
private __construct()
Methods
public static __callStatic( $name, $arguments)
 
  • throws \BadMethodCallException
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 alnum( $value, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static alpha( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static boolean( $value, $message = '')
 
  • psalm-pure
  • psalm-assert bool $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static classExists( $value, $message = '')
 
  • psalm-assert class-string $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static contains( $value, $subString, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
public static count( $array, $number, $message = '')
 

Does not check if $array is countable, this can generate a warning on php versions after 7.2.

  • param \Countable|array $array
  • param int $number
  • param string $message
  • throws \InvalidArgumentException
public static countBetween( $array, $min, $max, $message = '')
 

Does not check if $array is countable, this can generate a warning on php versions after 7.2.

  • param \Countable|array $array
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
public static digits( $value, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static directory( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static email( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static endsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
public static eq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
public static false( $value, $message = '')
 
  • psalm-pure
  • psalm-assert false $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static file( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static fileExists( $value, $message = '')
 

Will also pass if $value is a directory, use Assert::file() instead if you need to be sure it is a file.

  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static float( $value, $message = '')
 
  • psalm-pure
  • psalm-assert float $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static greaterThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
public static greaterThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
public static implementsInterface( $value, $interface, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $interface
  • psalm-assert class-string<ExpectedType> $value
  • param mixed $value
  • param mixed $interface
  • param string $message
  • throws \InvalidArgumentException
public static inArray( $value, array $values, $message = '')
 

Does strict comparison, so Assert::inArray(3, ['3']) does not pass the assertion.

  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
public static integer( $value, $message = '')
 
  • psalm-pure
  • psalm-assert int $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static integerish( $value, $message = '')
 
  • psalm-pure
  • psalm-assert numeric $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static interfaceExists( $value, $message = '')
 
  • psalm-assert class-string $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static ip( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static ipv4( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static ipv6( $value, $message = '')
 
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isAnyOf( $value, array $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param object|string $value
  • param string[] $classes
  • param string $message
  • throws \InvalidArgumentException
public static isAOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert ExpectedType|class-string<ExpectedType> $value
  • param object|string $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
public static isArray( $value, $message = '')
 
  • psalm-pure
  • psalm-assert array $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isArrayAccessible( $value, $message = '')
 
  • psalm-pure
  • psalm-assert array|ArrayAccess $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isCallable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert callable $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isCountable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert countable $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert empty $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert ExpectedType $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
public static isInstanceOfAny( $value, array $classes, $message = '')
 
  • psalm-pure
  • psalm-param array<class-string> $classes
  • param mixed $value
  • param (object|string)[] $classes
  • param string $message
  • throws \InvalidArgumentException
public static isIterable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static isList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert list $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
public static isMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param mixed|array<T> $array
  • psalm-assert array<string, T> $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
public static isNonEmptyList( $array, $message = '')
 
  • psalm-pure
  • psalm-assert non-empty-list $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
public static isNonEmptyMap( $array, $message = '')
 
  • psalm-pure
  • psalm-template T
  • psalm-param mixed|array<T> $array
  • psalm-assert array<string, T> $array
  • psalm-assert !empty $array
  • param mixed $array
  • param string $message
  • throws \InvalidArgumentException
public static isNotA( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template UnexpectedType of object
  • psalm-param class-string<UnexpectedType> $class
  • psalm-assert !UnexpectedType $value
  • psalm-assert !class-string<UnexpectedType> $value
  • param object|string $value
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
public static isTraversable( $value, $message = '')
 
  • psalm-pure
  • psalm-assert iterable $value
  • deprecated use "isIterable" or "isInstanceOf" instead
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static keyExists( $array, $key, $message = '')
 
  • psalm-pure
  • param array $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
public static keyNotExists( $array, $key, $message = '')
 
  • psalm-pure
  • param array $array
  • param string|int $key
  • param string $message
  • throws \InvalidArgumentException
public static length( $value, $length, $message = '')
 
  • psalm-pure
  • param string $value
  • param int $length
  • param string $message
  • throws \InvalidArgumentException
public static lengthBetween( $value, $min, $max, $message = '')
 

Inclusive , so Assert::lengthBetween('asd', 3, 5); passes the assertion.

  • psalm-pure
  • param string $value
  • param int|float $min
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
public static lessThan( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
public static lessThanEq( $value, $limit, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $limit
  • param string $message
  • throws \InvalidArgumentException
public static lower( $value, $message = '')
 
  • psalm-pure
  • psalm-assert lowercase-string $value
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static maxCount( $array, $max, $message = '')
 

Does not check if $array is countable, this can generate a warning on php versions after 7.2.

  • param \Countable|array $array
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
public static maxLength( $value, $max, $message = '')
 

Inclusive max.

  • psalm-pure
  • param string $value
  • param int|float $max
  • param string $message
  • throws \InvalidArgumentException
public static methodExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object $classOrObject
  • param string|object $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
public static methodNotExists( $classOrObject, $method, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object $classOrObject
  • param string|object $classOrObject
  • param mixed $method
  • param string $message
  • throws \InvalidArgumentException
public static minCount( $array, $min, $message = '')
 

Does not check if $array is countable, this can generate a warning on php versions after 7.2.

  • param \Countable|array $array
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
public static minLength( $value, $min, $message = '')
 

Inclusive min.

  • psalm-pure
  • param string $value
  • param int|float $min
  • param string $message
  • throws \InvalidArgumentException
public static natural( $value, $message = '')
 
  • psalm-pure
  • psalm-assert positive-int|0 $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static notContains( $value, $subString, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $subString
  • param string $message
  • throws \InvalidArgumentException
public static notEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert !empty $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static notEndsWith( $value, $suffix, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $suffix
  • param string $message
  • throws \InvalidArgumentException
public static notEq( $value, $expect, $message = '')
 
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
public static notFalse( $value, $message = '')
 
  • psalm-pure
  • psalm-assert !false $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static notInstanceOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert !ExpectedType $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
public static notNull( $value, $message = '')
 
  • psalm-pure
  • psalm-assert !null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static notRegex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
public static notSame( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
public static notStartsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
public static notWhitespaceOnly( $value, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static null( $value, $message = '')
 
  • psalm-pure
  • psalm-assert null $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
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
public static numeric( $value, $message = '')
 
  • psalm-pure
  • psalm-assert numeric $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static object( $value, $message = '')
 
  • psalm-pure
  • psalm-assert object $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static oneOf( $value, array $values, $message = '')
 

A more human-readable alias of Assert::inArray().

  • psalm-pure
  • param mixed $value
  • param array $values
  • param string $message
  • throws \InvalidArgumentException
public static positiveInteger( $value, $message = '')
 
  • psalm-pure
  • psalm-assert positive-int $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static propertyExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object $classOrObject
  • param string|object $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
public static propertyNotExists( $classOrObject, $property, $message = '')
 
  • psalm-pure
  • psalm-param class-string|object $classOrObject
  • param string|object $classOrObject
  • param mixed $property
  • param string $message
  • throws \InvalidArgumentException
public static range( $value, $min, $max, $message = '')
 

Inclusive range, so Assert::(3, 3, 5) passes.

  • psalm-pure
  • param mixed $value
  • param mixed $min
  • param mixed $max
  • param string $message
  • throws \InvalidArgumentException
public static readable( $value, $message = '')
 
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static regex( $value, $pattern, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $pattern
  • param string $message
  • throws \InvalidArgumentException
protected static reportInvalidArgument( $message)
 
  • param string $message
  • throws \InvalidArgumentException
  • psalm-pure this method is not supposed to perform side-effects
  • psalm-return never
public static resource( $value, $type = NULL, $message = '')
 
public static same( $value, $expect, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param mixed $expect
  • param string $message
  • throws \InvalidArgumentException
public static scalar( $value, $message = '')
 
  • psalm-pure
  • psalm-assert scalar $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static startsWith( $value, $prefix, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $prefix
  • param string $message
  • throws \InvalidArgumentException
public static startsWithLetter( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static string( $value, $message = '')
 
  • psalm-pure
  • psalm-assert string $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static stringNotEmpty( $value, $message = '')
 
  • psalm-pure
  • psalm-assert non-empty-string $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
protected static strlen( $value)
public static subclassOf( $value, $class, $message = '')
 
  • psalm-pure
  • psalm-template ExpectedType of object
  • psalm-param class-string<ExpectedType> $class
  • psalm-assert class-string<ExpectedType>|ExpectedType $value
  • param mixed $value
  • param string|object $class
  • param string $message
  • throws \InvalidArgumentException
public static throws(Closure $expression, $class = 'Exception', $message = '')
 
  • psalm-param class-string<Throwable> $class
  • param \Closure $expression
  • param string $class
  • param string $message
  • throws \InvalidArgumentException
public static true( $value, $message = '')
 
  • psalm-pure
  • psalm-assert true $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
protected static typeToString( $value)
 
  • param mixed $value
  • return string
public static unicodeLetters( $value, $message = '')
 
  • psalm-pure
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
public static uniqueValues(array $values, $message = '')
 

Does non strict comparisons on the items, so ['3', 3] will not pass the assertion.

  • param array $values
  • param string $message
  • throws \InvalidArgumentException
public static upper( $value, $message = '')
 
  • psalm-pure
  • psalm-assert !lowercase-string $value
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static uuid( $value, $message = '')
 
  • psalm-pure
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
public static validArrayKey( $value, $message = '')
 

Checks if a value is a valid array key (int or string).

  • psalm-pure
  • psalm-assert array-key $value
  • param mixed $value
  • param string $message
  • throws \InvalidArgumentException
protected static valueToString( $value)
 
  • param mixed $value
  • return string
public static writable( $value, $message = '')
 
  • param string $value
  • param string $message
  • throws \InvalidArgumentException
© 2025 Bruce Wells
Search Namespaces \ Classes
Configuration