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