[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  /**
   4   * provides type inference and auto-completion for magic static methods of Assert.
   5   */
   6  
   7  namespace Webmozart\Assert;
   8  
   9  use ArrayAccess;
  10  use Closure;
  11  use Countable;
  12  use Throwable;
  13  
  14  /**
  15   * This trait aids static analysis tooling in introspecting assertion magic methods.
  16   * Do not use this trait directly: it will change, and is not designed for reuse.
  17   */
  18  trait Mixin
  19  {
  20      /**
  21       * @psalm-pure
  22       * @psalm-assert string|null $value
  23       *
  24       * @param mixed  $value
  25       * @param string $message
  26       *
  27       * @throws InvalidArgumentException
  28       *
  29       * @return void
  30       */
  31      public static function nullOrString($value, $message = '')
  32      {
  33          static::__callStatic('nullOrString', array($value, $message));
  34      }
  35  
  36      /**
  37       * @psalm-pure
  38       * @psalm-assert iterable<string> $value
  39       *
  40       * @param mixed  $value
  41       * @param string $message
  42       *
  43       * @throws InvalidArgumentException
  44       *
  45       * @return void
  46       */
  47      public static function allString($value, $message = '')
  48      {
  49          static::__callStatic('allString', array($value, $message));
  50      }
  51  
  52      /**
  53       * @psalm-pure
  54       * @psalm-assert non-empty-string|null $value
  55       *
  56       * @param mixed  $value
  57       * @param string $message
  58       *
  59       * @throws InvalidArgumentException
  60       *
  61       * @return void
  62       */
  63      public static function nullOrStringNotEmpty($value, $message = '')
  64      {
  65          static::__callStatic('nullOrStringNotEmpty', array($value, $message));
  66      }
  67  
  68      /**
  69       * @psalm-pure
  70       * @psalm-assert iterable<non-empty-string> $value
  71       *
  72       * @param mixed  $value
  73       * @param string $message
  74       *
  75       * @throws InvalidArgumentException
  76       *
  77       * @return void
  78       */
  79      public static function allStringNotEmpty($value, $message = '')
  80      {
  81          static::__callStatic('allStringNotEmpty', array($value, $message));
  82      }
  83  
  84      /**
  85       * @psalm-pure
  86       * @psalm-assert int|null $value
  87       *
  88       * @param mixed  $value
  89       * @param string $message
  90       *
  91       * @throws InvalidArgumentException
  92       *
  93       * @return void
  94       */
  95      public static function nullOrInteger($value, $message = '')
  96      {
  97          static::__callStatic('nullOrInteger', array($value, $message));
  98      }
  99  
 100      /**
 101       * @psalm-pure
 102       * @psalm-assert iterable<int> $value
 103       *
 104       * @param mixed  $value
 105       * @param string $message
 106       *
 107       * @throws InvalidArgumentException
 108       *
 109       * @return void
 110       */
 111      public static function allInteger($value, $message = '')
 112      {
 113          static::__callStatic('allInteger', array($value, $message));
 114      }
 115  
 116      /**
 117       * @psalm-pure
 118       * @psalm-assert numeric|null $value
 119       *
 120       * @param mixed  $value
 121       * @param string $message
 122       *
 123       * @throws InvalidArgumentException
 124       *
 125       * @return void
 126       */
 127      public static function nullOrIntegerish($value, $message = '')
 128      {
 129          static::__callStatic('nullOrIntegerish', array($value, $message));
 130      }
 131  
 132      /**
 133       * @psalm-pure
 134       * @psalm-assert iterable<numeric> $value
 135       *
 136       * @param mixed  $value
 137       * @param string $message
 138       *
 139       * @throws InvalidArgumentException
 140       *
 141       * @return void
 142       */
 143      public static function allIntegerish($value, $message = '')
 144      {
 145          static::__callStatic('allIntegerish', array($value, $message));
 146      }
 147  
 148      /**
 149       * @psalm-pure
 150       * @psalm-assert positive-int|null $value
 151       *
 152       * @param mixed  $value
 153       * @param string $message
 154       *
 155       * @throws InvalidArgumentException
 156       *
 157       * @return void
 158       */
 159      public static function nullOrPositiveInteger($value, $message = '')
 160      {
 161          static::__callStatic('nullOrPositiveInteger', array($value, $message));
 162      }
 163  
 164      /**
 165       * @psalm-pure
 166       * @psalm-assert iterable<positive-int> $value
 167       *
 168       * @param mixed  $value
 169       * @param string $message
 170       *
 171       * @throws InvalidArgumentException
 172       *
 173       * @return void
 174       */
 175      public static function allPositiveInteger($value, $message = '')
 176      {
 177          static::__callStatic('allPositiveInteger', array($value, $message));
 178      }
 179  
 180      /**
 181       * @psalm-pure
 182       * @psalm-assert float|null $value
 183       *
 184       * @param mixed  $value
 185       * @param string $message
 186       *
 187       * @throws InvalidArgumentException
 188       *
 189       * @return void
 190       */
 191      public static function nullOrFloat($value, $message = '')
 192      {
 193          static::__callStatic('nullOrFloat', array($value, $message));
 194      }
 195  
 196      /**
 197       * @psalm-pure
 198       * @psalm-assert iterable<float> $value
 199       *
 200       * @param mixed  $value
 201       * @param string $message
 202       *
 203       * @throws InvalidArgumentException
 204       *
 205       * @return void
 206       */
 207      public static function allFloat($value, $message = '')
 208      {
 209          static::__callStatic('allFloat', array($value, $message));
 210      }
 211  
 212      /**
 213       * @psalm-pure
 214       * @psalm-assert numeric|null $value
 215       *
 216       * @param mixed  $value
 217       * @param string $message
 218       *
 219       * @throws InvalidArgumentException
 220       *
 221       * @return void
 222       */
 223      public static function nullOrNumeric($value, $message = '')
 224      {
 225          static::__callStatic('nullOrNumeric', array($value, $message));
 226      }
 227  
 228      /**
 229       * @psalm-pure
 230       * @psalm-assert iterable<numeric> $value
 231       *
 232       * @param mixed  $value
 233       * @param string $message
 234       *
 235       * @throws InvalidArgumentException
 236       *
 237       * @return void
 238       */
 239      public static function allNumeric($value, $message = '')
 240      {
 241          static::__callStatic('allNumeric', array($value, $message));
 242      }
 243  
 244      /**
 245       * @psalm-pure
 246       * @psalm-assert positive-int|0|null $value
 247       *
 248       * @param mixed  $value
 249       * @param string $message
 250       *
 251       * @throws InvalidArgumentException
 252       *
 253       * @return void
 254       */
 255      public static function nullOrNatural($value, $message = '')
 256      {
 257          static::__callStatic('nullOrNatural', array($value, $message));
 258      }
 259  
 260      /**
 261       * @psalm-pure
 262       * @psalm-assert iterable<positive-int|0> $value
 263       *
 264       * @param mixed  $value
 265       * @param string $message
 266       *
 267       * @throws InvalidArgumentException
 268       *
 269       * @return void
 270       */
 271      public static function allNatural($value, $message = '')
 272      {
 273          static::__callStatic('allNatural', array($value, $message));
 274      }
 275  
 276      /**
 277       * @psalm-pure
 278       * @psalm-assert bool|null $value
 279       *
 280       * @param mixed  $value
 281       * @param string $message
 282       *
 283       * @throws InvalidArgumentException
 284       *
 285       * @return void
 286       */
 287      public static function nullOrBoolean($value, $message = '')
 288      {
 289          static::__callStatic('nullOrBoolean', array($value, $message));
 290      }
 291  
 292      /**
 293       * @psalm-pure
 294       * @psalm-assert iterable<bool> $value
 295       *
 296       * @param mixed  $value
 297       * @param string $message
 298       *
 299       * @throws InvalidArgumentException
 300       *
 301       * @return void
 302       */
 303      public static function allBoolean($value, $message = '')
 304      {
 305          static::__callStatic('allBoolean', array($value, $message));
 306      }
 307  
 308      /**
 309       * @psalm-pure
 310       * @psalm-assert scalar|null $value
 311       *
 312       * @param mixed  $value
 313       * @param string $message
 314       *
 315       * @throws InvalidArgumentException
 316       *
 317       * @return void
 318       */
 319      public static function nullOrScalar($value, $message = '')
 320      {
 321          static::__callStatic('nullOrScalar', array($value, $message));
 322      }
 323  
 324      /**
 325       * @psalm-pure
 326       * @psalm-assert iterable<scalar> $value
 327       *
 328       * @param mixed  $value
 329       * @param string $message
 330       *
 331       * @throws InvalidArgumentException
 332       *
 333       * @return void
 334       */
 335      public static function allScalar($value, $message = '')
 336      {
 337          static::__callStatic('allScalar', array($value, $message));
 338      }
 339  
 340      /**
 341       * @psalm-pure
 342       * @psalm-assert object|null $value
 343       *
 344       * @param mixed  $value
 345       * @param string $message
 346       *
 347       * @throws InvalidArgumentException
 348       *
 349       * @return void
 350       */
 351      public static function nullOrObject($value, $message = '')
 352      {
 353          static::__callStatic('nullOrObject', array($value, $message));
 354      }
 355  
 356      /**
 357       * @psalm-pure
 358       * @psalm-assert iterable<object> $value
 359       *
 360       * @param mixed  $value
 361       * @param string $message
 362       *
 363       * @throws InvalidArgumentException
 364       *
 365       * @return void
 366       */
 367      public static function allObject($value, $message = '')
 368      {
 369          static::__callStatic('allObject', array($value, $message));
 370      }
 371  
 372      /**
 373       * @psalm-pure
 374       * @psalm-assert resource|null $value
 375       *
 376       * @param mixed       $value
 377       * @param string|null $type    type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php
 378       * @param string      $message
 379       *
 380       * @throws InvalidArgumentException
 381       *
 382       * @return void
 383       */
 384      public static function nullOrResource($value, $type = null, $message = '')
 385      {
 386          static::__callStatic('nullOrResource', array($value, $type, $message));
 387      }
 388  
 389      /**
 390       * @psalm-pure
 391       * @psalm-assert iterable<resource> $value
 392       *
 393       * @param mixed       $value
 394       * @param string|null $type    type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php
 395       * @param string      $message
 396       *
 397       * @throws InvalidArgumentException
 398       *
 399       * @return void
 400       */
 401      public static function allResource($value, $type = null, $message = '')
 402      {
 403          static::__callStatic('allResource', array($value, $type, $message));
 404      }
 405  
 406      /**
 407       * @psalm-pure
 408       * @psalm-assert callable|null $value
 409       *
 410       * @param mixed  $value
 411       * @param string $message
 412       *
 413       * @throws InvalidArgumentException
 414       *
 415       * @return void
 416       */
 417      public static function nullOrIsCallable($value, $message = '')
 418      {
 419          static::__callStatic('nullOrIsCallable', array($value, $message));
 420      }
 421  
 422      /**
 423       * @psalm-pure
 424       * @psalm-assert iterable<callable> $value
 425       *
 426       * @param mixed  $value
 427       * @param string $message
 428       *
 429       * @throws InvalidArgumentException
 430       *
 431       * @return void
 432       */
 433      public static function allIsCallable($value, $message = '')
 434      {
 435          static::__callStatic('allIsCallable', array($value, $message));
 436      }
 437  
 438      /**
 439       * @psalm-pure
 440       * @psalm-assert array|null $value
 441       *
 442       * @param mixed  $value
 443       * @param string $message
 444       *
 445       * @throws InvalidArgumentException
 446       *
 447       * @return void
 448       */
 449      public static function nullOrIsArray($value, $message = '')
 450      {
 451          static::__callStatic('nullOrIsArray', array($value, $message));
 452      }
 453  
 454      /**
 455       * @psalm-pure
 456       * @psalm-assert iterable<array> $value
 457       *
 458       * @param mixed  $value
 459       * @param string $message
 460       *
 461       * @throws InvalidArgumentException
 462       *
 463       * @return void
 464       */
 465      public static function allIsArray($value, $message = '')
 466      {
 467          static::__callStatic('allIsArray', array($value, $message));
 468      }
 469  
 470      /**
 471       * @psalm-pure
 472       * @psalm-assert iterable|null $value
 473       *
 474       * @deprecated use "isIterable" or "isInstanceOf" instead
 475       *
 476       * @param mixed  $value
 477       * @param string $message
 478       *
 479       * @throws InvalidArgumentException
 480       *
 481       * @return void
 482       */
 483      public static function nullOrIsTraversable($value, $message = '')
 484      {
 485          static::__callStatic('nullOrIsTraversable', array($value, $message));
 486      }
 487  
 488      /**
 489       * @psalm-pure
 490       * @psalm-assert iterable<iterable> $value
 491       *
 492       * @deprecated use "isIterable" or "isInstanceOf" instead
 493       *
 494       * @param mixed  $value
 495       * @param string $message
 496       *
 497       * @throws InvalidArgumentException
 498       *
 499       * @return void
 500       */
 501      public static function allIsTraversable($value, $message = '')
 502      {
 503          static::__callStatic('allIsTraversable', array($value, $message));
 504      }
 505  
 506      /**
 507       * @psalm-pure
 508       * @psalm-assert array|ArrayAccess|null $value
 509       *
 510       * @param mixed  $value
 511       * @param string $message
 512       *
 513       * @throws InvalidArgumentException
 514       *
 515       * @return void
 516       */
 517      public static function nullOrIsArrayAccessible($value, $message = '')
 518      {
 519          static::__callStatic('nullOrIsArrayAccessible', array($value, $message));
 520      }
 521  
 522      /**
 523       * @psalm-pure
 524       * @psalm-assert iterable<array|ArrayAccess> $value
 525       *
 526       * @param mixed  $value
 527       * @param string $message
 528       *
 529       * @throws InvalidArgumentException
 530       *
 531       * @return void
 532       */
 533      public static function allIsArrayAccessible($value, $message = '')
 534      {
 535          static::__callStatic('allIsArrayAccessible', array($value, $message));
 536      }
 537  
 538      /**
 539       * @psalm-pure
 540       * @psalm-assert countable|null $value
 541       *
 542       * @param mixed  $value
 543       * @param string $message
 544       *
 545       * @throws InvalidArgumentException
 546       *
 547       * @return void
 548       */
 549      public static function nullOrIsCountable($value, $message = '')
 550      {
 551          static::__callStatic('nullOrIsCountable', array($value, $message));
 552      }
 553  
 554      /**
 555       * @psalm-pure
 556       * @psalm-assert iterable<countable> $value
 557       *
 558       * @param mixed  $value
 559       * @param string $message
 560       *
 561       * @throws InvalidArgumentException
 562       *
 563       * @return void
 564       */
 565      public static function allIsCountable($value, $message = '')
 566      {
 567          static::__callStatic('allIsCountable', array($value, $message));
 568      }
 569  
 570      /**
 571       * @psalm-pure
 572       * @psalm-assert iterable|null $value
 573       *
 574       * @param mixed  $value
 575       * @param string $message
 576       *
 577       * @throws InvalidArgumentException
 578       *
 579       * @return void
 580       */
 581      public static function nullOrIsIterable($value, $message = '')
 582      {
 583          static::__callStatic('nullOrIsIterable', array($value, $message));
 584      }
 585  
 586      /**
 587       * @psalm-pure
 588       * @psalm-assert iterable<iterable> $value
 589       *
 590       * @param mixed  $value
 591       * @param string $message
 592       *
 593       * @throws InvalidArgumentException
 594       *
 595       * @return void
 596       */
 597      public static function allIsIterable($value, $message = '')
 598      {
 599          static::__callStatic('allIsIterable', array($value, $message));
 600      }
 601  
 602      /**
 603       * @psalm-pure
 604       * @psalm-template ExpectedType of object
 605       * @psalm-param class-string<ExpectedType> $class
 606       * @psalm-assert ExpectedType|null $value
 607       *
 608       * @param mixed         $value
 609       * @param string|object $class
 610       * @param string        $message
 611       *
 612       * @throws InvalidArgumentException
 613       *
 614       * @return void
 615       */
 616      public static function nullOrIsInstanceOf($value, $class, $message = '')
 617      {
 618          static::__callStatic('nullOrIsInstanceOf', array($value, $class, $message));
 619      }
 620  
 621      /**
 622       * @psalm-pure
 623       * @psalm-template ExpectedType of object
 624       * @psalm-param class-string<ExpectedType> $class
 625       * @psalm-assert iterable<ExpectedType> $value
 626       *
 627       * @param mixed         $value
 628       * @param string|object $class
 629       * @param string        $message
 630       *
 631       * @throws InvalidArgumentException
 632       *
 633       * @return void
 634       */
 635      public static function allIsInstanceOf($value, $class, $message = '')
 636      {
 637          static::__callStatic('allIsInstanceOf', array($value, $class, $message));
 638      }
 639  
 640      /**
 641       * @psalm-pure
 642       * @psalm-template ExpectedType of object
 643       * @psalm-param class-string<ExpectedType> $class
 644       *
 645       * @param mixed         $value
 646       * @param string|object $class
 647       * @param string        $message
 648       *
 649       * @throws InvalidArgumentException
 650       *
 651       * @return void
 652       */
 653      public static function nullOrNotInstanceOf($value, $class, $message = '')
 654      {
 655          static::__callStatic('nullOrNotInstanceOf', array($value, $class, $message));
 656      }
 657  
 658      /**
 659       * @psalm-pure
 660       * @psalm-template ExpectedType of object
 661       * @psalm-param class-string<ExpectedType> $class
 662       *
 663       * @param mixed         $value
 664       * @param string|object $class
 665       * @param string        $message
 666       *
 667       * @throws InvalidArgumentException
 668       *
 669       * @return void
 670       */
 671      public static function allNotInstanceOf($value, $class, $message = '')
 672      {
 673          static::__callStatic('allNotInstanceOf', array($value, $class, $message));
 674      }
 675  
 676      /**
 677       * @psalm-pure
 678       * @psalm-param array<class-string> $classes
 679       *
 680       * @param mixed                $value
 681       * @param array<object|string> $classes
 682       * @param string               $message
 683       *
 684       * @throws InvalidArgumentException
 685       *
 686       * @return void
 687       */
 688      public static function nullOrIsInstanceOfAny($value, $classes, $message = '')
 689      {
 690          static::__callStatic('nullOrIsInstanceOfAny', array($value, $classes, $message));
 691      }
 692  
 693      /**
 694       * @psalm-pure
 695       * @psalm-param array<class-string> $classes
 696       *
 697       * @param mixed                $value
 698       * @param array<object|string> $classes
 699       * @param string               $message
 700       *
 701       * @throws InvalidArgumentException
 702       *
 703       * @return void
 704       */
 705      public static function allIsInstanceOfAny($value, $classes, $message = '')
 706      {
 707          static::__callStatic('allIsInstanceOfAny', array($value, $classes, $message));
 708      }
 709  
 710      /**
 711       * @psalm-pure
 712       * @psalm-template ExpectedType of object
 713       * @psalm-param class-string<ExpectedType> $class
 714       * @psalm-assert ExpectedType|class-string<ExpectedType>|null $value
 715       *
 716       * @param object|string|null $value
 717       * @param string             $class
 718       * @param string             $message
 719       *
 720       * @throws InvalidArgumentException
 721       *
 722       * @return void
 723       */
 724      public static function nullOrIsAOf($value, $class, $message = '')
 725      {
 726          static::__callStatic('nullOrIsAOf', array($value, $class, $message));
 727      }
 728  
 729      /**
 730       * @psalm-pure
 731       * @psalm-template ExpectedType of object
 732       * @psalm-param class-string<ExpectedType> $class
 733       * @psalm-assert iterable<ExpectedType|class-string<ExpectedType>> $value
 734       *
 735       * @param iterable<object|string> $value
 736       * @param string                  $class
 737       * @param string                  $message
 738       *
 739       * @throws InvalidArgumentException
 740       *
 741       * @return void
 742       */
 743      public static function allIsAOf($value, $class, $message = '')
 744      {
 745          static::__callStatic('allIsAOf', array($value, $class, $message));
 746      }
 747  
 748      /**
 749       * @psalm-pure
 750       * @psalm-template UnexpectedType of object
 751       * @psalm-param class-string<UnexpectedType> $class
 752       *
 753       * @param object|string|null $value
 754       * @param string             $class
 755       * @param string             $message
 756       *
 757       * @throws InvalidArgumentException
 758       *
 759       * @return void
 760       */
 761      public static function nullOrIsNotA($value, $class, $message = '')
 762      {
 763          static::__callStatic('nullOrIsNotA', array($value, $class, $message));
 764      }
 765  
 766      /**
 767       * @psalm-pure
 768       * @psalm-template UnexpectedType of object
 769       * @psalm-param class-string<UnexpectedType> $class
 770       *
 771       * @param iterable<object|string> $value
 772       * @param string                  $class
 773       * @param string                  $message
 774       *
 775       * @throws InvalidArgumentException
 776       *
 777       * @return void
 778       */
 779      public static function allIsNotA($value, $class, $message = '')
 780      {
 781          static::__callStatic('allIsNotA', array($value, $class, $message));
 782      }
 783  
 784      /**
 785       * @psalm-pure
 786       * @psalm-param array<class-string> $classes
 787       *
 788       * @param object|string|null $value
 789       * @param string[]           $classes
 790       * @param string             $message
 791       *
 792       * @throws InvalidArgumentException
 793       *
 794       * @return void
 795       */
 796      public static function nullOrIsAnyOf($value, $classes, $message = '')
 797      {
 798          static::__callStatic('nullOrIsAnyOf', array($value, $classes, $message));
 799      }
 800  
 801      /**
 802       * @psalm-pure
 803       * @psalm-param array<class-string> $classes
 804       *
 805       * @param iterable<object|string> $value
 806       * @param string[]                $classes
 807       * @param string                  $message
 808       *
 809       * @throws InvalidArgumentException
 810       *
 811       * @return void
 812       */
 813      public static function allIsAnyOf($value, $classes, $message = '')
 814      {
 815          static::__callStatic('allIsAnyOf', array($value, $classes, $message));
 816      }
 817  
 818      /**
 819       * @psalm-pure
 820       * @psalm-assert empty $value
 821       *
 822       * @param mixed  $value
 823       * @param string $message
 824       *
 825       * @throws InvalidArgumentException
 826       *
 827       * @return void
 828       */
 829      public static function nullOrIsEmpty($value, $message = '')
 830      {
 831          static::__callStatic('nullOrIsEmpty', array($value, $message));
 832      }
 833  
 834      /**
 835       * @psalm-pure
 836       * @psalm-assert iterable<empty> $value
 837       *
 838       * @param mixed  $value
 839       * @param string $message
 840       *
 841       * @throws InvalidArgumentException
 842       *
 843       * @return void
 844       */
 845      public static function allIsEmpty($value, $message = '')
 846      {
 847          static::__callStatic('allIsEmpty', array($value, $message));
 848      }
 849  
 850      /**
 851       * @psalm-pure
 852       *
 853       * @param mixed  $value
 854       * @param string $message
 855       *
 856       * @throws InvalidArgumentException
 857       *
 858       * @return void
 859       */
 860      public static function nullOrNotEmpty($value, $message = '')
 861      {
 862          static::__callStatic('nullOrNotEmpty', array($value, $message));
 863      }
 864  
 865      /**
 866       * @psalm-pure
 867       *
 868       * @param mixed  $value
 869       * @param string $message
 870       *
 871       * @throws InvalidArgumentException
 872       *
 873       * @return void
 874       */
 875      public static function allNotEmpty($value, $message = '')
 876      {
 877          static::__callStatic('allNotEmpty', array($value, $message));
 878      }
 879  
 880      /**
 881       * @psalm-pure
 882       * @psalm-assert iterable<null> $value
 883       *
 884       * @param mixed  $value
 885       * @param string $message
 886       *
 887       * @throws InvalidArgumentException
 888       *
 889       * @return void
 890       */
 891      public static function allNull($value, $message = '')
 892      {
 893          static::__callStatic('allNull', array($value, $message));
 894      }
 895  
 896      /**
 897       * @psalm-pure
 898       *
 899       * @param mixed  $value
 900       * @param string $message
 901       *
 902       * @throws InvalidArgumentException
 903       *
 904       * @return void
 905       */
 906      public static function allNotNull($value, $message = '')
 907      {
 908          static::__callStatic('allNotNull', array($value, $message));
 909      }
 910  
 911      /**
 912       * @psalm-pure
 913       * @psalm-assert true|null $value
 914       *
 915       * @param mixed  $value
 916       * @param string $message
 917       *
 918       * @throws InvalidArgumentException
 919       *
 920       * @return void
 921       */
 922      public static function nullOrTrue($value, $message = '')
 923      {
 924          static::__callStatic('nullOrTrue', array($value, $message));
 925      }
 926  
 927      /**
 928       * @psalm-pure
 929       * @psalm-assert iterable<true> $value
 930       *
 931       * @param mixed  $value
 932       * @param string $message
 933       *
 934       * @throws InvalidArgumentException
 935       *
 936       * @return void
 937       */
 938      public static function allTrue($value, $message = '')
 939      {
 940          static::__callStatic('allTrue', array($value, $message));
 941      }
 942  
 943      /**
 944       * @psalm-pure
 945       * @psalm-assert false|null $value
 946       *
 947       * @param mixed  $value
 948       * @param string $message
 949       *
 950       * @throws InvalidArgumentException
 951       *
 952       * @return void
 953       */
 954      public static function nullOrFalse($value, $message = '')
 955      {
 956          static::__callStatic('nullOrFalse', array($value, $message));
 957      }
 958  
 959      /**
 960       * @psalm-pure
 961       * @psalm-assert iterable<false> $value
 962       *
 963       * @param mixed  $value
 964       * @param string $message
 965       *
 966       * @throws InvalidArgumentException
 967       *
 968       * @return void
 969       */
 970      public static function allFalse($value, $message = '')
 971      {
 972          static::__callStatic('allFalse', array($value, $message));
 973      }
 974  
 975      /**
 976       * @psalm-pure
 977       *
 978       * @param mixed  $value
 979       * @param string $message
 980       *
 981       * @throws InvalidArgumentException
 982       *
 983       * @return void
 984       */
 985      public static function nullOrNotFalse($value, $message = '')
 986      {
 987          static::__callStatic('nullOrNotFalse', array($value, $message));
 988      }
 989  
 990      /**
 991       * @psalm-pure
 992       *
 993       * @param mixed  $value
 994       * @param string $message
 995       *
 996       * @throws InvalidArgumentException
 997       *
 998       * @return void
 999       */
1000      public static function allNotFalse($value, $message = '')
1001      {
1002          static::__callStatic('allNotFalse', array($value, $message));
1003      }
1004  
1005      /**
1006       * @param mixed  $value
1007       * @param string $message
1008       *
1009       * @throws InvalidArgumentException
1010       *
1011       * @return void
1012       */
1013      public static function nullOrIp($value, $message = '')
1014      {
1015          static::__callStatic('nullOrIp', array($value, $message));
1016      }
1017  
1018      /**
1019       * @param mixed  $value
1020       * @param string $message
1021       *
1022       * @throws InvalidArgumentException
1023       *
1024       * @return void
1025       */
1026      public static function allIp($value, $message = '')
1027      {
1028          static::__callStatic('allIp', array($value, $message));
1029      }
1030  
1031      /**
1032       * @param mixed  $value
1033       * @param string $message
1034       *
1035       * @throws InvalidArgumentException
1036       *
1037       * @return void
1038       */
1039      public static function nullOrIpv4($value, $message = '')
1040      {
1041          static::__callStatic('nullOrIpv4', array($value, $message));
1042      }
1043  
1044      /**
1045       * @param mixed  $value
1046       * @param string $message
1047       *
1048       * @throws InvalidArgumentException
1049       *
1050       * @return void
1051       */
1052      public static function allIpv4($value, $message = '')
1053      {
1054          static::__callStatic('allIpv4', array($value, $message));
1055      }
1056  
1057      /**
1058       * @param mixed  $value
1059       * @param string $message
1060       *
1061       * @throws InvalidArgumentException
1062       *
1063       * @return void
1064       */
1065      public static function nullOrIpv6($value, $message = '')
1066      {
1067          static::__callStatic('nullOrIpv6', array($value, $message));
1068      }
1069  
1070      /**
1071       * @param mixed  $value
1072       * @param string $message
1073       *
1074       * @throws InvalidArgumentException
1075       *
1076       * @return void
1077       */
1078      public static function allIpv6($value, $message = '')
1079      {
1080          static::__callStatic('allIpv6', array($value, $message));
1081      }
1082  
1083      /**
1084       * @param mixed  $value
1085       * @param string $message
1086       *
1087       * @throws InvalidArgumentException
1088       *
1089       * @return void
1090       */
1091      public static function nullOrEmail($value, $message = '')
1092      {
1093          static::__callStatic('nullOrEmail', array($value, $message));
1094      }
1095  
1096      /**
1097       * @param mixed  $value
1098       * @param string $message
1099       *
1100       * @throws InvalidArgumentException
1101       *
1102       * @return void
1103       */
1104      public static function allEmail($value, $message = '')
1105      {
1106          static::__callStatic('allEmail', array($value, $message));
1107      }
1108  
1109      /**
1110       * @param array|null $values
1111       * @param string     $message
1112       *
1113       * @throws InvalidArgumentException
1114       *
1115       * @return void
1116       */
1117      public static function nullOrUniqueValues($values, $message = '')
1118      {
1119          static::__callStatic('nullOrUniqueValues', array($values, $message));
1120      }
1121  
1122      /**
1123       * @param iterable<array> $values
1124       * @param string          $message
1125       *
1126       * @throws InvalidArgumentException
1127       *
1128       * @return void
1129       */
1130      public static function allUniqueValues($values, $message = '')
1131      {
1132          static::__callStatic('allUniqueValues', array($values, $message));
1133      }
1134  
1135      /**
1136       * @param mixed  $value
1137       * @param mixed  $expect
1138       * @param string $message
1139       *
1140       * @throws InvalidArgumentException
1141       *
1142       * @return void
1143       */
1144      public static function nullOrEq($value, $expect, $message = '')
1145      {
1146          static::__callStatic('nullOrEq', array($value, $expect, $message));
1147      }
1148  
1149      /**
1150       * @param mixed  $value
1151       * @param mixed  $expect
1152       * @param string $message
1153       *
1154       * @throws InvalidArgumentException
1155       *
1156       * @return void
1157       */
1158      public static function allEq($value, $expect, $message = '')
1159      {
1160          static::__callStatic('allEq', array($value, $expect, $message));
1161      }
1162  
1163      /**
1164       * @param mixed  $value
1165       * @param mixed  $expect
1166       * @param string $message
1167       *
1168       * @throws InvalidArgumentException
1169       *
1170       * @return void
1171       */
1172      public static function nullOrNotEq($value, $expect, $message = '')
1173      {
1174          static::__callStatic('nullOrNotEq', array($value, $expect, $message));
1175      }
1176  
1177      /**
1178       * @param mixed  $value
1179       * @param mixed  $expect
1180       * @param string $message
1181       *
1182       * @throws InvalidArgumentException
1183       *
1184       * @return void
1185       */
1186      public static function allNotEq($value, $expect, $message = '')
1187      {
1188          static::__callStatic('allNotEq', array($value, $expect, $message));
1189      }
1190  
1191      /**
1192       * @psalm-pure
1193       *
1194       * @param mixed  $value
1195       * @param mixed  $expect
1196       * @param string $message
1197       *
1198       * @throws InvalidArgumentException
1199       *
1200       * @return void
1201       */
1202      public static function nullOrSame($value, $expect, $message = '')
1203      {
1204          static::__callStatic('nullOrSame', array($value, $expect, $message));
1205      }
1206  
1207      /**
1208       * @psalm-pure
1209       *
1210       * @param mixed  $value
1211       * @param mixed  $expect
1212       * @param string $message
1213       *
1214       * @throws InvalidArgumentException
1215       *
1216       * @return void
1217       */
1218      public static function allSame($value, $expect, $message = '')
1219      {
1220          static::__callStatic('allSame', array($value, $expect, $message));
1221      }
1222  
1223      /**
1224       * @psalm-pure
1225       *
1226       * @param mixed  $value
1227       * @param mixed  $expect
1228       * @param string $message
1229       *
1230       * @throws InvalidArgumentException
1231       *
1232       * @return void
1233       */
1234      public static function nullOrNotSame($value, $expect, $message = '')
1235      {
1236          static::__callStatic('nullOrNotSame', array($value, $expect, $message));
1237      }
1238  
1239      /**
1240       * @psalm-pure
1241       *
1242       * @param mixed  $value
1243       * @param mixed  $expect
1244       * @param string $message
1245       *
1246       * @throws InvalidArgumentException
1247       *
1248       * @return void
1249       */
1250      public static function allNotSame($value, $expect, $message = '')
1251      {
1252          static::__callStatic('allNotSame', array($value, $expect, $message));
1253      }
1254  
1255      /**
1256       * @psalm-pure
1257       *
1258       * @param mixed  $value
1259       * @param mixed  $limit
1260       * @param string $message
1261       *
1262       * @throws InvalidArgumentException
1263       *
1264       * @return void
1265       */
1266      public static function nullOrGreaterThan($value, $limit, $message = '')
1267      {
1268          static::__callStatic('nullOrGreaterThan', array($value, $limit, $message));
1269      }
1270  
1271      /**
1272       * @psalm-pure
1273       *
1274       * @param mixed  $value
1275       * @param mixed  $limit
1276       * @param string $message
1277       *
1278       * @throws InvalidArgumentException
1279       *
1280       * @return void
1281       */
1282      public static function allGreaterThan($value, $limit, $message = '')
1283      {
1284          static::__callStatic('allGreaterThan', array($value, $limit, $message));
1285      }
1286  
1287      /**
1288       * @psalm-pure
1289       *
1290       * @param mixed  $value
1291       * @param mixed  $limit
1292       * @param string $message
1293       *
1294       * @throws InvalidArgumentException
1295       *
1296       * @return void
1297       */
1298      public static function nullOrGreaterThanEq($value, $limit, $message = '')
1299      {
1300          static::__callStatic('nullOrGreaterThanEq', array($value, $limit, $message));
1301      }
1302  
1303      /**
1304       * @psalm-pure
1305       *
1306       * @param mixed  $value
1307       * @param mixed  $limit
1308       * @param string $message
1309       *
1310       * @throws InvalidArgumentException
1311       *
1312       * @return void
1313       */
1314      public static function allGreaterThanEq($value, $limit, $message = '')
1315      {
1316          static::__callStatic('allGreaterThanEq', array($value, $limit, $message));
1317      }
1318  
1319      /**
1320       * @psalm-pure
1321       *
1322       * @param mixed  $value
1323       * @param mixed  $limit
1324       * @param string $message
1325       *
1326       * @throws InvalidArgumentException
1327       *
1328       * @return void
1329       */
1330      public static function nullOrLessThan($value, $limit, $message = '')
1331      {
1332          static::__callStatic('nullOrLessThan', array($value, $limit, $message));
1333      }
1334  
1335      /**
1336       * @psalm-pure
1337       *
1338       * @param mixed  $value
1339       * @param mixed  $limit
1340       * @param string $message
1341       *
1342       * @throws InvalidArgumentException
1343       *
1344       * @return void
1345       */
1346      public static function allLessThan($value, $limit, $message = '')
1347      {
1348          static::__callStatic('allLessThan', array($value, $limit, $message));
1349      }
1350  
1351      /**
1352       * @psalm-pure
1353       *
1354       * @param mixed  $value
1355       * @param mixed  $limit
1356       * @param string $message
1357       *
1358       * @throws InvalidArgumentException
1359       *
1360       * @return void
1361       */
1362      public static function nullOrLessThanEq($value, $limit, $message = '')
1363      {
1364          static::__callStatic('nullOrLessThanEq', array($value, $limit, $message));
1365      }
1366  
1367      /**
1368       * @psalm-pure
1369       *
1370       * @param mixed  $value
1371       * @param mixed  $limit
1372       * @param string $message
1373       *
1374       * @throws InvalidArgumentException
1375       *
1376       * @return void
1377       */
1378      public static function allLessThanEq($value, $limit, $message = '')
1379      {
1380          static::__callStatic('allLessThanEq', array($value, $limit, $message));
1381      }
1382  
1383      /**
1384       * @psalm-pure
1385       *
1386       * @param mixed  $value
1387       * @param mixed  $min
1388       * @param mixed  $max
1389       * @param string $message
1390       *
1391       * @throws InvalidArgumentException
1392       *
1393       * @return void
1394       */
1395      public static function nullOrRange($value, $min, $max, $message = '')
1396      {
1397          static::__callStatic('nullOrRange', array($value, $min, $max, $message));
1398      }
1399  
1400      /**
1401       * @psalm-pure
1402       *
1403       * @param mixed  $value
1404       * @param mixed  $min
1405       * @param mixed  $max
1406       * @param string $message
1407       *
1408       * @throws InvalidArgumentException
1409       *
1410       * @return void
1411       */
1412      public static function allRange($value, $min, $max, $message = '')
1413      {
1414          static::__callStatic('allRange', array($value, $min, $max, $message));
1415      }
1416  
1417      /**
1418       * @psalm-pure
1419       *
1420       * @param mixed  $value
1421       * @param array  $values
1422       * @param string $message
1423       *
1424       * @throws InvalidArgumentException
1425       *
1426       * @return void
1427       */
1428      public static function nullOrOneOf($value, $values, $message = '')
1429      {
1430          static::__callStatic('nullOrOneOf', array($value, $values, $message));
1431      }
1432  
1433      /**
1434       * @psalm-pure
1435       *
1436       * @param mixed  $value
1437       * @param array  $values
1438       * @param string $message
1439       *
1440       * @throws InvalidArgumentException
1441       *
1442       * @return void
1443       */
1444      public static function allOneOf($value, $values, $message = '')
1445      {
1446          static::__callStatic('allOneOf', array($value, $values, $message));
1447      }
1448  
1449      /**
1450       * @psalm-pure
1451       *
1452       * @param mixed  $value
1453       * @param array  $values
1454       * @param string $message
1455       *
1456       * @throws InvalidArgumentException
1457       *
1458       * @return void
1459       */
1460      public static function nullOrInArray($value, $values, $message = '')
1461      {
1462          static::__callStatic('nullOrInArray', array($value, $values, $message));
1463      }
1464  
1465      /**
1466       * @psalm-pure
1467       *
1468       * @param mixed  $value
1469       * @param array  $values
1470       * @param string $message
1471       *
1472       * @throws InvalidArgumentException
1473       *
1474       * @return void
1475       */
1476      public static function allInArray($value, $values, $message = '')
1477      {
1478          static::__callStatic('allInArray', array($value, $values, $message));
1479      }
1480  
1481      /**
1482       * @psalm-pure
1483       *
1484       * @param string|null $value
1485       * @param string      $subString
1486       * @param string      $message
1487       *
1488       * @throws InvalidArgumentException
1489       *
1490       * @return void
1491       */
1492      public static function nullOrContains($value, $subString, $message = '')
1493      {
1494          static::__callStatic('nullOrContains', array($value, $subString, $message));
1495      }
1496  
1497      /**
1498       * @psalm-pure
1499       *
1500       * @param iterable<string> $value
1501       * @param string           $subString
1502       * @param string           $message
1503       *
1504       * @throws InvalidArgumentException
1505       *
1506       * @return void
1507       */
1508      public static function allContains($value, $subString, $message = '')
1509      {
1510          static::__callStatic('allContains', array($value, $subString, $message));
1511      }
1512  
1513      /**
1514       * @psalm-pure
1515       *
1516       * @param string|null $value
1517       * @param string      $subString
1518       * @param string      $message
1519       *
1520       * @throws InvalidArgumentException
1521       *
1522       * @return void
1523       */
1524      public static function nullOrNotContains($value, $subString, $message = '')
1525      {
1526          static::__callStatic('nullOrNotContains', array($value, $subString, $message));
1527      }
1528  
1529      /**
1530       * @psalm-pure
1531       *
1532       * @param iterable<string> $value
1533       * @param string           $subString
1534       * @param string           $message
1535       *
1536       * @throws InvalidArgumentException
1537       *
1538       * @return void
1539       */
1540      public static function allNotContains($value, $subString, $message = '')
1541      {
1542          static::__callStatic('allNotContains', array($value, $subString, $message));
1543      }
1544  
1545      /**
1546       * @psalm-pure
1547       *
1548       * @param string|null $value
1549       * @param string      $message
1550       *
1551       * @throws InvalidArgumentException
1552       *
1553       * @return void
1554       */
1555      public static function nullOrNotWhitespaceOnly($value, $message = '')
1556      {
1557          static::__callStatic('nullOrNotWhitespaceOnly', array($value, $message));
1558      }
1559  
1560      /**
1561       * @psalm-pure
1562       *
1563       * @param iterable<string> $value
1564       * @param string           $message
1565       *
1566       * @throws InvalidArgumentException
1567       *
1568       * @return void
1569       */
1570      public static function allNotWhitespaceOnly($value, $message = '')
1571      {
1572          static::__callStatic('allNotWhitespaceOnly', array($value, $message));
1573      }
1574  
1575      /**
1576       * @psalm-pure
1577       *
1578       * @param string|null $value
1579       * @param string      $prefix
1580       * @param string      $message
1581       *
1582       * @throws InvalidArgumentException
1583       *
1584       * @return void
1585       */
1586      public static function nullOrStartsWith($value, $prefix, $message = '')
1587      {
1588          static::__callStatic('nullOrStartsWith', array($value, $prefix, $message));
1589      }
1590  
1591      /**
1592       * @psalm-pure
1593       *
1594       * @param iterable<string> $value
1595       * @param string           $prefix
1596       * @param string           $message
1597       *
1598       * @throws InvalidArgumentException
1599       *
1600       * @return void
1601       */
1602      public static function allStartsWith($value, $prefix, $message = '')
1603      {
1604          static::__callStatic('allStartsWith', array($value, $prefix, $message));
1605      }
1606  
1607      /**
1608       * @psalm-pure
1609       *
1610       * @param string|null $value
1611       * @param string      $prefix
1612       * @param string      $message
1613       *
1614       * @throws InvalidArgumentException
1615       *
1616       * @return void
1617       */
1618      public static function nullOrNotStartsWith($value, $prefix, $message = '')
1619      {
1620          static::__callStatic('nullOrNotStartsWith', array($value, $prefix, $message));
1621      }
1622  
1623      /**
1624       * @psalm-pure
1625       *
1626       * @param iterable<string> $value
1627       * @param string           $prefix
1628       * @param string           $message
1629       *
1630       * @throws InvalidArgumentException
1631       *
1632       * @return void
1633       */
1634      public static function allNotStartsWith($value, $prefix, $message = '')
1635      {
1636          static::__callStatic('allNotStartsWith', array($value, $prefix, $message));
1637      }
1638  
1639      /**
1640       * @psalm-pure
1641       *
1642       * @param mixed  $value
1643       * @param string $message
1644       *
1645       * @throws InvalidArgumentException
1646       *
1647       * @return void
1648       */
1649      public static function nullOrStartsWithLetter($value, $message = '')
1650      {
1651          static::__callStatic('nullOrStartsWithLetter', array($value, $message));
1652      }
1653  
1654      /**
1655       * @psalm-pure
1656       *
1657       * @param mixed  $value
1658       * @param string $message
1659       *
1660       * @throws InvalidArgumentException
1661       *
1662       * @return void
1663       */
1664      public static function allStartsWithLetter($value, $message = '')
1665      {
1666          static::__callStatic('allStartsWithLetter', array($value, $message));
1667      }
1668  
1669      /**
1670       * @psalm-pure
1671       *
1672       * @param string|null $value
1673       * @param string      $suffix
1674       * @param string      $message
1675       *
1676       * @throws InvalidArgumentException
1677       *
1678       * @return void
1679       */
1680      public static function nullOrEndsWith($value, $suffix, $message = '')
1681      {
1682          static::__callStatic('nullOrEndsWith', array($value, $suffix, $message));
1683      }
1684  
1685      /**
1686       * @psalm-pure
1687       *
1688       * @param iterable<string> $value
1689       * @param string           $suffix
1690       * @param string           $message
1691       *
1692       * @throws InvalidArgumentException
1693       *
1694       * @return void
1695       */
1696      public static function allEndsWith($value, $suffix, $message = '')
1697      {
1698          static::__callStatic('allEndsWith', array($value, $suffix, $message));
1699      }
1700  
1701      /**
1702       * @psalm-pure
1703       *
1704       * @param string|null $value
1705       * @param string      $suffix
1706       * @param string      $message
1707       *
1708       * @throws InvalidArgumentException
1709       *
1710       * @return void
1711       */
1712      public static function nullOrNotEndsWith($value, $suffix, $message = '')
1713      {
1714          static::__callStatic('nullOrNotEndsWith', array($value, $suffix, $message));
1715      }
1716  
1717      /**
1718       * @psalm-pure
1719       *
1720       * @param iterable<string> $value
1721       * @param string           $suffix
1722       * @param string           $message
1723       *
1724       * @throws InvalidArgumentException
1725       *
1726       * @return void
1727       */
1728      public static function allNotEndsWith($value, $suffix, $message = '')
1729      {
1730          static::__callStatic('allNotEndsWith', array($value, $suffix, $message));
1731      }
1732  
1733      /**
1734       * @psalm-pure
1735       *
1736       * @param string|null $value
1737       * @param string      $pattern
1738       * @param string      $message
1739       *
1740       * @throws InvalidArgumentException
1741       *
1742       * @return void
1743       */
1744      public static function nullOrRegex($value, $pattern, $message = '')
1745      {
1746          static::__callStatic('nullOrRegex', array($value, $pattern, $message));
1747      }
1748  
1749      /**
1750       * @psalm-pure
1751       *
1752       * @param iterable<string> $value
1753       * @param string           $pattern
1754       * @param string           $message
1755       *
1756       * @throws InvalidArgumentException
1757       *
1758       * @return void
1759       */
1760      public static function allRegex($value, $pattern, $message = '')
1761      {
1762          static::__callStatic('allRegex', array($value, $pattern, $message));
1763      }
1764  
1765      /**
1766       * @psalm-pure
1767       *
1768       * @param string|null $value
1769       * @param string      $pattern
1770       * @param string      $message
1771       *
1772       * @throws InvalidArgumentException
1773       *
1774       * @return void
1775       */
1776      public static function nullOrNotRegex($value, $pattern, $message = '')
1777      {
1778          static::__callStatic('nullOrNotRegex', array($value, $pattern, $message));
1779      }
1780  
1781      /**
1782       * @psalm-pure
1783       *
1784       * @param iterable<string> $value
1785       * @param string           $pattern
1786       * @param string           $message
1787       *
1788       * @throws InvalidArgumentException
1789       *
1790       * @return void
1791       */
1792      public static function allNotRegex($value, $pattern, $message = '')
1793      {
1794          static::__callStatic('allNotRegex', array($value, $pattern, $message));
1795      }
1796  
1797      /**
1798       * @psalm-pure
1799       *
1800       * @param mixed  $value
1801       * @param string $message
1802       *
1803       * @throws InvalidArgumentException
1804       *
1805       * @return void
1806       */
1807      public static function nullOrUnicodeLetters($value, $message = '')
1808      {
1809          static::__callStatic('nullOrUnicodeLetters', array($value, $message));
1810      }
1811  
1812      /**
1813       * @psalm-pure
1814       *
1815       * @param mixed  $value
1816       * @param string $message
1817       *
1818       * @throws InvalidArgumentException
1819       *
1820       * @return void
1821       */
1822      public static function allUnicodeLetters($value, $message = '')
1823      {
1824          static::__callStatic('allUnicodeLetters', array($value, $message));
1825      }
1826  
1827      /**
1828       * @psalm-pure
1829       *
1830       * @param mixed  $value
1831       * @param string $message
1832       *
1833       * @throws InvalidArgumentException
1834       *
1835       * @return void
1836       */
1837      public static function nullOrAlpha($value, $message = '')
1838      {
1839          static::__callStatic('nullOrAlpha', array($value, $message));
1840      }
1841  
1842      /**
1843       * @psalm-pure
1844       *
1845       * @param mixed  $value
1846       * @param string $message
1847       *
1848       * @throws InvalidArgumentException
1849       *
1850       * @return void
1851       */
1852      public static function allAlpha($value, $message = '')
1853      {
1854          static::__callStatic('allAlpha', array($value, $message));
1855      }
1856  
1857      /**
1858       * @psalm-pure
1859       *
1860       * @param string|null $value
1861       * @param string      $message
1862       *
1863       * @throws InvalidArgumentException
1864       *
1865       * @return void
1866       */
1867      public static function nullOrDigits($value, $message = '')
1868      {
1869          static::__callStatic('nullOrDigits', array($value, $message));
1870      }
1871  
1872      /**
1873       * @psalm-pure
1874       *
1875       * @param iterable<string> $value
1876       * @param string           $message
1877       *
1878       * @throws InvalidArgumentException
1879       *
1880       * @return void
1881       */
1882      public static function allDigits($value, $message = '')
1883      {
1884          static::__callStatic('allDigits', array($value, $message));
1885      }
1886  
1887      /**
1888       * @psalm-pure
1889       *
1890       * @param string|null $value
1891       * @param string      $message
1892       *
1893       * @throws InvalidArgumentException
1894       *
1895       * @return void
1896       */
1897      public static function nullOrAlnum($value, $message = '')
1898      {
1899          static::__callStatic('nullOrAlnum', array($value, $message));
1900      }
1901  
1902      /**
1903       * @psalm-pure
1904       *
1905       * @param iterable<string> $value
1906       * @param string           $message
1907       *
1908       * @throws InvalidArgumentException
1909       *
1910       * @return void
1911       */
1912      public static function allAlnum($value, $message = '')
1913      {
1914          static::__callStatic('allAlnum', array($value, $message));
1915      }
1916  
1917      /**
1918       * @psalm-pure
1919       * @psalm-assert lowercase-string|null $value
1920       *
1921       * @param string|null $value
1922       * @param string      $message
1923       *
1924       * @throws InvalidArgumentException
1925       *
1926       * @return void
1927       */
1928      public static function nullOrLower($value, $message = '')
1929      {
1930          static::__callStatic('nullOrLower', array($value, $message));
1931      }
1932  
1933      /**
1934       * @psalm-pure
1935       * @psalm-assert iterable<lowercase-string> $value
1936       *
1937       * @param iterable<string> $value
1938       * @param string           $message
1939       *
1940       * @throws InvalidArgumentException
1941       *
1942       * @return void
1943       */
1944      public static function allLower($value, $message = '')
1945      {
1946          static::__callStatic('allLower', array($value, $message));
1947      }
1948  
1949      /**
1950       * @psalm-pure
1951       *
1952       * @param string|null $value
1953       * @param string      $message
1954       *
1955       * @throws InvalidArgumentException
1956       *
1957       * @return void
1958       */
1959      public static function nullOrUpper($value, $message = '')
1960      {
1961          static::__callStatic('nullOrUpper', array($value, $message));
1962      }
1963  
1964      /**
1965       * @psalm-pure
1966       *
1967       * @param iterable<string> $value
1968       * @param string           $message
1969       *
1970       * @throws InvalidArgumentException
1971       *
1972       * @return void
1973       */
1974      public static function allUpper($value, $message = '')
1975      {
1976          static::__callStatic('allUpper', array($value, $message));
1977      }
1978  
1979      /**
1980       * @psalm-pure
1981       *
1982       * @param string|null $value
1983       * @param int         $length
1984       * @param string      $message
1985       *
1986       * @throws InvalidArgumentException
1987       *
1988       * @return void
1989       */
1990      public static function nullOrLength($value, $length, $message = '')
1991      {
1992          static::__callStatic('nullOrLength', array($value, $length, $message));
1993      }
1994  
1995      /**
1996       * @psalm-pure
1997       *
1998       * @param iterable<string> $value
1999       * @param int              $length
2000       * @param string           $message
2001       *
2002       * @throws InvalidArgumentException
2003       *
2004       * @return void
2005       */
2006      public static function allLength($value, $length, $message = '')
2007      {
2008          static::__callStatic('allLength', array($value, $length, $message));
2009      }
2010  
2011      /**
2012       * @psalm-pure
2013       *
2014       * @param string|null $value
2015       * @param int|float   $min
2016       * @param string      $message
2017       *
2018       * @throws InvalidArgumentException
2019       *
2020       * @return void
2021       */
2022      public static function nullOrMinLength($value, $min, $message = '')
2023      {
2024          static::__callStatic('nullOrMinLength', array($value, $min, $message));
2025      }
2026  
2027      /**
2028       * @psalm-pure
2029       *
2030       * @param iterable<string> $value
2031       * @param int|float        $min
2032       * @param string           $message
2033       *
2034       * @throws InvalidArgumentException
2035       *
2036       * @return void
2037       */
2038      public static function allMinLength($value, $min, $message = '')
2039      {
2040          static::__callStatic('allMinLength', array($value, $min, $message));
2041      }
2042  
2043      /**
2044       * @psalm-pure
2045       *
2046       * @param string|null $value
2047       * @param int|float   $max
2048       * @param string      $message
2049       *
2050       * @throws InvalidArgumentException
2051       *
2052       * @return void
2053       */
2054      public static function nullOrMaxLength($value, $max, $message = '')
2055      {
2056          static::__callStatic('nullOrMaxLength', array($value, $max, $message));
2057      }
2058  
2059      /**
2060       * @psalm-pure
2061       *
2062       * @param iterable<string> $value
2063       * @param int|float        $max
2064       * @param string           $message
2065       *
2066       * @throws InvalidArgumentException
2067       *
2068       * @return void
2069       */
2070      public static function allMaxLength($value, $max, $message = '')
2071      {
2072          static::__callStatic('allMaxLength', array($value, $max, $message));
2073      }
2074  
2075      /**
2076       * @psalm-pure
2077       *
2078       * @param string|null $value
2079       * @param int|float   $min
2080       * @param int|float   $max
2081       * @param string      $message
2082       *
2083       * @throws InvalidArgumentException
2084       *
2085       * @return void
2086       */
2087      public static function nullOrLengthBetween($value, $min, $max, $message = '')
2088      {
2089          static::__callStatic('nullOrLengthBetween', array($value, $min, $max, $message));
2090      }
2091  
2092      /**
2093       * @psalm-pure
2094       *
2095       * @param iterable<string> $value
2096       * @param int|float        $min
2097       * @param int|float        $max
2098       * @param string           $message
2099       *
2100       * @throws InvalidArgumentException
2101       *
2102       * @return void
2103       */
2104      public static function allLengthBetween($value, $min, $max, $message = '')
2105      {
2106          static::__callStatic('allLengthBetween', array($value, $min, $max, $message));
2107      }
2108  
2109      /**
2110       * @param mixed  $value
2111       * @param string $message
2112       *
2113       * @throws InvalidArgumentException
2114       *
2115       * @return void
2116       */
2117      public static function nullOrFileExists($value, $message = '')
2118      {
2119          static::__callStatic('nullOrFileExists', array($value, $message));
2120      }
2121  
2122      /**
2123       * @param mixed  $value
2124       * @param string $message
2125       *
2126       * @throws InvalidArgumentException
2127       *
2128       * @return void
2129       */
2130      public static function allFileExists($value, $message = '')
2131      {
2132          static::__callStatic('allFileExists', array($value, $message));
2133      }
2134  
2135      /**
2136       * @param mixed  $value
2137       * @param string $message
2138       *
2139       * @throws InvalidArgumentException
2140       *
2141       * @return void
2142       */
2143      public static function nullOrFile($value, $message = '')
2144      {
2145          static::__callStatic('nullOrFile', array($value, $message));
2146      }
2147  
2148      /**
2149       * @param mixed  $value
2150       * @param string $message
2151       *
2152       * @throws InvalidArgumentException
2153       *
2154       * @return void
2155       */
2156      public static function allFile($value, $message = '')
2157      {
2158          static::__callStatic('allFile', array($value, $message));
2159      }
2160  
2161      /**
2162       * @param mixed  $value
2163       * @param string $message
2164       *
2165       * @throws InvalidArgumentException
2166       *
2167       * @return void
2168       */
2169      public static function nullOrDirectory($value, $message = '')
2170      {
2171          static::__callStatic('nullOrDirectory', array($value, $message));
2172      }
2173  
2174      /**
2175       * @param mixed  $value
2176       * @param string $message
2177       *
2178       * @throws InvalidArgumentException
2179       *
2180       * @return void
2181       */
2182      public static function allDirectory($value, $message = '')
2183      {
2184          static::__callStatic('allDirectory', array($value, $message));
2185      }
2186  
2187      /**
2188       * @param string|null $value
2189       * @param string      $message
2190       *
2191       * @throws InvalidArgumentException
2192       *
2193       * @return void
2194       */
2195      public static function nullOrReadable($value, $message = '')
2196      {
2197          static::__callStatic('nullOrReadable', array($value, $message));
2198      }
2199  
2200      /**
2201       * @param iterable<string> $value
2202       * @param string           $message
2203       *
2204       * @throws InvalidArgumentException
2205       *
2206       * @return void
2207       */
2208      public static function allReadable($value, $message = '')
2209      {
2210          static::__callStatic('allReadable', array($value, $message));
2211      }
2212  
2213      /**
2214       * @param string|null $value
2215       * @param string      $message
2216       *
2217       * @throws InvalidArgumentException
2218       *
2219       * @return void
2220       */
2221      public static function nullOrWritable($value, $message = '')
2222      {
2223          static::__callStatic('nullOrWritable', array($value, $message));
2224      }
2225  
2226      /**
2227       * @param iterable<string> $value
2228       * @param string           $message
2229       *
2230       * @throws InvalidArgumentException
2231       *
2232       * @return void
2233       */
2234      public static function allWritable($value, $message = '')
2235      {
2236          static::__callStatic('allWritable', array($value, $message));
2237      }
2238  
2239      /**
2240       * @psalm-assert class-string|null $value
2241       *
2242       * @param mixed  $value
2243       * @param string $message
2244       *
2245       * @throws InvalidArgumentException
2246       *
2247       * @return void
2248       */
2249      public static function nullOrClassExists($value, $message = '')
2250      {
2251          static::__callStatic('nullOrClassExists', array($value, $message));
2252      }
2253  
2254      /**
2255       * @psalm-assert iterable<class-string> $value
2256       *
2257       * @param mixed  $value
2258       * @param string $message
2259       *
2260       * @throws InvalidArgumentException
2261       *
2262       * @return void
2263       */
2264      public static function allClassExists($value, $message = '')
2265      {
2266          static::__callStatic('allClassExists', array($value, $message));
2267      }
2268  
2269      /**
2270       * @psalm-pure
2271       * @psalm-template ExpectedType of object
2272       * @psalm-param class-string<ExpectedType> $class
2273       * @psalm-assert class-string<ExpectedType>|ExpectedType|null $value
2274       *
2275       * @param mixed         $value
2276       * @param string|object $class
2277       * @param string        $message
2278       *
2279       * @throws InvalidArgumentException
2280       *
2281       * @return void
2282       */
2283      public static function nullOrSubclassOf($value, $class, $message = '')
2284      {
2285          static::__callStatic('nullOrSubclassOf', array($value, $class, $message));
2286      }
2287  
2288      /**
2289       * @psalm-pure
2290       * @psalm-template ExpectedType of object
2291       * @psalm-param class-string<ExpectedType> $class
2292       * @psalm-assert iterable<class-string<ExpectedType>|ExpectedType> $value
2293       *
2294       * @param mixed         $value
2295       * @param string|object $class
2296       * @param string        $message
2297       *
2298       * @throws InvalidArgumentException
2299       *
2300       * @return void
2301       */
2302      public static function allSubclassOf($value, $class, $message = '')
2303      {
2304          static::__callStatic('allSubclassOf', array($value, $class, $message));
2305      }
2306  
2307      /**
2308       * @psalm-assert class-string|null $value
2309       *
2310       * @param mixed  $value
2311       * @param string $message
2312       *
2313       * @throws InvalidArgumentException
2314       *
2315       * @return void
2316       */
2317      public static function nullOrInterfaceExists($value, $message = '')
2318      {
2319          static::__callStatic('nullOrInterfaceExists', array($value, $message));
2320      }
2321  
2322      /**
2323       * @psalm-assert iterable<class-string> $value
2324       *
2325       * @param mixed  $value
2326       * @param string $message
2327       *
2328       * @throws InvalidArgumentException
2329       *
2330       * @return void
2331       */
2332      public static function allInterfaceExists($value, $message = '')
2333      {
2334          static::__callStatic('allInterfaceExists', array($value, $message));
2335      }
2336  
2337      /**
2338       * @psalm-pure
2339       * @psalm-template ExpectedType of object
2340       * @psalm-param class-string<ExpectedType> $interface
2341       * @psalm-assert class-string<ExpectedType>|null $value
2342       *
2343       * @param mixed  $value
2344       * @param mixed  $interface
2345       * @param string $message
2346       *
2347       * @throws InvalidArgumentException
2348       *
2349       * @return void
2350       */
2351      public static function nullOrImplementsInterface($value, $interface, $message = '')
2352      {
2353          static::__callStatic('nullOrImplementsInterface', array($value, $interface, $message));
2354      }
2355  
2356      /**
2357       * @psalm-pure
2358       * @psalm-template ExpectedType of object
2359       * @psalm-param class-string<ExpectedType> $interface
2360       * @psalm-assert iterable<class-string<ExpectedType>> $value
2361       *
2362       * @param mixed  $value
2363       * @param mixed  $interface
2364       * @param string $message
2365       *
2366       * @throws InvalidArgumentException
2367       *
2368       * @return void
2369       */
2370      public static function allImplementsInterface($value, $interface, $message = '')
2371      {
2372          static::__callStatic('allImplementsInterface', array($value, $interface, $message));
2373      }
2374  
2375      /**
2376       * @psalm-pure
2377       * @psalm-param class-string|object|null $classOrObject
2378       *
2379       * @param string|object|null $classOrObject
2380       * @param mixed              $property
2381       * @param string             $message
2382       *
2383       * @throws InvalidArgumentException
2384       *
2385       * @return void
2386       */
2387      public static function nullOrPropertyExists($classOrObject, $property, $message = '')
2388      {
2389          static::__callStatic('nullOrPropertyExists', array($classOrObject, $property, $message));
2390      }
2391  
2392      /**
2393       * @psalm-pure
2394       * @psalm-param iterable<class-string|object> $classOrObject
2395       *
2396       * @param iterable<string|object> $classOrObject
2397       * @param mixed                   $property
2398       * @param string                  $message
2399       *
2400       * @throws InvalidArgumentException
2401       *
2402       * @return void
2403       */
2404      public static function allPropertyExists($classOrObject, $property, $message = '')
2405      {
2406          static::__callStatic('allPropertyExists', array($classOrObject, $property, $message));
2407      }
2408  
2409      /**
2410       * @psalm-pure
2411       * @psalm-param class-string|object|null $classOrObject
2412       *
2413       * @param string|object|null $classOrObject
2414       * @param mixed              $property
2415       * @param string             $message
2416       *
2417       * @throws InvalidArgumentException
2418       *
2419       * @return void
2420       */
2421      public static function nullOrPropertyNotExists($classOrObject, $property, $message = '')
2422      {
2423          static::__callStatic('nullOrPropertyNotExists', array($classOrObject, $property, $message));
2424      }
2425  
2426      /**
2427       * @psalm-pure
2428       * @psalm-param iterable<class-string|object> $classOrObject
2429       *
2430       * @param iterable<string|object> $classOrObject
2431       * @param mixed                   $property
2432       * @param string                  $message
2433       *
2434       * @throws InvalidArgumentException
2435       *
2436       * @return void
2437       */
2438      public static function allPropertyNotExists($classOrObject, $property, $message = '')
2439      {
2440          static::__callStatic('allPropertyNotExists', array($classOrObject, $property, $message));
2441      }
2442  
2443      /**
2444       * @psalm-pure
2445       * @psalm-param class-string|object|null $classOrObject
2446       *
2447       * @param string|object|null $classOrObject
2448       * @param mixed              $method
2449       * @param string             $message
2450       *
2451       * @throws InvalidArgumentException
2452       *
2453       * @return void
2454       */
2455      public static function nullOrMethodExists($classOrObject, $method, $message = '')
2456      {
2457          static::__callStatic('nullOrMethodExists', array($classOrObject, $method, $message));
2458      }
2459  
2460      /**
2461       * @psalm-pure
2462       * @psalm-param iterable<class-string|object> $classOrObject
2463       *
2464       * @param iterable<string|object> $classOrObject
2465       * @param mixed                   $method
2466       * @param string                  $message
2467       *
2468       * @throws InvalidArgumentException
2469       *
2470       * @return void
2471       */
2472      public static function allMethodExists($classOrObject, $method, $message = '')
2473      {
2474          static::__callStatic('allMethodExists', array($classOrObject, $method, $message));
2475      }
2476  
2477      /**
2478       * @psalm-pure
2479       * @psalm-param class-string|object|null $classOrObject
2480       *
2481       * @param string|object|null $classOrObject
2482       * @param mixed              $method
2483       * @param string             $message
2484       *
2485       * @throws InvalidArgumentException
2486       *
2487       * @return void
2488       */
2489      public static function nullOrMethodNotExists($classOrObject, $method, $message = '')
2490      {
2491          static::__callStatic('nullOrMethodNotExists', array($classOrObject, $method, $message));
2492      }
2493  
2494      /**
2495       * @psalm-pure
2496       * @psalm-param iterable<class-string|object> $classOrObject
2497       *
2498       * @param iterable<string|object> $classOrObject
2499       * @param mixed                   $method
2500       * @param string                  $message
2501       *
2502       * @throws InvalidArgumentException
2503       *
2504       * @return void
2505       */
2506      public static function allMethodNotExists($classOrObject, $method, $message = '')
2507      {
2508          static::__callStatic('allMethodNotExists', array($classOrObject, $method, $message));
2509      }
2510  
2511      /**
2512       * @psalm-pure
2513       *
2514       * @param array|null $array
2515       * @param string|int $key
2516       * @param string     $message
2517       *
2518       * @throws InvalidArgumentException
2519       *
2520       * @return void
2521       */
2522      public static function nullOrKeyExists($array, $key, $message = '')
2523      {
2524          static::__callStatic('nullOrKeyExists', array($array, $key, $message));
2525      }
2526  
2527      /**
2528       * @psalm-pure
2529       *
2530       * @param iterable<array> $array
2531       * @param string|int      $key
2532       * @param string          $message
2533       *
2534       * @throws InvalidArgumentException
2535       *
2536       * @return void
2537       */
2538      public static function allKeyExists($array, $key, $message = '')
2539      {
2540          static::__callStatic('allKeyExists', array($array, $key, $message));
2541      }
2542  
2543      /**
2544       * @psalm-pure
2545       *
2546       * @param array|null $array
2547       * @param string|int $key
2548       * @param string     $message
2549       *
2550       * @throws InvalidArgumentException
2551       *
2552       * @return void
2553       */
2554      public static function nullOrKeyNotExists($array, $key, $message = '')
2555      {
2556          static::__callStatic('nullOrKeyNotExists', array($array, $key, $message));
2557      }
2558  
2559      /**
2560       * @psalm-pure
2561       *
2562       * @param iterable<array> $array
2563       * @param string|int      $key
2564       * @param string          $message
2565       *
2566       * @throws InvalidArgumentException
2567       *
2568       * @return void
2569       */
2570      public static function allKeyNotExists($array, $key, $message = '')
2571      {
2572          static::__callStatic('allKeyNotExists', array($array, $key, $message));
2573      }
2574  
2575      /**
2576       * @psalm-pure
2577       * @psalm-assert array-key|null $value
2578       *
2579       * @param mixed  $value
2580       * @param string $message
2581       *
2582       * @throws InvalidArgumentException
2583       *
2584       * @return void
2585       */
2586      public static function nullOrValidArrayKey($value, $message = '')
2587      {
2588          static::__callStatic('nullOrValidArrayKey', array($value, $message));
2589      }
2590  
2591      /**
2592       * @psalm-pure
2593       * @psalm-assert iterable<array-key> $value
2594       *
2595       * @param mixed  $value
2596       * @param string $message
2597       *
2598       * @throws InvalidArgumentException
2599       *
2600       * @return void
2601       */
2602      public static function allValidArrayKey($value, $message = '')
2603      {
2604          static::__callStatic('allValidArrayKey', array($value, $message));
2605      }
2606  
2607      /**
2608       * @param Countable|array|null $array
2609       * @param int                  $number
2610       * @param string               $message
2611       *
2612       * @throws InvalidArgumentException
2613       *
2614       * @return void
2615       */
2616      public static function nullOrCount($array, $number, $message = '')
2617      {
2618          static::__callStatic('nullOrCount', array($array, $number, $message));
2619      }
2620  
2621      /**
2622       * @param iterable<Countable|array> $array
2623       * @param int                       $number
2624       * @param string                    $message
2625       *
2626       * @throws InvalidArgumentException
2627       *
2628       * @return void
2629       */
2630      public static function allCount($array, $number, $message = '')
2631      {
2632          static::__callStatic('allCount', array($array, $number, $message));
2633      }
2634  
2635      /**
2636       * @param Countable|array|null $array
2637       * @param int|float            $min
2638       * @param string               $message
2639       *
2640       * @throws InvalidArgumentException
2641       *
2642       * @return void
2643       */
2644      public static function nullOrMinCount($array, $min, $message = '')
2645      {
2646          static::__callStatic('nullOrMinCount', array($array, $min, $message));
2647      }
2648  
2649      /**
2650       * @param iterable<Countable|array> $array
2651       * @param int|float                 $min
2652       * @param string                    $message
2653       *
2654       * @throws InvalidArgumentException
2655       *
2656       * @return void
2657       */
2658      public static function allMinCount($array, $min, $message = '')
2659      {
2660          static::__callStatic('allMinCount', array($array, $min, $message));
2661      }
2662  
2663      /**
2664       * @param Countable|array|null $array
2665       * @param int|float            $max
2666       * @param string               $message
2667       *
2668       * @throws InvalidArgumentException
2669       *
2670       * @return void
2671       */
2672      public static function nullOrMaxCount($array, $max, $message = '')
2673      {
2674          static::__callStatic('nullOrMaxCount', array($array, $max, $message));
2675      }
2676  
2677      /**
2678       * @param iterable<Countable|array> $array
2679       * @param int|float                 $max
2680       * @param string                    $message
2681       *
2682       * @throws InvalidArgumentException
2683       *
2684       * @return void
2685       */
2686      public static function allMaxCount($array, $max, $message = '')
2687      {
2688          static::__callStatic('allMaxCount', array($array, $max, $message));
2689      }
2690  
2691      /**
2692       * @param Countable|array|null $array
2693       * @param int|float            $min
2694       * @param int|float            $max
2695       * @param string               $message
2696       *
2697       * @throws InvalidArgumentException
2698       *
2699       * @return void
2700       */
2701      public static function nullOrCountBetween($array, $min, $max, $message = '')
2702      {
2703          static::__callStatic('nullOrCountBetween', array($array, $min, $max, $message));
2704      }
2705  
2706      /**
2707       * @param iterable<Countable|array> $array
2708       * @param int|float                 $min
2709       * @param int|float                 $max
2710       * @param string                    $message
2711       *
2712       * @throws InvalidArgumentException
2713       *
2714       * @return void
2715       */
2716      public static function allCountBetween($array, $min, $max, $message = '')
2717      {
2718          static::__callStatic('allCountBetween', array($array, $min, $max, $message));
2719      }
2720  
2721      /**
2722       * @psalm-pure
2723       * @psalm-assert list|null $array
2724       *
2725       * @param mixed  $array
2726       * @param string $message
2727       *
2728       * @throws InvalidArgumentException
2729       *
2730       * @return void
2731       */
2732      public static function nullOrIsList($array, $message = '')
2733      {
2734          static::__callStatic('nullOrIsList', array($array, $message));
2735      }
2736  
2737      /**
2738       * @psalm-pure
2739       * @psalm-assert iterable<list> $array
2740       *
2741       * @param mixed  $array
2742       * @param string $message
2743       *
2744       * @throws InvalidArgumentException
2745       *
2746       * @return void
2747       */
2748      public static function allIsList($array, $message = '')
2749      {
2750          static::__callStatic('allIsList', array($array, $message));
2751      }
2752  
2753      /**
2754       * @psalm-pure
2755       * @psalm-assert non-empty-list|null $array
2756       *
2757       * @param mixed  $array
2758       * @param string $message
2759       *
2760       * @throws InvalidArgumentException
2761       *
2762       * @return void
2763       */
2764      public static function nullOrIsNonEmptyList($array, $message = '')
2765      {
2766          static::__callStatic('nullOrIsNonEmptyList', array($array, $message));
2767      }
2768  
2769      /**
2770       * @psalm-pure
2771       * @psalm-assert iterable<non-empty-list> $array
2772       *
2773       * @param mixed  $array
2774       * @param string $message
2775       *
2776       * @throws InvalidArgumentException
2777       *
2778       * @return void
2779       */
2780      public static function allIsNonEmptyList($array, $message = '')
2781      {
2782          static::__callStatic('allIsNonEmptyList', array($array, $message));
2783      }
2784  
2785      /**
2786       * @psalm-pure
2787       * @psalm-template T
2788       * @psalm-param mixed|array<T>|null $array
2789       * @psalm-assert array<string, T>|null $array
2790       *
2791       * @param mixed  $array
2792       * @param string $message
2793       *
2794       * @throws InvalidArgumentException
2795       *
2796       * @return void
2797       */
2798      public static function nullOrIsMap($array, $message = '')
2799      {
2800          static::__callStatic('nullOrIsMap', array($array, $message));
2801      }
2802  
2803      /**
2804       * @psalm-pure
2805       * @psalm-template T
2806       * @psalm-param iterable<mixed|array<T>> $array
2807       * @psalm-assert iterable<array<string, T>> $array
2808       *
2809       * @param mixed  $array
2810       * @param string $message
2811       *
2812       * @throws InvalidArgumentException
2813       *
2814       * @return void
2815       */
2816      public static function allIsMap($array, $message = '')
2817      {
2818          static::__callStatic('allIsMap', array($array, $message));
2819      }
2820  
2821      /**
2822       * @psalm-pure
2823       * @psalm-template T
2824       * @psalm-param mixed|array<T>|null $array
2825       *
2826       * @param mixed  $array
2827       * @param string $message
2828       *
2829       * @throws InvalidArgumentException
2830       *
2831       * @return void
2832       */
2833      public static function nullOrIsNonEmptyMap($array, $message = '')
2834      {
2835          static::__callStatic('nullOrIsNonEmptyMap', array($array, $message));
2836      }
2837  
2838      /**
2839       * @psalm-pure
2840       * @psalm-template T
2841       * @psalm-param iterable<mixed|array<T>> $array
2842       *
2843       * @param mixed  $array
2844       * @param string $message
2845       *
2846       * @throws InvalidArgumentException
2847       *
2848       * @return void
2849       */
2850      public static function allIsNonEmptyMap($array, $message = '')
2851      {
2852          static::__callStatic('allIsNonEmptyMap', array($array, $message));
2853      }
2854  
2855      /**
2856       * @psalm-pure
2857       *
2858       * @param string|null $value
2859       * @param string      $message
2860       *
2861       * @throws InvalidArgumentException
2862       *
2863       * @return void
2864       */
2865      public static function nullOrUuid($value, $message = '')
2866      {
2867          static::__callStatic('nullOrUuid', array($value, $message));
2868      }
2869  
2870      /**
2871       * @psalm-pure
2872       *
2873       * @param iterable<string> $value
2874       * @param string           $message
2875       *
2876       * @throws InvalidArgumentException
2877       *
2878       * @return void
2879       */
2880      public static function allUuid($value, $message = '')
2881      {
2882          static::__callStatic('allUuid', array($value, $message));
2883      }
2884  
2885      /**
2886       * @psalm-param class-string<Throwable> $class
2887       *
2888       * @param Closure|null $expression
2889       * @param string       $class
2890       * @param string       $message
2891       *
2892       * @throws InvalidArgumentException
2893       *
2894       * @return void
2895       */
2896      public static function nullOrThrows($expression, $class = 'Exception', $message = '')
2897      {
2898          static::__callStatic('nullOrThrows', array($expression, $class, $message));
2899      }
2900  
2901      /**
2902       * @psalm-param class-string<Throwable> $class
2903       *
2904       * @param iterable<Closure> $expression
2905       * @param string            $class
2906       * @param string            $message
2907       *
2908       * @throws InvalidArgumentException
2909       *
2910       * @return void
2911       */
2912      public static function allThrows($expression, $class = 'Exception', $message = '')
2913      {
2914          static::__callStatic('allThrows', array($expression, $class, $message));
2915      }
2916  }