vendor/webmozart/assert/src/Mixin.php line 49

Open in your IDE?
  1. <?php
  3. /**
  4.  * provides type inference and auto-completion for magic static methods of Assert.
  5.  */
  7. namespace Webmozart\Assert;
  9. use ArrayAccess;
  10. use Closure;
  11. use Countable;
  12. use Throwable;
  14. /**
  15.  * This trait aids static analysis tooling in introspecting assertion magic methods.
  16.  * Do not use this trait directly: it will change, and is not designed for reuse.
  17.  */
  18. trait Mixin
  19. {
  20.     /**
  21.      * @psalm-pure
  22.      * @psalm-assert string|null $value
  23.      *
  24.      * @param mixed  $value
  25.      * @param string $message
  26.      *
  27.      * @throws InvalidArgumentException
  28.      *
  29.      * @return void
  30.      */
  31.     public static function nullOrString($value, $message = '')
  32.     {
  33.         static::__callStatic('nullOrString', array($value, $message));
  34.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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.     }
  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. }