1<?php 2 3/** 4 * provides type inference and auto-completion for magic static methods of Assert. 5 */ 6 7namespace Webmozart\Assert; 8 9use ArrayAccess; 10use Closure; 11use Countable; 12use 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 */ 18trait 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} 2917