Subversion-Projekte lars-tiefland.laravel_shop

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
1664 lars 1 
<?php
2 
// @formatter:off
3 
// phpcs:ignoreFile
4 
 
5 
/**
6 
 * A helper file for Laravel, to provide autocomplete information to your IDE
7 
 * Generated for Laravel 9.52.7.
8 
 *
9 
 * This file should not be included in your code, only analyzed by your IDE!
10 
 *
11 
 * @author Barry vd. Heuvel <barryvdh@gmail.com>
12 
 * @see https://github.com/barryvdh/laravel-ide-helper
13 
 */
14 
 
15 
    namespace Illuminate\Support\Facades {
16 
            /**
17 
     *
18 
     *
19 
     * @see \Illuminate\Foundation\Application
20 
     */
21 
        class App {
22 
                    /**
23 
         * Get the version number of the application.
24 
         *
25 
         * @return string
26 
         * @static
27 
         */
28 
        public static function version()
29 
        {
30 
                        /** @var \Illuminate\Foundation\Application $instance */
31 
                        return $instance->version();
32 
        }
33 
                    /**
34 
         * Run the given array of bootstrap classes.
35 
         *
36 
         * @param string[] $bootstrappers
37 
         * @return void
38 
         * @static
39 
         */
40 
        public static function bootstrapWith($bootstrappers)
41 
        {
42 
                        /** @var \Illuminate\Foundation\Application $instance */
43 
                        $instance->bootstrapWith($bootstrappers);
44 
        }
45 
                    /**
46 
         * Register a callback to run after loading the environment.
47 
         *
48 
         * @param \Closure $callback
49 
         * @return void
50 
         * @static
51 
         */
52 
        public static function afterLoadingEnvironment($callback)
53 
        {
54 
                        /** @var \Illuminate\Foundation\Application $instance */
55 
                        $instance->afterLoadingEnvironment($callback);
56 
        }
57 
                    /**
58 
         * Register a callback to run before a bootstrapper.
59 
         *
60 
         * @param string $bootstrapper
61 
         * @param \Closure $callback
62 
         * @return void
63 
         * @static
64 
         */
65 
        public static function beforeBootstrapping($bootstrapper, $callback)
66 
        {
67 
                        /** @var \Illuminate\Foundation\Application $instance */
68 
                        $instance->beforeBootstrapping($bootstrapper, $callback);
69 
        }
70 
                    /**
71 
         * Register a callback to run after a bootstrapper.
72 
         *
73 
         * @param string $bootstrapper
74 
         * @param \Closure $callback
75 
         * @return void
76 
         * @static
77 
         */
78 
        public static function afterBootstrapping($bootstrapper, $callback)
79 
        {
80 
                        /** @var \Illuminate\Foundation\Application $instance */
81 
                        $instance->afterBootstrapping($bootstrapper, $callback);
82 
        }
83 
                    /**
84 
         * Determine if the application has been bootstrapped before.
85 
         *
86 
         * @return bool
87 
         * @static
88 
         */
89 
        public static function hasBeenBootstrapped()
90 
        {
91 
                        /** @var \Illuminate\Foundation\Application $instance */
92 
                        return $instance->hasBeenBootstrapped();
93 
        }
94 
                    /**
95 
         * Set the base path for the application.
96 
         *
97 
         * @param string $basePath
98 
         * @return \Illuminate\Foundation\Application
99 
         * @static
100 
         */
101 
        public static function setBasePath($basePath)
102 
        {
103 
                        /** @var \Illuminate\Foundation\Application $instance */
104 
                        return $instance->setBasePath($basePath);
105 
        }
106 
                    /**
107 
         * Get the path to the application "app" directory.
108 
         *
109 
         * @param string $path
110 
         * @return string
111 
         * @static
112 
         */
113 
        public static function path($path = '')
114 
        {
115 
                        /** @var \Illuminate\Foundation\Application $instance */
116 
                        return $instance->path($path);
117 
        }
118 
                    /**
119 
         * Set the application directory.
120 
         *
121 
         * @param string $path
122 
         * @return \Illuminate\Foundation\Application
123 
         * @static
124 
         */
125 
        public static function useAppPath($path)
126 
        {
127 
                        /** @var \Illuminate\Foundation\Application $instance */
128 
                        return $instance->useAppPath($path);
129 
        }
130 
                    /**
131 
         * Get the base path of the Laravel installation.
132 
         *
133 
         * @param string $path
134 
         * @return string
135 
         * @static
136 
         */
137 
        public static function basePath($path = '')
138 
        {
139 
                        /** @var \Illuminate\Foundation\Application $instance */
140 
                        return $instance->basePath($path);
141 
        }
142 
                    /**
143 
         * Get the path to the bootstrap directory.
144 
         *
145 
         * @param string $path
146 
         * @return string
147 
         * @static
148 
         */
149 
        public static function bootstrapPath($path = '')
150 
        {
151 
                        /** @var \Illuminate\Foundation\Application $instance */
152 
                        return $instance->bootstrapPath($path);
153 
        }
154 
                    /**
155 
         * Get the path to the application configuration files.
156 
         *
157 
         * @param string $path
158 
         * @return string
159 
         * @static
160 
         */
161 
        public static function configPath($path = '')
162 
        {
163 
                        /** @var \Illuminate\Foundation\Application $instance */
164 
                        return $instance->configPath($path);
165 
        }
166 
                    /**
167 
         * Get the path to the database directory.
168 
         *
169 
         * @param string $path
170 
         * @return string
171 
         * @static
172 
         */
173 
        public static function databasePath($path = '')
174 
        {
175 
                        /** @var \Illuminate\Foundation\Application $instance */
176 
                        return $instance->databasePath($path);
177 
        }
178 
                    /**
179 
         * Set the database directory.
180 
         *
181 
         * @param string $path
182 
         * @return \Illuminate\Foundation\Application
183 
         * @static
184 
         */
185 
        public static function useDatabasePath($path)
186 
        {
187 
                        /** @var \Illuminate\Foundation\Application $instance */
188 
                        return $instance->useDatabasePath($path);
189 
        }
190 
                    /**
191 
         * Get the path to the language files.
192 
         *
193 
         * @param string $path
194 
         * @return string
195 
         * @static
196 
         */
197 
        public static function langPath($path = '')
198 
        {
199 
                        /** @var \Illuminate\Foundation\Application $instance */
200 
                        return $instance->langPath($path);
201 
        }
202 
                    /**
203 
         * Set the language file directory.
204 
         *
205 
         * @param string $path
206 
         * @return \Illuminate\Foundation\Application
207 
         * @static
208 
         */
209 
        public static function useLangPath($path)
210 
        {
211 
                        /** @var \Illuminate\Foundation\Application $instance */
212 
                        return $instance->useLangPath($path);
213 
        }
214 
                    /**
215 
         * Get the path to the public / web directory.
216 
         *
217 
         * @return string
218 
         * @static
219 
         */
220 
        public static function publicPath()
221 
        {
222 
                        /** @var \Illuminate\Foundation\Application $instance */
223 
                        return $instance->publicPath();
224 
        }
225 
                    /**
226 
         * Get the path to the storage directory.
227 
         *
228 
         * @param string $path
229 
         * @return string
230 
         * @static
231 
         */
232 
        public static function storagePath($path = '')
233 
        {
234 
                        /** @var \Illuminate\Foundation\Application $instance */
235 
                        return $instance->storagePath($path);
236 
        }
237 
                    /**
238 
         * Set the storage directory.
239 
         *
240 
         * @param string $path
241 
         * @return \Illuminate\Foundation\Application
242 
         * @static
243 
         */
244 
        public static function useStoragePath($path)
245 
        {
246 
                        /** @var \Illuminate\Foundation\Application $instance */
247 
                        return $instance->useStoragePath($path);
248 
        }
249 
                    /**
250 
         * Get the path to the resources directory.
251 
         *
252 
         * @param string $path
253 
         * @return string
254 
         * @static
255 
         */
256 
        public static function resourcePath($path = '')
257 
        {
258 
                        /** @var \Illuminate\Foundation\Application $instance */
259 
                        return $instance->resourcePath($path);
260 
        }
261 
                    /**
262 
         * Get the path to the views directory.
263 
         *
264 
         * This method returns the first configured path in the array of view paths.
265 
         *
266 
         * @param string $path
267 
         * @return string
268 
         * @static
269 
         */
270 
        public static function viewPath($path = '')
271 
        {
272 
                        /** @var \Illuminate\Foundation\Application $instance */
273 
                        return $instance->viewPath($path);
274 
        }
275 
                    /**
276 
         * Get the path to the environment file directory.
277 
         *
278 
         * @return string
279 
         * @static
280 
         */
281 
        public static function environmentPath()
282 
        {
283 
                        /** @var \Illuminate\Foundation\Application $instance */
284 
                        return $instance->environmentPath();
285 
        }
286 
                    /**
287 
         * Set the directory for the environment file.
288 
         *
289 
         * @param string $path
290 
         * @return \Illuminate\Foundation\Application
291 
         * @static
292 
         */
293 
        public static function useEnvironmentPath($path)
294 
        {
295 
                        /** @var \Illuminate\Foundation\Application $instance */
296 
                        return $instance->useEnvironmentPath($path);
297 
        }
298 
                    /**
299 
         * Set the environment file to be loaded during bootstrapping.
300 
         *
301 
         * @param string $file
302 
         * @return \Illuminate\Foundation\Application
303 
         * @static
304 
         */
305 
        public static function loadEnvironmentFrom($file)
306 
        {
307 
                        /** @var \Illuminate\Foundation\Application $instance */
308 
                        return $instance->loadEnvironmentFrom($file);
309 
        }
310 
                    /**
311 
         * Get the environment file the application is using.
312 
         *
313 
         * @return string
314 
         * @static
315 
         */
316 
        public static function environmentFile()
317 
        {
318 
                        /** @var \Illuminate\Foundation\Application $instance */
319 
                        return $instance->environmentFile();
320 
        }
321 
                    /**
322 
         * Get the fully qualified path to the environment file.
323 
         *
324 
         * @return string
325 
         * @static
326 
         */
327 
        public static function environmentFilePath()
328 
        {
329 
                        /** @var \Illuminate\Foundation\Application $instance */
330 
                        return $instance->environmentFilePath();
331 
        }
332 
                    /**
333 
         * Get or check the current application environment.
334 
         *
335 
         * @param string|array $environments
336 
         * @return string|bool
337 
         * @static
338 
         */
339 
        public static function environment(...$environments)
340 
        {
341 
                        /** @var \Illuminate\Foundation\Application $instance */
342 
                        return $instance->environment(...$environments);
343 
        }
344 
                    /**
345 
         * Determine if the application is in the local environment.
346 
         *
347 
         * @return bool
348 
         * @static
349 
         */
350 
        public static function isLocal()
351 
        {
352 
                        /** @var \Illuminate\Foundation\Application $instance */
353 
                        return $instance->isLocal();
354 
        }
355 
                    /**
356 
         * Determine if the application is in the production environment.
357 
         *
358 
         * @return bool
359 
         * @static
360 
         */
361 
        public static function isProduction()
362 
        {
363 
                        /** @var \Illuminate\Foundation\Application $instance */
364 
                        return $instance->isProduction();
365 
        }
366 
                    /**
367 
         * Detect the application's current environment.
368 
         *
369 
         * @param \Closure $callback
370 
         * @return string
371 
         * @static
372 
         */
373 
        public static function detectEnvironment($callback)
374 
        {
375 
                        /** @var \Illuminate\Foundation\Application $instance */
376 
                        return $instance->detectEnvironment($callback);
377 
        }
378 
                    /**
379 
         * Determine if the application is running in the console.
380 
         *
381 
         * @return bool
382 
         * @static
383 
         */
384 
        public static function runningInConsole()
385 
        {
386 
                        /** @var \Illuminate\Foundation\Application $instance */
387 
                        return $instance->runningInConsole();
388 
        }
389 
                    /**
390 
         * Determine if the application is running unit tests.
391 
         *
392 
         * @return bool
393 
         * @static
394 
         */
395 
        public static function runningUnitTests()
396 
        {
397 
                        /** @var \Illuminate\Foundation\Application $instance */
398 
                        return $instance->runningUnitTests();
399 
        }
400 
                    /**
401 
         * Determine if the application is running with debug mode enabled.
402 
         *
403 
         * @return bool
404 
         * @static
405 
         */
406 
        public static function hasDebugModeEnabled()
407 
        {
408 
                        /** @var \Illuminate\Foundation\Application $instance */
409 
                        return $instance->hasDebugModeEnabled();
410 
        }
411 
                    /**
412 
         * Register all of the configured providers.
413 
         *
414 
         * @return void
415 
         * @static
416 
         */
417 
        public static function registerConfiguredProviders()
418 
        {
419 
                        /** @var \Illuminate\Foundation\Application $instance */
420 
                        $instance->registerConfiguredProviders();
421 
        }
422 
                    /**
423 
         * Register a service provider with the application.
424 
         *
425 
         * @param \Illuminate\Support\ServiceProvider|string $provider
426 
         * @param bool $force
427 
         * @return \Illuminate\Support\ServiceProvider
428 
         * @static
429 
         */
430 
        public static function register($provider, $force = false)
431 
        {
432 
                        /** @var \Illuminate\Foundation\Application $instance */
433 
                        return $instance->register($provider, $force);
434 
        }
435 
                    /**
436 
         * Get the registered service provider instance if it exists.
437 
         *
438 
         * @param \Illuminate\Support\ServiceProvider|string $provider
439 
         * @return \Illuminate\Support\ServiceProvider|null
440 
         * @static
441 
         */
442 
        public static function getProvider($provider)
443 
        {
444 
                        /** @var \Illuminate\Foundation\Application $instance */
445 
                        return $instance->getProvider($provider);
446 
        }
447 
                    /**
448 
         * Get the registered service provider instances if any exist.
449 
         *
450 
         * @param \Illuminate\Support\ServiceProvider|string $provider
451 
         * @return array
452 
         * @static
453 
         */
454 
        public static function getProviders($provider)
455 
        {
456 
                        /** @var \Illuminate\Foundation\Application $instance */
457 
                        return $instance->getProviders($provider);
458 
        }
459 
                    /**
460 
         * Resolve a service provider instance from the class name.
461 
         *
462 
         * @param string $provider
463 
         * @return \Illuminate\Support\ServiceProvider
464 
         * @static
465 
         */
466 
        public static function resolveProvider($provider)
467 
        {
468 
                        /** @var \Illuminate\Foundation\Application $instance */
469 
                        return $instance->resolveProvider($provider);
470 
        }
471 
                    /**
472 
         * Load and boot all of the remaining deferred providers.
473 
         *
474 
         * @return void
475 
         * @static
476 
         */
477 
        public static function loadDeferredProviders()
478 
        {
479 
                        /** @var \Illuminate\Foundation\Application $instance */
480 
                        $instance->loadDeferredProviders();
481 
        }
482 
                    /**
483 
         * Load the provider for a deferred service.
484 
         *
485 
         * @param string $service
486 
         * @return void
487 
         * @static
488 
         */
489 
        public static function loadDeferredProvider($service)
490 
        {
491 
                        /** @var \Illuminate\Foundation\Application $instance */
492 
                        $instance->loadDeferredProvider($service);
493 
        }
494 
                    /**
495 
         * Register a deferred provider and service.
496 
         *
497 
         * @param string $provider
498 
         * @param string|null $service
499 
         * @return void
500 
         * @static
501 
         */
502 
        public static function registerDeferredProvider($provider, $service = null)
503 
        {
504 
                        /** @var \Illuminate\Foundation\Application $instance */
505 
                        $instance->registerDeferredProvider($provider, $service);
506 
        }
507 
                    /**
508 
         * Resolve the given type from the container.
509 
         *
510 
         * @param string $abstract
511 
         * @param array $parameters
512 
         * @return mixed
513 
         * @static
514 
         */
515 
        public static function make($abstract, $parameters = [])
516 
        {
517 
                        /** @var \Illuminate\Foundation\Application $instance */
518 
                        return $instance->make($abstract, $parameters);
519 
        }
520 
                    /**
521 
         * Determine if the given abstract type has been bound.
522 
         *
523 
         * @param string $abstract
524 
         * @return bool
525 
         * @static
526 
         */
527 
        public static function bound($abstract)
528 
        {
529 
                        /** @var \Illuminate\Foundation\Application $instance */
530 
                        return $instance->bound($abstract);
531 
        }
532 
                    /**
533 
         * Determine if the application has booted.
534 
         *
535 
         * @return bool
536 
         * @static
537 
         */
538 
        public static function isBooted()
539 
        {
540 
                        /** @var \Illuminate\Foundation\Application $instance */
541 
                        return $instance->isBooted();
542 
        }
543 
                    /**
544 
         * Boot the application's service providers.
545 
         *
546 
         * @return void
547 
         * @static
548 
         */
549 
        public static function boot()
550 
        {
551 
                        /** @var \Illuminate\Foundation\Application $instance */
552 
                        $instance->boot();
553 
        }
554 
                    /**
555 
         * Register a new boot listener.
556 
         *
557 
         * @param callable $callback
558 
         * @return void
559 
         * @static
560 
         */
561 
        public static function booting($callback)
562 
        {
563 
                        /** @var \Illuminate\Foundation\Application $instance */
564 
                        $instance->booting($callback);
565 
        }
566 
                    /**
567 
         * Register a new "booted" listener.
568 
         *
569 
         * @param callable $callback
570 
         * @return void
571 
         * @static
572 
         */
573 
        public static function booted($callback)
574 
        {
575 
                        /** @var \Illuminate\Foundation\Application $instance */
576 
                        $instance->booted($callback);
577 
        }
578 
                    /**
579 
         * {@inheritdoc}
580 
         *
581 
         * @return \Symfony\Component\HttpFoundation\Response
582 
         * @static
583 
         */
584 
        public static function handle($request, $type = 1, $catch = true)
585 
        {
586 
                        /** @var \Illuminate\Foundation\Application $instance */
587 
                        return $instance->handle($request, $type, $catch);
588 
        }
589 
                    /**
590 
         * Determine if middleware has been disabled for the application.
591 
         *
592 
         * @return bool
593 
         * @static
594 
         */
595 
        public static function shouldSkipMiddleware()
596 
        {
597 
                        /** @var \Illuminate\Foundation\Application $instance */
598 
                        return $instance->shouldSkipMiddleware();
599 
        }
600 
                    /**
601 
         * Get the path to the cached services.php file.
602 
         *
603 
         * @return string
604 
         * @static
605 
         */
606 
        public static function getCachedServicesPath()
607 
        {
608 
                        /** @var \Illuminate\Foundation\Application $instance */
609 
                        return $instance->getCachedServicesPath();
610 
        }
611 
                    /**
612 
         * Get the path to the cached packages.php file.
613 
         *
614 
         * @return string
615 
         * @static
616 
         */
617 
        public static function getCachedPackagesPath()
618 
        {
619 
                        /** @var \Illuminate\Foundation\Application $instance */
620 
                        return $instance->getCachedPackagesPath();
621 
        }
622 
                    /**
623 
         * Determine if the application configuration is cached.
624 
         *
625 
         * @return bool
626 
         * @static
627 
         */
628 
        public static function configurationIsCached()
629 
        {
630 
                        /** @var \Illuminate\Foundation\Application $instance */
631 
                        return $instance->configurationIsCached();
632 
        }
633 
                    /**
634 
         * Get the path to the configuration cache file.
635 
         *
636 
         * @return string
637 
         * @static
638 
         */
639 
        public static function getCachedConfigPath()
640 
        {
641 
                        /** @var \Illuminate\Foundation\Application $instance */
642 
                        return $instance->getCachedConfigPath();
643 
        }
644 
                    /**
645 
         * Determine if the application routes are cached.
646 
         *
647 
         * @return bool
648 
         * @static
649 
         */
650 
        public static function routesAreCached()
651 
        {
652 
                        /** @var \Illuminate\Foundation\Application $instance */
653 
                        return $instance->routesAreCached();
654 
        }
655 
                    /**
656 
         * Get the path to the routes cache file.
657 
         *
658 
         * @return string
659 
         * @static
660 
         */
661 
        public static function getCachedRoutesPath()
662 
        {
663 
                        /** @var \Illuminate\Foundation\Application $instance */
664 
                        return $instance->getCachedRoutesPath();
665 
        }
666 
                    /**
667 
         * Determine if the application events are cached.
668 
         *
669 
         * @return bool
670 
         * @static
671 
         */
672 
        public static function eventsAreCached()
673 
        {
674 
                        /** @var \Illuminate\Foundation\Application $instance */
675 
                        return $instance->eventsAreCached();
676 
        }
677 
                    /**
678 
         * Get the path to the events cache file.
679 
         *
680 
         * @return string
681 
         * @static
682 
         */
683 
        public static function getCachedEventsPath()
684 
        {
685 
                        /** @var \Illuminate\Foundation\Application $instance */
686 
                        return $instance->getCachedEventsPath();
687 
        }
688 
                    /**
689 
         * Add new prefix to list of absolute path prefixes.
690 
         *
691 
         * @param string $prefix
692 
         * @return \Illuminate\Foundation\Application
693 
         * @static
694 
         */
695 
        public static function addAbsoluteCachePathPrefix($prefix)
696 
        {
697 
                        /** @var \Illuminate\Foundation\Application $instance */
698 
                        return $instance->addAbsoluteCachePathPrefix($prefix);
699 
        }
700 
                    /**
701 
         * Get an instance of the maintenance mode manager implementation.
702 
         *
703 
         * @return \Illuminate\Contracts\Foundation\MaintenanceMode
704 
         * @static
705 
         */
706 
        public static function maintenanceMode()
707 
        {
708 
                        /** @var \Illuminate\Foundation\Application $instance */
709 
                        return $instance->maintenanceMode();
710 
        }
711 
                    /**
712 
         * Determine if the application is currently down for maintenance.
713 
         *
714 
         * @return bool
715 
         * @static
716 
         */
717 
        public static function isDownForMaintenance()
718 
        {
719 
                        /** @var \Illuminate\Foundation\Application $instance */
720 
                        return $instance->isDownForMaintenance();
721 
        }
722 
                    /**
723 
         * Throw an HttpException with the given data.
724 
         *
725 
         * @param int $code
726 
         * @param string $message
727 
         * @param array $headers
728 
         * @return \Illuminate\Foundation\never
729 
         * @throws \Symfony\Component\HttpKernel\Exception\HttpException
730 
         * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
731 
         * @static
732 
         */
733 
        public static function abort($code, $message = '', $headers = [])
734 
        {
735 
                        /** @var \Illuminate\Foundation\Application $instance */
736 
                        return $instance->abort($code, $message, $headers);
737 
        }
738 
                    /**
739 
         * Register a terminating callback with the application.
740 
         *
741 
         * @param callable|string $callback
742 
         * @return \Illuminate\Foundation\Application
743 
         * @static
744 
         */
745 
        public static function terminating($callback)
746 
        {
747 
                        /** @var \Illuminate\Foundation\Application $instance */
748 
                        return $instance->terminating($callback);
749 
        }
750 
                    /**
751 
         * Terminate the application.
752 
         *
753 
         * @return void
754 
         * @static
755 
         */
756 
        public static function terminate()
757 
        {
758 
                        /** @var \Illuminate\Foundation\Application $instance */
759 
                        $instance->terminate();
760 
        }
761 
                    /**
762 
         * Get the service providers that have been loaded.
763 
         *
764 
         * @return array
765 
         * @static
766 
         */
767 
        public static function getLoadedProviders()
768 
        {
769 
                        /** @var \Illuminate\Foundation\Application $instance */
770 
                        return $instance->getLoadedProviders();
771 
        }
772 
                    /**
773 
         * Determine if the given service provider is loaded.
774 
         *
775 
         * @param string $provider
776 
         * @return bool
777 
         * @static
778 
         */
779 
        public static function providerIsLoaded($provider)
780 
        {
781 
                        /** @var \Illuminate\Foundation\Application $instance */
782 
                        return $instance->providerIsLoaded($provider);
783 
        }
784 
                    /**
785 
         * Get the application's deferred services.
786 
         *
787 
         * @return array
788 
         * @static
789 
         */
790 
        public static function getDeferredServices()
791 
        {
792 
                        /** @var \Illuminate\Foundation\Application $instance */
793 
                        return $instance->getDeferredServices();
794 
        }
795 
                    /**
796 
         * Set the application's deferred services.
797 
         *
798 
         * @param array $services
799 
         * @return void
800 
         * @static
801 
         */
802 
        public static function setDeferredServices($services)
803 
        {
804 
                        /** @var \Illuminate\Foundation\Application $instance */
805 
                        $instance->setDeferredServices($services);
806 
        }
807 
                    /**
808 
         * Add an array of services to the application's deferred services.
809 
         *
810 
         * @param array $services
811 
         * @return void
812 
         * @static
813 
         */
814 
        public static function addDeferredServices($services)
815 
        {
816 
                        /** @var \Illuminate\Foundation\Application $instance */
817 
                        $instance->addDeferredServices($services);
818 
        }
819 
                    /**
820 
         * Determine if the given service is a deferred service.
821 
         *
822 
         * @param string $service
823 
         * @return bool
824 
         * @static
825 
         */
826 
        public static function isDeferredService($service)
827 
        {
828 
                        /** @var \Illuminate\Foundation\Application $instance */
829 
                        return $instance->isDeferredService($service);
830 
        }
831 
                    /**
832 
         * Configure the real-time facade namespace.
833 
         *
834 
         * @param string $namespace
835 
         * @return void
836 
         * @static
837 
         */
838 
        public static function provideFacades($namespace)
839 
        {
840 
                        /** @var \Illuminate\Foundation\Application $instance */
841 
                        $instance->provideFacades($namespace);
842 
        }
843 
                    /**
844 
         * Get the current application locale.
845 
         *
846 
         * @return string
847 
         * @static
848 
         */
849 
        public static function getLocale()
850 
        {
851 
                        /** @var \Illuminate\Foundation\Application $instance */
852 
                        return $instance->getLocale();
853 
        }
854 
                    /**
855 
         * Get the current application locale.
856 
         *
857 
         * @return string
858 
         * @static
859 
         */
860 
        public static function currentLocale()
861 
        {
862 
                        /** @var \Illuminate\Foundation\Application $instance */
863 
                        return $instance->currentLocale();
864 
        }
865 
                    /**
866 
         * Get the current application fallback locale.
867 
         *
868 
         * @return string
869 
         * @static
870 
         */
871 
        public static function getFallbackLocale()
872 
        {
873 
                        /** @var \Illuminate\Foundation\Application $instance */
874 
                        return $instance->getFallbackLocale();
875 
        }
876 
                    /**
877 
         * Set the current application locale.
878 
         *
879 
         * @param string $locale
880 
         * @return void
881 
         * @static
882 
         */
883 
        public static function setLocale($locale)
884 
        {
885 
                        /** @var \Illuminate\Foundation\Application $instance */
886 
                        $instance->setLocale($locale);
887 
        }
888 
                    /**
889 
         * Set the current application fallback locale.
890 
         *
891 
         * @param string $fallbackLocale
892 
         * @return void
893 
         * @static
894 
         */
895 
        public static function setFallbackLocale($fallbackLocale)
896 
        {
897 
                        /** @var \Illuminate\Foundation\Application $instance */
898 
                        $instance->setFallbackLocale($fallbackLocale);
899 
        }
900 
                    /**
901 
         * Determine if the application locale is the given locale.
902 
         *
903 
         * @param string $locale
904 
         * @return bool
905 
         * @static
906 
         */
907 
        public static function isLocale($locale)
908 
        {
909 
                        /** @var \Illuminate\Foundation\Application $instance */
910 
                        return $instance->isLocale($locale);
911 
        }
912 
                    /**
913 
         * Register the core class aliases in the container.
914 
         *
915 
         * @return void
916 
         * @static
917 
         */
918 
        public static function registerCoreContainerAliases()
919 
        {
920 
                        /** @var \Illuminate\Foundation\Application $instance */
921 
                        $instance->registerCoreContainerAliases();
922 
        }
923 
                    /**
924 
         * Flush the container of all bindings and resolved instances.
925 
         *
926 
         * @return void
927 
         * @static
928 
         */
929 
        public static function flush()
930 
        {
931 
                        /** @var \Illuminate\Foundation\Application $instance */
932 
                        $instance->flush();
933 
        }
934 
                    /**
935 
         * Get the application namespace.
936 
         *
937 
         * @return string
938 
         * @throws \RuntimeException
939 
         * @static
940 
         */
941 
        public static function getNamespace()
942 
        {
943 
                        /** @var \Illuminate\Foundation\Application $instance */
944 
                        return $instance->getNamespace();
945 
        }
946 
                    /**
947 
         * Define a contextual binding.
948 
         *
949 
         * @param array|string $concrete
950 
         * @return \Illuminate\Contracts\Container\ContextualBindingBuilder
951 
         * @static
952 
         */
953 
        public static function when($concrete)
954 
        {            //Method inherited from \Illuminate\Container\Container
955 
                        /** @var \Illuminate\Foundation\Application $instance */
956 
                        return $instance->when($concrete);
957 
        }
958 
                    /**
959 
         * Returns true if the container can return an entry for the given identifier.
960 
         *
961 
         * Returns false otherwise.
962 
         *
963 
         * `has($id)` returning true does not mean that `get($id)` will not throw an exception.
964 
         * It does however mean that `get($id)` will not throw a `NotFoundExceptionInterface`.
965 
         *
966 
         * @return bool
967 
         * @param string $id Identifier of the entry to look for.
968 
         * @return bool
969 
         * @static
970 
         */
971 
        public static function has($id)
972 
        {            //Method inherited from \Illuminate\Container\Container
973 
                        /** @var \Illuminate\Foundation\Application $instance */
974 
                        return $instance->has($id);
975 
        }
976 
                    /**
977 
         * Determine if the given abstract type has been resolved.
978 
         *
979 
         * @param string $abstract
980 
         * @return bool
981 
         * @static
982 
         */
983 
        public static function resolved($abstract)
984 
        {            //Method inherited from \Illuminate\Container\Container
985 
                        /** @var \Illuminate\Foundation\Application $instance */
986 
                        return $instance->resolved($abstract);
987 
        }
988 
                    /**
989 
         * Determine if a given type is shared.
990 
         *
991 
         * @param string $abstract
992 
         * @return bool
993 
         * @static
994 
         */
995 
        public static function isShared($abstract)
996 
        {            //Method inherited from \Illuminate\Container\Container
997 
                        /** @var \Illuminate\Foundation\Application $instance */
998 
                        return $instance->isShared($abstract);
999 
        }
1000 
                    /**
1001 
         * Determine if a given string is an alias.
1002 
         *
1003 
         * @param string $name
1004 
         * @return bool
1005 
         * @static
1006 
         */
1007 
        public static function isAlias($name)
1008 
        {            //Method inherited from \Illuminate\Container\Container
1009 
                        /** @var \Illuminate\Foundation\Application $instance */
1010 
                        return $instance->isAlias($name);
1011 
        }
1012 
                    /**
1013 
         * Register a binding with the container.
1014 
         *
1015 
         * @param string $abstract
1016 
         * @param \Closure|string|null $concrete
1017 
         * @param bool $shared
1018 
         * @return void
1019 
         * @throws \TypeError
1020 
         * @static
1021 
         */
1022 
        public static function bind($abstract, $concrete = null, $shared = false)
1023 
        {            //Method inherited from \Illuminate\Container\Container
1024 
                        /** @var \Illuminate\Foundation\Application $instance */
1025 
                        $instance->bind($abstract, $concrete, $shared);
1026 
        }
1027 
                    /**
1028 
         * Determine if the container has a method binding.
1029 
         *
1030 
         * @param string $method
1031 
         * @return bool
1032 
         * @static
1033 
         */
1034 
        public static function hasMethodBinding($method)
1035 
        {            //Method inherited from \Illuminate\Container\Container
1036 
                        /** @var \Illuminate\Foundation\Application $instance */
1037 
                        return $instance->hasMethodBinding($method);
1038 
        }
1039 
                    /**
1040 
         * Bind a callback to resolve with Container::call.
1041 
         *
1042 
         * @param array|string $method
1043 
         * @param \Closure $callback
1044 
         * @return void
1045 
         * @static
1046 
         */
1047 
        public static function bindMethod($method, $callback)
1048 
        {            //Method inherited from \Illuminate\Container\Container
1049 
                        /** @var \Illuminate\Foundation\Application $instance */
1050 
                        $instance->bindMethod($method, $callback);
1051 
        }
1052 
                    /**
1053 
         * Get the method binding for the given method.
1054 
         *
1055 
         * @param string $method
1056 
         * @param mixed $instance
1057 
         * @return mixed
1058 
         * @static
1059 
         */
1060 
        public static function callMethodBinding($method, $instance)
1061 
        {            //Method inherited from \Illuminate\Container\Container
1062 
                        /** @var \Illuminate\Foundation\Application $instance */
1063 
                        return $instance->callMethodBinding($method, $instance);
1064 
        }
1065 
                    /**
1066 
         * Add a contextual binding to the container.
1067 
         *
1068 
         * @param string $concrete
1069 
         * @param string $abstract
1070 
         * @param \Closure|string $implementation
1071 
         * @return void
1072 
         * @static
1073 
         */
1074 
        public static function addContextualBinding($concrete, $abstract, $implementation)
1075 
        {            //Method inherited from \Illuminate\Container\Container
1076 
                        /** @var \Illuminate\Foundation\Application $instance */
1077 
                        $instance->addContextualBinding($concrete, $abstract, $implementation);
1078 
        }
1079 
                    /**
1080 
         * Register a binding if it hasn't already been registered.
1081 
         *
1082 
         * @param string $abstract
1083 
         * @param \Closure|string|null $concrete
1084 
         * @param bool $shared
1085 
         * @return void
1086 
         * @static
1087 
         */
1088 
        public static function bindIf($abstract, $concrete = null, $shared = false)
1089 
        {            //Method inherited from \Illuminate\Container\Container
1090 
                        /** @var \Illuminate\Foundation\Application $instance */
1091 
                        $instance->bindIf($abstract, $concrete, $shared);
1092 
        }
1093 
                    /**
1094 
         * Register a shared binding in the container.
1095 
         *
1096 
         * @param string $abstract
1097 
         * @param \Closure|string|null $concrete
1098 
         * @return void
1099 
         * @static
1100 
         */
1101 
        public static function singleton($abstract, $concrete = null)
1102 
        {            //Method inherited from \Illuminate\Container\Container
1103 
                        /** @var \Illuminate\Foundation\Application $instance */
1104 
                        $instance->singleton($abstract, $concrete);
1105 
        }
1106 
                    /**
1107 
         * Register a shared binding if it hasn't already been registered.
1108 
         *
1109 
         * @param string $abstract
1110 
         * @param \Closure|string|null $concrete
1111 
         * @return void
1112 
         * @static
1113 
         */
1114 
        public static function singletonIf($abstract, $concrete = null)
1115 
        {            //Method inherited from \Illuminate\Container\Container
1116 
                        /** @var \Illuminate\Foundation\Application $instance */
1117 
                        $instance->singletonIf($abstract, $concrete);
1118 
        }
1119 
                    /**
1120 
         * Register a scoped binding in the container.
1121 
         *
1122 
         * @param string $abstract
1123 
         * @param \Closure|string|null $concrete
1124 
         * @return void
1125 
         * @static
1126 
         */
1127 
        public static function scoped($abstract, $concrete = null)
1128 
        {            //Method inherited from \Illuminate\Container\Container
1129 
                        /** @var \Illuminate\Foundation\Application $instance */
1130 
                        $instance->scoped($abstract, $concrete);
1131 
        }
1132 
                    /**
1133 
         * Register a scoped binding if it hasn't already been registered.
1134 
         *
1135 
         * @param string $abstract
1136 
         * @param \Closure|string|null $concrete
1137 
         * @return void
1138 
         * @static
1139 
         */
1140 
        public static function scopedIf($abstract, $concrete = null)
1141 
        {            //Method inherited from \Illuminate\Container\Container
1142 
                        /** @var \Illuminate\Foundation\Application $instance */
1143 
                        $instance->scopedIf($abstract, $concrete);
1144 
        }
1145 
                    /**
1146 
         * "Extend" an abstract type in the container.
1147 
         *
1148 
         * @param string $abstract
1149 
         * @param \Closure $closure
1150 
         * @return void
1151 
         * @throws \InvalidArgumentException
1152 
         * @static
1153 
         */
1154 
        public static function extend($abstract, $closure)
1155 
        {            //Method inherited from \Illuminate\Container\Container
1156 
                        /** @var \Illuminate\Foundation\Application $instance */
1157 
                        $instance->extend($abstract, $closure);
1158 
        }
1159 
                    /**
1160 
         * Register an existing instance as shared in the container.
1161 
         *
1162 
         * @param string $abstract
1163 
         * @param mixed $instance
1164 
         * @return mixed
1165 
         * @static
1166 
         */
1167 
        public static function instance($abstract, $instance)
1168 
        {            //Method inherited from \Illuminate\Container\Container
1169 
                        /** @var \Illuminate\Foundation\Application $instance */
1170 
                        return $instance->instance($abstract, $instance);
1171 
        }
1172 
                    /**
1173 
         * Assign a set of tags to a given binding.
1174 
         *
1175 
         * @param array|string $abstracts
1176 
         * @param array|mixed $tags
1177 
         * @return void
1178 
         * @static
1179 
         */
1180 
        public static function tag($abstracts, $tags)
1181 
        {            //Method inherited from \Illuminate\Container\Container
1182 
                        /** @var \Illuminate\Foundation\Application $instance */
1183 
                        $instance->tag($abstracts, $tags);
1184 
        }
1185 
                    /**
1186 
         * Resolve all of the bindings for a given tag.
1187 
         *
1188 
         * @param string $tag
1189 
         * @return \Illuminate\Container\iterable
1190 
         * @static
1191 
         */
1192 
        public static function tagged($tag)
1193 
        {            //Method inherited from \Illuminate\Container\Container
1194 
                        /** @var \Illuminate\Foundation\Application $instance */
1195 
                        return $instance->tagged($tag);
1196 
        }
1197 
                    /**
1198 
         * Alias a type to a different name.
1199 
         *
1200 
         * @param string $abstract
1201 
         * @param string $alias
1202 
         * @return void
1203 
         * @throws \LogicException
1204 
         * @static
1205 
         */
1206 
        public static function alias($abstract, $alias)
1207 
        {            //Method inherited from \Illuminate\Container\Container
1208 
                        /** @var \Illuminate\Foundation\Application $instance */
1209 
                        $instance->alias($abstract, $alias);
1210 
        }
1211 
                    /**
1212 
         * Bind a new callback to an abstract's rebind event.
1213 
         *
1214 
         * @param string $abstract
1215 
         * @param \Closure $callback
1216 
         * @return mixed
1217 
         * @static
1218 
         */
1219 
        public static function rebinding($abstract, $callback)
1220 
        {            //Method inherited from \Illuminate\Container\Container
1221 
                        /** @var \Illuminate\Foundation\Application $instance */
1222 
                        return $instance->rebinding($abstract, $callback);
1223 
        }
1224 
                    /**
1225 
         * Refresh an instance on the given target and method.
1226 
         *
1227 
         * @param string $abstract
1228 
         * @param mixed $target
1229 
         * @param string $method
1230 
         * @return mixed
1231 
         * @static
1232 
         */
1233 
        public static function refresh($abstract, $target, $method)
1234 
        {            //Method inherited from \Illuminate\Container\Container
1235 
                        /** @var \Illuminate\Foundation\Application $instance */
1236 
                        return $instance->refresh($abstract, $target, $method);
1237 
        }
1238 
                    /**
1239 
         * Wrap the given closure such that its dependencies will be injected when executed.
1240 
         *
1241 
         * @param \Closure $callback
1242 
         * @param array $parameters
1243 
         * @return \Closure
1244 
         * @static
1245 
         */
1246 
        public static function wrap($callback, $parameters = [])
1247 
        {            //Method inherited from \Illuminate\Container\Container
1248 
                        /** @var \Illuminate\Foundation\Application $instance */
1249 
                        return $instance->wrap($callback, $parameters);
1250 
        }
1251 
                    /**
1252 
         * Call the given Closure / class@method and inject its dependencies.
1253 
         *
1254 
         * @param callable|string $callback
1255 
         * @param \Illuminate\Container\array<string,  mixed>  $parameters
1256 
         * @param string|null $defaultMethod
1257 
         * @return mixed
1258 
         * @throws \InvalidArgumentException
1259 
         * @static
1260 
         */
1261 
        public static function call($callback, $parameters = [], $defaultMethod = null)
1262 
        {            //Method inherited from \Illuminate\Container\Container
1263 
                        /** @var \Illuminate\Foundation\Application $instance */
1264 
                        return $instance->call($callback, $parameters, $defaultMethod);
1265 
        }
1266 
                    /**
1267 
         * Get a closure to resolve the given type from the container.
1268 
         *
1269 
         * @param string $abstract
1270 
         * @return \Closure
1271 
         * @static
1272 
         */
1273 
        public static function factory($abstract)
1274 
        {            //Method inherited from \Illuminate\Container\Container
1275 
                        /** @var \Illuminate\Foundation\Application $instance */
1276 
                        return $instance->factory($abstract);
1277 
        }
1278 
                    /**
1279 
         * An alias function name for make().
1280 
         *
1281 
         * @param string|callable $abstract
1282 
         * @param array $parameters
1283 
         * @return mixed
1284 
         * @throws \Illuminate\Contracts\Container\BindingResolutionException
1285 
         * @static
1286 
         */
1287 
        public static function makeWith($abstract, $parameters = [])
1288 
        {            //Method inherited from \Illuminate\Container\Container
1289 
                        /** @var \Illuminate\Foundation\Application $instance */
1290 
                        return $instance->makeWith($abstract, $parameters);
1291 
        }
1292 
                    /**
1293 
         * Finds an entry of the container by its identifier and returns it.
1294 
         *
1295 
         * @return mixed
1296 
         * @param string $id Identifier of the entry to look for.
1297 
         * @throws NotFoundExceptionInterface  No entry was found for **this** identifier.
1298 
         * @throws ContainerExceptionInterface Error while retrieving the entry.
1299 
         * @return mixed Entry.
1300 
         * @static
1301 
         */
1302 
        public static function get($id)
1303 
        {            //Method inherited from \Illuminate\Container\Container
1304 
                        /** @var \Illuminate\Foundation\Application $instance */
1305 
                        return $instance->get($id);
1306 
        }
1307 
                    /**
1308 
         * Instantiate a concrete instance of the given type.
1309 
         *
1310 
         * @param \Closure|string $concrete
1311 
         * @return mixed
1312 
         * @throws \Illuminate\Contracts\Container\BindingResolutionException
1313 
         * @throws \Illuminate\Contracts\Container\CircularDependencyException
1314 
         * @static
1315 
         */
1316 
        public static function build($concrete)
1317 
        {            //Method inherited from \Illuminate\Container\Container
1318 
                        /** @var \Illuminate\Foundation\Application $instance */
1319 
                        return $instance->build($concrete);
1320 
        }
1321 
                    /**
1322 
         * Register a new before resolving callback for all types.
1323 
         *
1324 
         * @param \Closure|string $abstract
1325 
         * @param \Closure|null $callback
1326 
         * @return void
1327 
         * @static
1328 
         */
1329 
        public static function beforeResolving($abstract, $callback = null)
1330 
        {            //Method inherited from \Illuminate\Container\Container
1331 
                        /** @var \Illuminate\Foundation\Application $instance */
1332 
                        $instance->beforeResolving($abstract, $callback);
1333 
        }
1334 
                    /**
1335 
         * Register a new resolving callback.
1336 
         *
1337 
         * @param \Closure|string $abstract
1338 
         * @param \Closure|null $callback
1339 
         * @return void
1340 
         * @static
1341 
         */
1342 
        public static function resolving($abstract, $callback = null)
1343 
        {            //Method inherited from \Illuminate\Container\Container
1344 
                        /** @var \Illuminate\Foundation\Application $instance */
1345 
                        $instance->resolving($abstract, $callback);
1346 
        }
1347 
                    /**
1348 
         * Register a new after resolving callback for all types.
1349 
         *
1350 
         * @param \Closure|string $abstract
1351 
         * @param \Closure|null $callback
1352 
         * @return void
1353 
         * @static
1354 
         */
1355 
        public static function afterResolving($abstract, $callback = null)
1356 
        {            //Method inherited from \Illuminate\Container\Container
1357 
                        /** @var \Illuminate\Foundation\Application $instance */
1358 
                        $instance->afterResolving($abstract, $callback);
1359 
        }
1360 
                    /**
1361 
         * Get the container's bindings.
1362 
         *
1363 
         * @return array
1364 
         * @static
1365 
         */
1366 
        public static function getBindings()
1367 
        {            //Method inherited from \Illuminate\Container\Container
1368 
                        /** @var \Illuminate\Foundation\Application $instance */
1369 
                        return $instance->getBindings();
1370 
        }
1371 
                    /**
1372 
         * Get the alias for an abstract if available.
1373 
         *
1374 
         * @param string $abstract
1375 
         * @return string
1376 
         * @static
1377 
         */
1378 
        public static function getAlias($abstract)
1379 
        {            //Method inherited from \Illuminate\Container\Container
1380 
                        /** @var \Illuminate\Foundation\Application $instance */
1381 
                        return $instance->getAlias($abstract);
1382 
        }
1383 
                    /**
1384 
         * Remove all of the extender callbacks for a given type.
1385 
         *
1386 
         * @param string $abstract
1387 
         * @return void
1388 
         * @static
1389 
         */
1390 
        public static function forgetExtenders($abstract)
1391 
        {            //Method inherited from \Illuminate\Container\Container
1392 
                        /** @var \Illuminate\Foundation\Application $instance */
1393 
                        $instance->forgetExtenders($abstract);
1394 
        }
1395 
                    /**
1396 
         * Remove a resolved instance from the instance cache.
1397 
         *
1398 
         * @param string $abstract
1399 
         * @return void
1400 
         * @static
1401 
         */
1402 
        public static function forgetInstance($abstract)
1403 
        {            //Method inherited from \Illuminate\Container\Container
1404 
                        /** @var \Illuminate\Foundation\Application $instance */
1405 
                        $instance->forgetInstance($abstract);
1406 
        }
1407 
                    /**
1408 
         * Clear all of the instances from the container.
1409 
         *
1410 
         * @return void
1411 
         * @static
1412 
         */
1413 
        public static function forgetInstances()
1414 
        {            //Method inherited from \Illuminate\Container\Container
1415 
                        /** @var \Illuminate\Foundation\Application $instance */
1416 
                        $instance->forgetInstances();
1417 
        }
1418 
                    /**
1419 
         * Clear all of the scoped instances from the container.
1420 
         *
1421 
         * @return void
1422 
         * @static
1423 
         */
1424 
        public static function forgetScopedInstances()
1425 
        {            //Method inherited from \Illuminate\Container\Container
1426 
                        /** @var \Illuminate\Foundation\Application $instance */
1427 
                        $instance->forgetScopedInstances();
1428 
        }
1429 
                    /**
1430 
         * Get the globally available instance of the container.
1431 
         *
1432 
         * @return static
1433 
         * @static
1434 
         */
1435 
        public static function getInstance()
1436 
        {            //Method inherited from \Illuminate\Container\Container
1437 
                        return \Illuminate\Foundation\Application::getInstance();
1438 
        }
1439 
                    /**
1440 
         * Set the shared instance of the container.
1441 
         *
1442 
         * @param \Illuminate\Contracts\Container\Container|null $container
1443 
         * @return \Illuminate\Contracts\Container\Container|static
1444 
         * @static
1445 
         */
1446 
        public static function setInstance($container = null)
1447 
        {            //Method inherited from \Illuminate\Container\Container
1448 
                        return \Illuminate\Foundation\Application::setInstance($container);
1449 
        }
1450 
                    /**
1451 
         * Determine if a given offset exists.
1452 
         *
1453 
         * @param string $key
1454 
         * @return bool
1455 
         * @static
1456 
         */
1457 
        public static function offsetExists($key)
1458 
        {            //Method inherited from \Illuminate\Container\Container
1459 
                        /** @var \Illuminate\Foundation\Application $instance */
1460 
                        return $instance->offsetExists($key);
1461 
        }
1462 
                    /**
1463 
         * Get the value at a given offset.
1464 
         *
1465 
         * @param string $key
1466 
         * @return mixed
1467 
         * @static
1468 
         */
1469 
        public static function offsetGet($key)
1470 
        {            //Method inherited from \Illuminate\Container\Container
1471 
                        /** @var \Illuminate\Foundation\Application $instance */
1472 
                        return $instance->offsetGet($key);
1473 
        }
1474 
                    /**
1475 
         * Set the value at a given offset.
1476 
         *
1477 
         * @param string $key
1478 
         * @param mixed $value
1479 
         * @return void
1480 
         * @static
1481 
         */
1482 
        public static function offsetSet($key, $value)
1483 
        {            //Method inherited from \Illuminate\Container\Container
1484 
                        /** @var \Illuminate\Foundation\Application $instance */
1485 
                        $instance->offsetSet($key, $value);
1486 
        }
1487 
                    /**
1488 
         * Unset the value at a given offset.
1489 
         *
1490 
         * @param string $key
1491 
         * @return void
1492 
         * @static
1493 
         */
1494 
        public static function offsetUnset($key)
1495 
        {            //Method inherited from \Illuminate\Container\Container
1496 
                        /** @var \Illuminate\Foundation\Application $instance */
1497 
                        $instance->offsetUnset($key);
1498 
        }
1499 
                    /**
1500 
         * Register a custom macro.
1501 
         *
1502 
         * @param string $name
1503 
         * @param object|callable $macro
1504 
         * @return void
1505 
         * @static
1506 
         */
1507 
        public static function macro($name, $macro)
1508 
        {
1509 
                        \Illuminate\Foundation\Application::macro($name, $macro);
1510 
        }
1511 
                    /**
1512 
         * Mix another object into the class.
1513 
         *
1514 
         * @param object $mixin
1515 
         * @param bool $replace
1516 
         * @return void
1517 
         * @throws \ReflectionException
1518 
         * @static
1519 
         */
1520 
        public static function mixin($mixin, $replace = true)
1521 
        {
1522 
                        \Illuminate\Foundation\Application::mixin($mixin, $replace);
1523 
        }
1524 
                    /**
1525 
         * Checks if macro is registered.
1526 
         *
1527 
         * @param string $name
1528 
         * @return bool
1529 
         * @static
1530 
         */
1531 
        public static function hasMacro($name)
1532 
        {
1533 
                        return \Illuminate\Foundation\Application::hasMacro($name);
1534 
        }
1535 
                    /**
1536 
         * Flush the existing macros.
1537 
         *
1538 
         * @return void
1539 
         * @static
1540 
         */
1541 
        public static function flushMacros()
1542 
        {
1543 
                        \Illuminate\Foundation\Application::flushMacros();
1544 
        }
1545 
 
1546 
    }
1547 
            /**
1548 
     *
1549 
     *
1550 
     * @see \Illuminate\Foundation\Console\Kernel
1551 
     */
1552 
        class Artisan {
1553 
                    /**
1554 
         * Run the console application.
1555 
         *
1556 
         * @param \Symfony\Component\Console\Input\InputInterface $input
1557 
         * @param \Symfony\Component\Console\Output\OutputInterface|null $output
1558 
         * @return int
1559 
         * @static
1560 
         */
1561 
        public static function handle($input, $output = null)
1562 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1563 
                        /** @var \App\Console\Kernel $instance */
1564 
                        return $instance->handle($input, $output);
1565 
        }
1566 
                    /**
1567 
         * Terminate the application.
1568 
         *
1569 
         * @param \Symfony\Component\Console\Input\InputInterface $input
1570 
         * @param int $status
1571 
         * @return void
1572 
         * @static
1573 
         */
1574 
        public static function terminate($input, $status)
1575 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1576 
                        /** @var \App\Console\Kernel $instance */
1577 
                        $instance->terminate($input, $status);
1578 
        }
1579 
                    /**
1580 
         * Register a callback to be invoked when the command lifecycle duration exceeds a given amount of time.
1581 
         *
1582 
         * @param \DateTimeInterface|\Carbon\CarbonInterval|float|int $threshold
1583 
         * @param callable $handler
1584 
         * @return void
1585 
         * @static
1586 
         */
1587 
        public static function whenCommandLifecycleIsLongerThan($threshold, $handler)
1588 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1589 
                        /** @var \App\Console\Kernel $instance */
1590 
                        $instance->whenCommandLifecycleIsLongerThan($threshold, $handler);
1591 
        }
1592 
                    /**
1593 
         * When the command being handled started.
1594 
         *
1595 
         * @return \Illuminate\Support\Carbon|null
1596 
         * @static
1597 
         */
1598 
        public static function commandStartedAt()
1599 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1600 
                        /** @var \App\Console\Kernel $instance */
1601 
                        return $instance->commandStartedAt();
1602 
        }
1603 
                    /**
1604 
         * Register a Closure based command with the application.
1605 
         *
1606 
         * @param string $signature
1607 
         * @param \Closure $callback
1608 
         * @return \Illuminate\Foundation\Console\ClosureCommand
1609 
         * @static
1610 
         */
1611 
        public static function command($signature, $callback)
1612 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1613 
                        /** @var \App\Console\Kernel $instance */
1614 
                        return $instance->command($signature, $callback);
1615 
        }
1616 
                    /**
1617 
         * Register the given command with the console application.
1618 
         *
1619 
         * @param \Symfony\Component\Console\Command\Command $command
1620 
         * @return void
1621 
         * @static
1622 
         */
1623 
        public static function registerCommand($command)
1624 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1625 
                        /** @var \App\Console\Kernel $instance */
1626 
                        $instance->registerCommand($command);
1627 
        }
1628 
                    /**
1629 
         * Run an Artisan console command by name.
1630 
         *
1631 
         * @param string $command
1632 
         * @param array $parameters
1633 
         * @param \Symfony\Component\Console\Output\OutputInterface|null $outputBuffer
1634 
         * @return int
1635 
         * @throws \Symfony\Component\Console\Exception\CommandNotFoundException
1636 
         * @static
1637 
         */
1638 
        public static function call($command, $parameters = [], $outputBuffer = null)
1639 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1640 
                        /** @var \App\Console\Kernel $instance */
1641 
                        return $instance->call($command, $parameters, $outputBuffer);
1642 
        }
1643 
                    /**
1644 
         * Queue the given console command.
1645 
         *
1646 
         * @param string $command
1647 
         * @param array $parameters
1648 
         * @return \Illuminate\Foundation\Bus\PendingDispatch
1649 
         * @static
1650 
         */
1651 
        public static function queue($command, $parameters = [])
1652 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1653 
                        /** @var \App\Console\Kernel $instance */
1654 
                        return $instance->queue($command, $parameters);
1655 
        }
1656 
                    /**
1657 
         * Get all of the commands registered with the console.
1658 
         *
1659 
         * @return array
1660 
         * @static
1661 
         */
1662 
        public static function all()
1663 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1664 
                        /** @var \App\Console\Kernel $instance */
1665 
                        return $instance->all();
1666 
        }
1667 
                    /**
1668 
         * Get the output for the last run command.
1669 
         *
1670 
         * @return string
1671 
         * @static
1672 
         */
1673 
        public static function output()
1674 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1675 
                        /** @var \App\Console\Kernel $instance */
1676 
                        return $instance->output();
1677 
        }
1678 
                    /**
1679 
         * Bootstrap the application for artisan commands.
1680 
         *
1681 
         * @return void
1682 
         * @static
1683 
         */
1684 
        public static function bootstrap()
1685 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1686 
                        /** @var \App\Console\Kernel $instance */
1687 
                        $instance->bootstrap();
1688 
        }
1689 
                    /**
1690 
         * Bootstrap the application without booting service providers.
1691 
         *
1692 
         * @return void
1693 
         * @static
1694 
         */
1695 
        public static function bootstrapWithoutBootingProviders()
1696 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1697 
                        /** @var \App\Console\Kernel $instance */
1698 
                        $instance->bootstrapWithoutBootingProviders();
1699 
        }
1700 
                    /**
1701 
         * Set the Artisan application instance.
1702 
         *
1703 
         * @param \Illuminate\Console\Application $artisan
1704 
         * @return void
1705 
         * @static
1706 
         */
1707 
        public static function setArtisan($artisan)
1708 
        {            //Method inherited from \Illuminate\Foundation\Console\Kernel
1709 
                        /** @var \App\Console\Kernel $instance */
1710 
                        $instance->setArtisan($artisan);
1711 
        }
1712 
 
1713 
    }
1714 
            /**
1715 
     *
1716 
     *
1717 
     * @see \Illuminate\Auth\AuthManager
1718 
     * @see \Illuminate\Auth\SessionGuard
1719 
     */
1720 
        class Auth {
1721 
                    /**
1722 
         * Attempt to get the guard from the local cache.
1723 
         *
1724 
         * @param string|null $name
1725 
         * @return \Illuminate\Contracts\Auth\Guard|\Illuminate\Contracts\Auth\StatefulGuard
1726 
         * @static
1727 
         */
1728 
        public static function guard($name = null)
1729 
        {
1730 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1731 
                        return $instance->guard($name);
1732 
        }
1733 
                    /**
1734 
         * Create a session based authentication guard.
1735 
         *
1736 
         * @param string $name
1737 
         * @param array $config
1738 
         * @return \Illuminate\Auth\SessionGuard
1739 
         * @static
1740 
         */
1741 
        public static function createSessionDriver($name, $config)
1742 
        {
1743 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1744 
                        return $instance->createSessionDriver($name, $config);
1745 
        }
1746 
                    /**
1747 
         * Create a token based authentication guard.
1748 
         *
1749 
         * @param string $name
1750 
         * @param array $config
1751 
         * @return \Illuminate\Auth\TokenGuard
1752 
         * @static
1753 
         */
1754 
        public static function createTokenDriver($name, $config)
1755 
        {
1756 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1757 
                        return $instance->createTokenDriver($name, $config);
1758 
        }
1759 
                    /**
1760 
         * Get the default authentication driver name.
1761 
         *
1762 
         * @return string
1763 
         * @static
1764 
         */
1765 
        public static function getDefaultDriver()
1766 
        {
1767 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1768 
                        return $instance->getDefaultDriver();
1769 
        }
1770 
                    /**
1771 
         * Set the default guard driver the factory should serve.
1772 
         *
1773 
         * @param string $name
1774 
         * @return void
1775 
         * @static
1776 
         */
1777 
        public static function shouldUse($name)
1778 
        {
1779 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1780 
                        $instance->shouldUse($name);
1781 
        }
1782 
                    /**
1783 
         * Set the default authentication driver name.
1784 
         *
1785 
         * @param string $name
1786 
         * @return void
1787 
         * @static
1788 
         */
1789 
        public static function setDefaultDriver($name)
1790 
        {
1791 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1792 
                        $instance->setDefaultDriver($name);
1793 
        }
1794 
                    /**
1795 
         * Register a new callback based request guard.
1796 
         *
1797 
         * @param string $driver
1798 
         * @param callable $callback
1799 
         * @return \Illuminate\Auth\AuthManager
1800 
         * @static
1801 
         */
1802 
        public static function viaRequest($driver, $callback)
1803 
        {
1804 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1805 
                        return $instance->viaRequest($driver, $callback);
1806 
        }
1807 
                    /**
1808 
         * Get the user resolver callback.
1809 
         *
1810 
         * @return \Closure
1811 
         * @static
1812 
         */
1813 
        public static function userResolver()
1814 
        {
1815 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1816 
                        return $instance->userResolver();
1817 
        }
1818 
                    /**
1819 
         * Set the callback to be used to resolve users.
1820 
         *
1821 
         * @param \Closure $userResolver
1822 
         * @return \Illuminate\Auth\AuthManager
1823 
         * @static
1824 
         */
1825 
        public static function resolveUsersUsing($userResolver)
1826 
        {
1827 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1828 
                        return $instance->resolveUsersUsing($userResolver);
1829 
        }
1830 
                    /**
1831 
         * Register a custom driver creator Closure.
1832 
         *
1833 
         * @param string $driver
1834 
         * @param \Closure $callback
1835 
         * @return \Illuminate\Auth\AuthManager
1836 
         * @static
1837 
         */
1838 
        public static function extend($driver, $callback)
1839 
        {
1840 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1841 
                        return $instance->extend($driver, $callback);
1842 
        }
1843 
                    /**
1844 
         * Register a custom provider creator Closure.
1845 
         *
1846 
         * @param string $name
1847 
         * @param \Closure $callback
1848 
         * @return \Illuminate\Auth\AuthManager
1849 
         * @static
1850 
         */
1851 
        public static function provider($name, $callback)
1852 
        {
1853 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1854 
                        return $instance->provider($name, $callback);
1855 
        }
1856 
                    /**
1857 
         * Determines if any guards have already been resolved.
1858 
         *
1859 
         * @return bool
1860 
         * @static
1861 
         */
1862 
        public static function hasResolvedGuards()
1863 
        {
1864 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1865 
                        return $instance->hasResolvedGuards();
1866 
        }
1867 
                    /**
1868 
         * Forget all of the resolved guard instances.
1869 
         *
1870 
         * @return \Illuminate\Auth\AuthManager
1871 
         * @static
1872 
         */
1873 
        public static function forgetGuards()
1874 
        {
1875 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1876 
                        return $instance->forgetGuards();
1877 
        }
1878 
                    /**
1879 
         * Set the application instance used by the manager.
1880 
         *
1881 
         * @param \Illuminate\Contracts\Foundation\Application $app
1882 
         * @return \Illuminate\Auth\AuthManager
1883 
         * @static
1884 
         */
1885 
        public static function setApplication($app)
1886 
        {
1887 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1888 
                        return $instance->setApplication($app);
1889 
        }
1890 
                    /**
1891 
         * Create the user provider implementation for the driver.
1892 
         *
1893 
         * @param string|null $provider
1894 
         * @return \Illuminate\Contracts\Auth\UserProvider|null
1895 
         * @throws \InvalidArgumentException
1896 
         * @static
1897 
         */
1898 
        public static function createUserProvider($provider = null)
1899 
        {
1900 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1901 
                        return $instance->createUserProvider($provider);
1902 
        }
1903 
                    /**
1904 
         * Get the default user provider name.
1905 
         *
1906 
         * @return string
1907 
         * @static
1908 
         */
1909 
        public static function getDefaultUserProvider()
1910 
        {
1911 
                        /** @var \Illuminate\Auth\AuthManager $instance */
1912 
                        return $instance->getDefaultUserProvider();
1913 
        }
1914 
                    /**
1915 
         * Get the currently authenticated user.
1916 
         *
1917 
         * @return \App\Models\User|null
1918 
         * @static
1919 
         */
1920 
        public static function user()
1921 
        {
1922 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
1923 
                        return $instance->user();
1924 
        }
1925 
                    /**
1926 
         * Get the ID for the currently authenticated user.
1927 
         *
1928 
         * @return int|string|null
1929 
         * @static
1930 
         */
1931 
        public static function id()
1932 
        {
1933 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
1934 
                        return $instance->id();
1935 
        }
1936 
                    /**
1937 
         * Log a user into the application without sessions or cookies.
1938 
         *
1939 
         * @param array $credentials
1940 
         * @return bool
1941 
         * @static
1942 
         */
1943 
        public static function once($credentials = [])
1944 
        {
1945 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
1946 
                        return $instance->once($credentials);
1947 
        }
1948 
                    /**
1949 
         * Log the given user ID into the application without sessions or cookies.
1950 
         *
1951 
         * @param mixed $id
1952 
         * @return \App\Models\User|false
1953 
         * @static
1954 
         */
1955 
        public static function onceUsingId($id)
1956 
        {
1957 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
1958 
                        return $instance->onceUsingId($id);
1959 
        }
1960 
                    /**
1961 
         * Validate a user's credentials.
1962 
         *
1963 
         * @param array $credentials
1964 
         * @return bool
1965 
         * @static
1966 
         */
1967 
        public static function validate($credentials = [])
1968 
        {
1969 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
1970 
                        return $instance->validate($credentials);
1971 
        }
1972 
                    /**
1973 
         * Attempt to authenticate using HTTP Basic Auth.
1974 
         *
1975 
         * @param string $field
1976 
         * @param array $extraConditions
1977 
         * @return \Symfony\Component\HttpFoundation\Response|null
1978 
         * @throws \Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException
1979 
         * @static
1980 
         */
1981 
        public static function basic($field = 'email', $extraConditions = [])
1982 
        {
1983 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
1984 
                        return $instance->basic($field, $extraConditions);
1985 
        }
1986 
                    /**
1987 
         * Perform a stateless HTTP Basic login attempt.
1988 
         *
1989 
         * @param string $field
1990 
         * @param array $extraConditions
1991 
         * @return \Symfony\Component\HttpFoundation\Response|null
1992 
         * @throws \Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException
1993 
         * @static
1994 
         */
1995 
        public static function onceBasic($field = 'email', $extraConditions = [])
1996 
        {
1997 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
1998 
                        return $instance->onceBasic($field, $extraConditions);
1999 
        }
2000 
                    /**
2001 
         * Attempt to authenticate a user using the given credentials.
2002 
         *
2003 
         * @param array $credentials
2004 
         * @param bool $remember
2005 
         * @return bool
2006 
         * @static
2007 
         */
2008 
        public static function attempt($credentials = [], $remember = false)
2009 
        {
2010 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2011 
                        return $instance->attempt($credentials, $remember);
2012 
        }
2013 
                    /**
2014 
         * Attempt to authenticate a user with credentials and additional callbacks.
2015 
         *
2016 
         * @param array $credentials
2017 
         * @param array|callable|null $callbacks
2018 
         * @param bool $remember
2019 
         * @return bool
2020 
         * @static
2021 
         */
2022 
        public static function attemptWhen($credentials = [], $callbacks = null, $remember = false)
2023 
        {
2024 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2025 
                        return $instance->attemptWhen($credentials, $callbacks, $remember);
2026 
        }
2027 
                    /**
2028 
         * Log the given user ID into the application.
2029 
         *
2030 
         * @param mixed $id
2031 
         * @param bool $remember
2032 
         * @return \App\Models\User|false
2033 
         * @static
2034 
         */
2035 
        public static function loginUsingId($id, $remember = false)
2036 
        {
2037 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2038 
                        return $instance->loginUsingId($id, $remember);
2039 
        }
2040 
                    /**
2041 
         * Log a user into the application.
2042 
         *
2043 
         * @param \Illuminate\Contracts\Auth\Authenticatable $user
2044 
         * @param bool $remember
2045 
         * @return void
2046 
         * @static
2047 
         */
2048 
        public static function login($user, $remember = false)
2049 
        {
2050 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2051 
                        $instance->login($user, $remember);
2052 
        }
2053 
                    /**
2054 
         * Log the user out of the application.
2055 
         *
2056 
         * @return void
2057 
         * @static
2058 
         */
2059 
        public static function logout()
2060 
        {
2061 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2062 
                        $instance->logout();
2063 
        }
2064 
                    /**
2065 
         * Log the user out of the application on their current device only.
2066 
         *
2067 
         * This method does not cycle the "remember" token.
2068 
         *
2069 
         * @return void
2070 
         * @static
2071 
         */
2072 
        public static function logoutCurrentDevice()
2073 
        {
2074 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2075 
                        $instance->logoutCurrentDevice();
2076 
        }
2077 
                    /**
2078 
         * Invalidate other sessions for the current user.
2079 
         *
2080 
         * The application must be using the AuthenticateSession middleware.
2081 
         *
2082 
         * @param string $password
2083 
         * @param string $attribute
2084 
         * @return \App\Models\User|null
2085 
         * @throws \Illuminate\Auth\AuthenticationException
2086 
         * @static
2087 
         */
2088 
        public static function logoutOtherDevices($password, $attribute = 'password')
2089 
        {
2090 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2091 
                        return $instance->logoutOtherDevices($password, $attribute);
2092 
        }
2093 
                    /**
2094 
         * Register an authentication attempt event listener.
2095 
         *
2096 
         * @param mixed $callback
2097 
         * @return void
2098 
         * @static
2099 
         */
2100 
        public static function attempting($callback)
2101 
        {
2102 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2103 
                        $instance->attempting($callback);
2104 
        }
2105 
                    /**
2106 
         * Get the last user we attempted to authenticate.
2107 
         *
2108 
         * @return \App\Models\User
2109 
         * @static
2110 
         */
2111 
        public static function getLastAttempted()
2112 
        {
2113 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2114 
                        return $instance->getLastAttempted();
2115 
        }
2116 
                    /**
2117 
         * Get a unique identifier for the auth session value.
2118 
         *
2119 
         * @return string
2120 
         * @static
2121 
         */
2122 
        public static function getName()
2123 
        {
2124 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2125 
                        return $instance->getName();
2126 
        }
2127 
                    /**
2128 
         * Get the name of the cookie used to store the "recaller".
2129 
         *
2130 
         * @return string
2131 
         * @static
2132 
         */
2133 
        public static function getRecallerName()
2134 
        {
2135 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2136 
                        return $instance->getRecallerName();
2137 
        }
2138 
                    /**
2139 
         * Determine if the user was authenticated via "remember me" cookie.
2140 
         *
2141 
         * @return bool
2142 
         * @static
2143 
         */
2144 
        public static function viaRemember()
2145 
        {
2146 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2147 
                        return $instance->viaRemember();
2148 
        }
2149 
                    /**
2150 
         * Set the number of minutes the remember me cookie should be valid for.
2151 
         *
2152 
         * @param int $minutes
2153 
         * @return \Illuminate\Auth\SessionGuard
2154 
         * @static
2155 
         */
2156 
        public static function setRememberDuration($minutes)
2157 
        {
2158 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2159 
                        return $instance->setRememberDuration($minutes);
2160 
        }
2161 
                    /**
2162 
         * Get the cookie creator instance used by the guard.
2163 
         *
2164 
         * @return \Illuminate\Contracts\Cookie\QueueingFactory
2165 
         * @throws \RuntimeException
2166 
         * @static
2167 
         */
2168 
        public static function getCookieJar()
2169 
        {
2170 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2171 
                        return $instance->getCookieJar();
2172 
        }
2173 
                    /**
2174 
         * Set the cookie creator instance used by the guard.
2175 
         *
2176 
         * @param \Illuminate\Contracts\Cookie\QueueingFactory $cookie
2177 
         * @return void
2178 
         * @static
2179 
         */
2180 
        public static function setCookieJar($cookie)
2181 
        {
2182 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2183 
                        $instance->setCookieJar($cookie);
2184 
        }
2185 
                    /**
2186 
         * Get the event dispatcher instance.
2187 
         *
2188 
         * @return \Illuminate\Contracts\Events\Dispatcher
2189 
         * @static
2190 
         */
2191 
        public static function getDispatcher()
2192 
        {
2193 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2194 
                        return $instance->getDispatcher();
2195 
        }
2196 
                    /**
2197 
         * Set the event dispatcher instance.
2198 
         *
2199 
         * @param \Illuminate\Contracts\Events\Dispatcher $events
2200 
         * @return void
2201 
         * @static
2202 
         */
2203 
        public static function setDispatcher($events)
2204 
        {
2205 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2206 
                        $instance->setDispatcher($events);
2207 
        }
2208 
                    /**
2209 
         * Get the session store used by the guard.
2210 
         *
2211 
         * @return \Illuminate\Contracts\Session\Session
2212 
         * @static
2213 
         */
2214 
        public static function getSession()
2215 
        {
2216 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2217 
                        return $instance->getSession();
2218 
        }
2219 
                    /**
2220 
         * Return the currently cached user.
2221 
         *
2222 
         * @return \App\Models\User|null
2223 
         * @static
2224 
         */
2225 
        public static function getUser()
2226 
        {
2227 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2228 
                        return $instance->getUser();
2229 
        }
2230 
                    /**
2231 
         * Set the current user.
2232 
         *
2233 
         * @param \Illuminate\Contracts\Auth\Authenticatable $user
2234 
         * @return \Illuminate\Auth\SessionGuard
2235 
         * @static
2236 
         */
2237 
        public static function setUser($user)
2238 
        {
2239 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2240 
                        return $instance->setUser($user);
2241 
        }
2242 
                    /**
2243 
         * Get the current request instance.
2244 
         *
2245 
         * @return \Symfony\Component\HttpFoundation\Request
2246 
         * @static
2247 
         */
2248 
        public static function getRequest()
2249 
        {
2250 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2251 
                        return $instance->getRequest();
2252 
        }
2253 
                    /**
2254 
         * Set the current request instance.
2255 
         *
2256 
         * @param \Symfony\Component\HttpFoundation\Request $request
2257 
         * @return \Illuminate\Auth\SessionGuard
2258 
         * @static
2259 
         */
2260 
        public static function setRequest($request)
2261 
        {
2262 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2263 
                        return $instance->setRequest($request);
2264 
        }
2265 
                    /**
2266 
         * Get the timebox instance used by the guard.
2267 
         *
2268 
         * @return \Illuminate\Support\Timebox
2269 
         * @static
2270 
         */
2271 
        public static function getTimebox()
2272 
        {
2273 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2274 
                        return $instance->getTimebox();
2275 
        }
2276 
                    /**
2277 
         * Determine if the current user is authenticated. If not, throw an exception.
2278 
         *
2279 
         * @return \App\Models\User
2280 
         * @throws \Illuminate\Auth\AuthenticationException
2281 
         * @static
2282 
         */
2283 
        public static function authenticate()
2284 
        {
2285 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2286 
                        return $instance->authenticate();
2287 
        }
2288 
                    /**
2289 
         * Determine if the guard has a user instance.
2290 
         *
2291 
         * @return bool
2292 
         * @static
2293 
         */
2294 
        public static function hasUser()
2295 
        {
2296 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2297 
                        return $instance->hasUser();
2298 
        }
2299 
                    /**
2300 
         * Determine if the current user is authenticated.
2301 
         *
2302 
         * @return bool
2303 
         * @static
2304 
         */
2305 
        public static function check()
2306 
        {
2307 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2308 
                        return $instance->check();
2309 
        }
2310 
                    /**
2311 
         * Determine if the current user is a guest.
2312 
         *
2313 
         * @return bool
2314 
         * @static
2315 
         */
2316 
        public static function guest()
2317 
        {
2318 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2319 
                        return $instance->guest();
2320 
        }
2321 
                    /**
2322 
         * Forget the current user.
2323 
         *
2324 
         * @return \Illuminate\Auth\SessionGuard
2325 
         * @static
2326 
         */
2327 
        public static function forgetUser()
2328 
        {
2329 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2330 
                        return $instance->forgetUser();
2331 
        }
2332 
                    /**
2333 
         * Get the user provider used by the guard.
2334 
         *
2335 
         * @return \Illuminate\Contracts\Auth\UserProvider
2336 
         * @static
2337 
         */
2338 
        public static function getProvider()
2339 
        {
2340 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2341 
                        return $instance->getProvider();
2342 
        }
2343 
                    /**
2344 
         * Set the user provider used by the guard.
2345 
         *
2346 
         * @param \Illuminate\Contracts\Auth\UserProvider $provider
2347 
         * @return void
2348 
         * @static
2349 
         */
2350 
        public static function setProvider($provider)
2351 
        {
2352 
                        /** @var \Illuminate\Auth\SessionGuard $instance */
2353 
                        $instance->setProvider($provider);
2354 
        }
2355 
                    /**
2356 
         * Register a custom macro.
2357 
         *
2358 
         * @param string $name
2359 
         * @param object|callable $macro
2360 
         * @return void
2361 
         * @static
2362 
         */
2363 
        public static function macro($name, $macro)
2364 
        {
2365 
                        \Illuminate\Auth\SessionGuard::macro($name, $macro);
2366 
        }
2367 
                    /**
2368 
         * Mix another object into the class.
2369 
         *
2370 
         * @param object $mixin
2371 
         * @param bool $replace
2372 
         * @return void
2373 
         * @throws \ReflectionException
2374 
         * @static
2375 
         */
2376 
        public static function mixin($mixin, $replace = true)
2377 
        {
2378 
                        \Illuminate\Auth\SessionGuard::mixin($mixin, $replace);
2379 
        }
2380 
                    /**
2381 
         * Checks if macro is registered.
2382 
         *
2383 
         * @param string $name
2384 
         * @return bool
2385 
         * @static
2386 
         */
2387 
        public static function hasMacro($name)
2388 
        {
2389 
                        return \Illuminate\Auth\SessionGuard::hasMacro($name);
2390 
        }
2391 
                    /**
2392 
         * Flush the existing macros.
2393 
         *
2394 
         * @return void
2395 
         * @static
2396 
         */
2397 
        public static function flushMacros()
2398 
        {
2399 
                        \Illuminate\Auth\SessionGuard::flushMacros();
2400 
        }
2401 
 
2402 
    }
2403 
            /**
2404 
     *
2405 
     *
2406 
     * @see \Illuminate\View\Compilers\BladeCompiler
2407 
     */
2408 
        class Blade {
2409 
                    /**
2410 
         * Compile the view at the given path.
2411 
         *
2412 
         * @param string|null $path
2413 
         * @return void
2414 
         * @static
2415 
         */
2416 
        public static function compile($path = null)
2417 
        {
2418 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2419 
                        $instance->compile($path);
2420 
        }
2421 
                    /**
2422 
         * Get the path currently being compiled.
2423 
         *
2424 
         * @return string
2425 
         * @static
2426 
         */
2427 
        public static function getPath()
2428 
        {
2429 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2430 
                        return $instance->getPath();
2431 
        }
2432 
                    /**
2433 
         * Set the path currently being compiled.
2434 
         *
2435 
         * @param string $path
2436 
         * @return void
2437 
         * @static
2438 
         */
2439 
        public static function setPath($path)
2440 
        {
2441 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2442 
                        $instance->setPath($path);
2443 
        }
2444 
                    /**
2445 
         * Compile the given Blade template contents.
2446 
         *
2447 
         * @param string $value
2448 
         * @return string
2449 
         * @static
2450 
         */
2451 
        public static function compileString($value)
2452 
        {
2453 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2454 
                        return $instance->compileString($value);
2455 
        }
2456 
                    /**
2457 
         * Evaluate and render a Blade string to HTML.
2458 
         *
2459 
         * @param string $string
2460 
         * @param array $data
2461 
         * @param bool $deleteCachedView
2462 
         * @return string
2463 
         * @static
2464 
         */
2465 
        public static function render($string, $data = [], $deleteCachedView = false)
2466 
        {
2467 
                        return \Illuminate\View\Compilers\BladeCompiler::render($string, $data, $deleteCachedView);
2468 
        }
2469 
                    /**
2470 
         * Render a component instance to HTML.
2471 
         *
2472 
         * @param \Illuminate\View\Component $component
2473 
         * @return string
2474 
         * @static
2475 
         */
2476 
        public static function renderComponent($component)
2477 
        {
2478 
                        return \Illuminate\View\Compilers\BladeCompiler::renderComponent($component);
2479 
        }
2480 
                    /**
2481 
         * Strip the parentheses from the given expression.
2482 
         *
2483 
         * @param string $expression
2484 
         * @return string
2485 
         * @static
2486 
         */
2487 
        public static function stripParentheses($expression)
2488 
        {
2489 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2490 
                        return $instance->stripParentheses($expression);
2491 
        }
2492 
                    /**
2493 
         * Register a custom Blade compiler.
2494 
         *
2495 
         * @param callable $compiler
2496 
         * @return void
2497 
         * @static
2498 
         */
2499 
        public static function extend($compiler)
2500 
        {
2501 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2502 
                        $instance->extend($compiler);
2503 
        }
2504 
                    /**
2505 
         * Get the extensions used by the compiler.
2506 
         *
2507 
         * @return array
2508 
         * @static
2509 
         */
2510 
        public static function getExtensions()
2511 
        {
2512 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2513 
                        return $instance->getExtensions();
2514 
        }
2515 
                    /**
2516 
         * Register an "if" statement directive.
2517 
         *
2518 
         * @param string $name
2519 
         * @param callable $callback
2520 
         * @return void
2521 
         * @static
2522 
         */
2523 
        public static function if($name, $callback)
2524 
        {
2525 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2526 
                        $instance->if($name, $callback);
2527 
        }
2528 
                    /**
2529 
         * Check the result of a condition.
2530 
         *
2531 
         * @param string $name
2532 
         * @param mixed $parameters
2533 
         * @return bool
2534 
         * @static
2535 
         */
2536 
        public static function check($name, ...$parameters)
2537 
        {
2538 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2539 
                        return $instance->check($name, ...$parameters);
2540 
        }
2541 
                    /**
2542 
         * Register a class-based component alias directive.
2543 
         *
2544 
         * @param string $class
2545 
         * @param string|null $alias
2546 
         * @param string $prefix
2547 
         * @return void
2548 
         * @static
2549 
         */
2550 
        public static function component($class, $alias = null, $prefix = '')
2551 
        {
2552 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2553 
                        $instance->component($class, $alias, $prefix);
2554 
        }
2555 
                    /**
2556 
         * Register an array of class-based components.
2557 
         *
2558 
         * @param array $components
2559 
         * @param string $prefix
2560 
         * @return void
2561 
         * @static
2562 
         */
2563 
        public static function components($components, $prefix = '')
2564 
        {
2565 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2566 
                        $instance->components($components, $prefix);
2567 
        }
2568 
                    /**
2569 
         * Get the registered class component aliases.
2570 
         *
2571 
         * @return array
2572 
         * @static
2573 
         */
2574 
        public static function getClassComponentAliases()
2575 
        {
2576 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2577 
                        return $instance->getClassComponentAliases();
2578 
        }
2579 
                    /**
2580 
         * Register a new anonymous component path.
2581 
         *
2582 
         * @param string $path
2583 
         * @param string|null $prefix
2584 
         * @return void
2585 
         * @static
2586 
         */
2587 
        public static function anonymousComponentPath($path, $prefix = null)
2588 
        {
2589 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2590 
                        $instance->anonymousComponentPath($path, $prefix);
2591 
        }
2592 
                    /**
2593 
         * Register an anonymous component namespace.
2594 
         *
2595 
         * @param string $directory
2596 
         * @param string|null $prefix
2597 
         * @return void
2598 
         * @static
2599 
         */
2600 
        public static function anonymousComponentNamespace($directory, $prefix = null)
2601 
        {
2602 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2603 
                        $instance->anonymousComponentNamespace($directory, $prefix);
2604 
        }
2605 
                    /**
2606 
         * Register a class-based component namespace.
2607 
         *
2608 
         * @param string $namespace
2609 
         * @param string $prefix
2610 
         * @return void
2611 
         * @static
2612 
         */
2613 
        public static function componentNamespace($namespace, $prefix)
2614 
        {
2615 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2616 
                        $instance->componentNamespace($namespace, $prefix);
2617 
        }
2618 
                    /**
2619 
         * Get the registered anonymous component paths.
2620 
         *
2621 
         * @return array
2622 
         * @static
2623 
         */
2624 
        public static function getAnonymousComponentPaths()
2625 
        {
2626 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2627 
                        return $instance->getAnonymousComponentPaths();
2628 
        }
2629 
                    /**
2630 
         * Get the registered anonymous component namespaces.
2631 
         *
2632 
         * @return array
2633 
         * @static
2634 
         */
2635 
        public static function getAnonymousComponentNamespaces()
2636 
        {
2637 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2638 
                        return $instance->getAnonymousComponentNamespaces();
2639 
        }
2640 
                    /**
2641 
         * Get the registered class component namespaces.
2642 
         *
2643 
         * @return array
2644 
         * @static
2645 
         */
2646 
        public static function getClassComponentNamespaces()
2647 
        {
2648 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2649 
                        return $instance->getClassComponentNamespaces();
2650 
        }
2651 
                    /**
2652 
         * Register a component alias directive.
2653 
         *
2654 
         * @param string $path
2655 
         * @param string|null $alias
2656 
         * @return void
2657 
         * @static
2658 
         */
2659 
        public static function aliasComponent($path, $alias = null)
2660 
        {
2661 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2662 
                        $instance->aliasComponent($path, $alias);
2663 
        }
2664 
                    /**
2665 
         * Register an include alias directive.
2666 
         *
2667 
         * @param string $path
2668 
         * @param string|null $alias
2669 
         * @return void
2670 
         * @static
2671 
         */
2672 
        public static function include($path, $alias = null)
2673 
        {
2674 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2675 
                        $instance->include($path, $alias);
2676 
        }
2677 
                    /**
2678 
         * Register an include alias directive.
2679 
         *
2680 
         * @param string $path
2681 
         * @param string|null $alias
2682 
         * @return void
2683 
         * @static
2684 
         */
2685 
        public static function aliasInclude($path, $alias = null)
2686 
        {
2687 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2688 
                        $instance->aliasInclude($path, $alias);
2689 
        }
2690 
                    /**
2691 
         * Register a handler for custom directives.
2692 
         *
2693 
         * @param string $name
2694 
         * @param callable $handler
2695 
         * @return void
2696 
         * @throws \InvalidArgumentException
2697 
         * @static
2698 
         */
2699 
        public static function directive($name, $handler)
2700 
        {
2701 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2702 
                        $instance->directive($name, $handler);
2703 
        }
2704 
                    /**
2705 
         * Get the list of custom directives.
2706 
         *
2707 
         * @return array
2708 
         * @static
2709 
         */
2710 
        public static function getCustomDirectives()
2711 
        {
2712 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2713 
                        return $instance->getCustomDirectives();
2714 
        }
2715 
                    /**
2716 
         * Register a new precompiler.
2717 
         *
2718 
         * @param callable $precompiler
2719 
         * @return void
2720 
         * @static
2721 
         */
2722 
        public static function precompiler($precompiler)
2723 
        {
2724 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2725 
                        $instance->precompiler($precompiler);
2726 
        }
2727 
                    /**
2728 
         * Set the echo format to be used by the compiler.
2729 
         *
2730 
         * @param string $format
2731 
         * @return void
2732 
         * @static
2733 
         */
2734 
        public static function setEchoFormat($format)
2735 
        {
2736 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2737 
                        $instance->setEchoFormat($format);
2738 
        }
2739 
                    /**
2740 
         * Set the "echo" format to double encode entities.
2741 
         *
2742 
         * @return void
2743 
         * @static
2744 
         */
2745 
        public static function withDoubleEncoding()
2746 
        {
2747 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2748 
                        $instance->withDoubleEncoding();
2749 
        }
2750 
                    /**
2751 
         * Set the "echo" format to not double encode entities.
2752 
         *
2753 
         * @return void
2754 
         * @static
2755 
         */
2756 
        public static function withoutDoubleEncoding()
2757 
        {
2758 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2759 
                        $instance->withoutDoubleEncoding();
2760 
        }
2761 
                    /**
2762 
         * Indicate that component tags should not be compiled.
2763 
         *
2764 
         * @return void
2765 
         * @static
2766 
         */
2767 
        public static function withoutComponentTags()
2768 
        {
2769 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2770 
                        $instance->withoutComponentTags();
2771 
        }
2772 
                    /**
2773 
         * Get the path to the compiled version of a view.
2774 
         *
2775 
         * @param string $path
2776 
         * @return string
2777 
         * @static
2778 
         */
2779 
        public static function getCompiledPath($path)
2780 
        {            //Method inherited from \Illuminate\View\Compilers\Compiler
2781 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2782 
                        return $instance->getCompiledPath($path);
2783 
        }
2784 
                    /**
2785 
         * Determine if the view at the given path is expired.
2786 
         *
2787 
         * @param string $path
2788 
         * @return bool
2789 
         * @static
2790 
         */
2791 
        public static function isExpired($path)
2792 
        {            //Method inherited from \Illuminate\View\Compilers\Compiler
2793 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2794 
                        return $instance->isExpired($path);
2795 
        }
2796 
                    /**
2797 
         * Get a new component hash for a component name.
2798 
         *
2799 
         * @param string $component
2800 
         * @return string
2801 
         * @static
2802 
         */
2803 
        public static function newComponentHash($component)
2804 
        {
2805 
                        return \Illuminate\View\Compilers\BladeCompiler::newComponentHash($component);
2806 
        }
2807 
                    /**
2808 
         * Compile a class component opening.
2809 
         *
2810 
         * @param string $component
2811 
         * @param string $alias
2812 
         * @param string $data
2813 
         * @param string $hash
2814 
         * @return string
2815 
         * @static
2816 
         */
2817 
        public static function compileClassComponentOpening($component, $alias, $data, $hash)
2818 
        {
2819 
                        return \Illuminate\View\Compilers\BladeCompiler::compileClassComponentOpening($component, $alias, $data, $hash);
2820 
        }
2821 
                    /**
2822 
         * Compile the end-component statements into valid PHP.
2823 
         *
2824 
         * @return string
2825 
         * @static
2826 
         */
2827 
        public static function compileEndComponentClass()
2828 
        {
2829 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2830 
                        return $instance->compileEndComponentClass();
2831 
        }
2832 
                    /**
2833 
         * Sanitize the given component attribute value.
2834 
         *
2835 
         * @param mixed $value
2836 
         * @return mixed
2837 
         * @static
2838 
         */
2839 
        public static function sanitizeComponentAttribute($value)
2840 
        {
2841 
                        return \Illuminate\View\Compilers\BladeCompiler::sanitizeComponentAttribute($value);
2842 
        }
2843 
                    /**
2844 
         * Compile an end-once block into valid PHP.
2845 
         *
2846 
         * @return string
2847 
         * @static
2848 
         */
2849 
        public static function compileEndOnce()
2850 
        {
2851 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2852 
                        return $instance->compileEndOnce();
2853 
        }
2854 
                    /**
2855 
         * Add a handler to be executed before echoing a given class.
2856 
         *
2857 
         * @param string|callable $class
2858 
         * @param callable|null $handler
2859 
         * @return void
2860 
         * @static
2861 
         */
2862 
        public static function stringable($class, $handler = null)
2863 
        {
2864 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2865 
                        $instance->stringable($class, $handler);
2866 
        }
2867 
                    /**
2868 
         * Compile Blade echos into valid PHP.
2869 
         *
2870 
         * @param string $value
2871 
         * @return string
2872 
         * @static
2873 
         */
2874 
        public static function compileEchos($value)
2875 
        {
2876 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2877 
                        return $instance->compileEchos($value);
2878 
        }
2879 
                    /**
2880 
         * Apply the echo handler for the value if it exists.
2881 
         *
2882 
         * @param string $value
2883 
         * @return string
2884 
         * @static
2885 
         */
2886 
        public static function applyEchoHandler($value)
2887 
        {
2888 
                        /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2889 
                        return $instance->applyEchoHandler($value);
2890 
        }
2891 
 
2892 
    }
2893 
            /**
2894 
     *
2895 
     *
2896 
     * @method static mixed auth(\Illuminate\Http\Request $request)
2897 
     * @method static mixed validAuthenticationResponse(\Illuminate\Http\Request $request, mixed $result)
2898 
     * @method static void broadcast(array $channels, string $event, array $payload = [])
2899 
     * @method static array|null resolveAuthenticatedUser(\Illuminate\Http\Request $request)
2900 
     * @method static void resolveAuthenticatedUserUsing(\Closure $callback)
2901 
     * @method static \Illuminate\Broadcasting\Broadcasters\Broadcaster channel(\Illuminate\Contracts\Broadcasting\HasBroadcastChannel|string $channel, callable|string $callback, array $options = [])
2902 
     * @see \Illuminate\Broadcasting\BroadcastManager
2903 
     * @see \Illuminate\Broadcasting\Broadcasters\Broadcaster
2904 
     */
2905 
        class Broadcast {
2906 
                    /**
2907 
         * Register the routes for handling broadcast channel authentication and sockets.
2908 
         *
2909 
         * @param array|null $attributes
2910 
         * @return void
2911 
         * @static
2912 
         */
2913 
        public static function routes($attributes = null)
2914 
        {
2915 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2916 
                        $instance->routes($attributes);
2917 
        }
2918 
                    /**
2919 
         * Register the routes for handling broadcast user authentication.
2920 
         *
2921 
         * @param array|null $attributes
2922 
         * @return void
2923 
         * @static
2924 
         */
2925 
        public static function userRoutes($attributes = null)
2926 
        {
2927 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2928 
                        $instance->userRoutes($attributes);
2929 
        }
2930 
                    /**
2931 
         * Register the routes for handling broadcast authentication and sockets.
2932 
         *
2933 
         * Alias of "routes" method.
2934 
         *
2935 
         * @param array|null $attributes
2936 
         * @return void
2937 
         * @static
2938 
         */
2939 
        public static function channelRoutes($attributes = null)
2940 
        {
2941 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2942 
                        $instance->channelRoutes($attributes);
2943 
        }
2944 
                    /**
2945 
         * Get the socket ID for the given request.
2946 
         *
2947 
         * @param \Illuminate\Http\Request|null $request
2948 
         * @return string|null
2949 
         * @static
2950 
         */
2951 
        public static function socket($request = null)
2952 
        {
2953 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2954 
                        return $instance->socket($request);
2955 
        }
2956 
                    /**
2957 
         * Begin broadcasting an event.
2958 
         *
2959 
         * @param mixed|null $event
2960 
         * @return \Illuminate\Broadcasting\PendingBroadcast
2961 
         * @static
2962 
         */
2963 
        public static function event($event = null)
2964 
        {
2965 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2966 
                        return $instance->event($event);
2967 
        }
2968 
                    /**
2969 
         * Queue the given event for broadcast.
2970 
         *
2971 
         * @param mixed $event
2972 
         * @return void
2973 
         * @static
2974 
         */
2975 
        public static function queue($event)
2976 
        {
2977 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2978 
                        $instance->queue($event);
2979 
        }
2980 
                    /**
2981 
         * Get a driver instance.
2982 
         *
2983 
         * @param string|null $driver
2984 
         * @return mixed
2985 
         * @static
2986 
         */
2987 
        public static function connection($driver = null)
2988 
        {
2989 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2990 
                        return $instance->connection($driver);
2991 
        }
2992 
                    /**
2993 
         * Get a driver instance.
2994 
         *
2995 
         * @param string|null $name
2996 
         * @return mixed
2997 
         * @static
2998 
         */
2999 
        public static function driver($name = null)
3000 
        {
3001 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
3002 
                        return $instance->driver($name);
3003 
        }
3004 
                    /**
3005 
         * Get a Pusher instance for the given configuration.
3006 
         *
3007 
         * @param array $config
3008 
         * @return \Pusher\Pusher
3009 
         * @static
3010 
         */
3011 
        public static function pusher($config)
3012 
        {
3013 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
3014 
                        return $instance->pusher($config);
3015 
        }
3016 
                    /**
3017 
         * Get an Ably instance for the given configuration.
3018 
         *
3019 
         * @param array $config
3020 
         * @return \Ably\AblyRest
3021 
         * @static
3022 
         */
3023 
        public static function ably($config)
3024 
        {
3025 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
3026 
                        return $instance->ably($config);
3027 
        }
3028 
                    /**
3029 
         * Get the default driver name.
3030 
         *
3031 
         * @return string
3032 
         * @static
3033 
         */
3034 
        public static function getDefaultDriver()
3035 
        {
3036 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
3037 
                        return $instance->getDefaultDriver();
3038 
        }
3039 
                    /**
3040 
         * Set the default driver name.
3041 
         *
3042 
         * @param string $name
3043 
         * @return void
3044 
         * @static
3045 
         */
3046 
        public static function setDefaultDriver($name)
3047 
        {
3048 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
3049 
                        $instance->setDefaultDriver($name);
3050 
        }
3051 
                    /**
3052 
         * Disconnect the given disk and remove from local cache.
3053 
         *
3054 
         * @param string|null $name
3055 
         * @return void
3056 
         * @static
3057 
         */
3058 
        public static function purge($name = null)
3059 
        {
3060 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
3061 
                        $instance->purge($name);
3062 
        }
3063 
                    /**
3064 
         * Register a custom driver creator Closure.
3065 
         *
3066 
         * @param string $driver
3067 
         * @param \Closure $callback
3068 
         * @return \Illuminate\Broadcasting\BroadcastManager
3069 
         * @static
3070 
         */
3071 
        public static function extend($driver, $callback)
3072 
        {
3073 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
3074 
                        return $instance->extend($driver, $callback);
3075 
        }
3076 
                    /**
3077 
         * Get the application instance used by the manager.
3078 
         *
3079 
         * @return \Illuminate\Contracts\Foundation\Application
3080 
         * @static
3081 
         */
3082 
        public static function getApplication()
3083 
        {
3084 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
3085 
                        return $instance->getApplication();
3086 
        }
3087 
                    /**
3088 
         * Set the application instance used by the manager.
3089 
         *
3090 
         * @param \Illuminate\Contracts\Foundation\Application $app
3091 
         * @return \Illuminate\Broadcasting\BroadcastManager
3092 
         * @static
3093 
         */
3094 
        public static function setApplication($app)
3095 
        {
3096 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
3097 
                        return $instance->setApplication($app);
3098 
        }
3099 
                    /**
3100 
         * Forget all of the resolved driver instances.
3101 
         *
3102 
         * @return \Illuminate\Broadcasting\BroadcastManager
3103 
         * @static
3104 
         */
3105 
        public static function forgetDrivers()
3106 
        {
3107 
                        /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
3108 
                        return $instance->forgetDrivers();
3109 
        }
3110 
 
3111 
    }
3112 
            /**
3113 
     *
3114 
     *
3115 
     * @see \Illuminate\Bus\Dispatcher
3116 
     * @see \Illuminate\Support\Testing\Fakes\BusFake
3117 
     */
3118 
        class Bus {
3119 
                    /**
3120 
         * Dispatch a command to its appropriate handler.
3121 
         *
3122 
         * @param mixed $command
3123 
         * @return mixed
3124 
         * @static
3125 
         */
3126 
        public static function dispatch($command)
3127 
        {
3128 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3129 
                        return $instance->dispatch($command);
3130 
        }
3131 
                    /**
3132 
         * Dispatch a command to its appropriate handler in the current process.
3133 
         *
3134 
         * Queueable jobs will be dispatched to the "sync" queue.
3135 
         *
3136 
         * @param mixed $command
3137 
         * @param mixed $handler
3138 
         * @return mixed
3139 
         * @static
3140 
         */
3141 
        public static function dispatchSync($command, $handler = null)
3142 
        {
3143 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3144 
                        return $instance->dispatchSync($command, $handler);
3145 
        }
3146 
                    /**
3147 
         * Dispatch a command to its appropriate handler in the current process without using the synchronous queue.
3148 
         *
3149 
         * @param mixed $command
3150 
         * @param mixed $handler
3151 
         * @return mixed
3152 
         * @static
3153 
         */
3154 
        public static function dispatchNow($command, $handler = null)
3155 
        {
3156 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3157 
                        return $instance->dispatchNow($command, $handler);
3158 
        }
3159 
                    /**
3160 
         * Attempt to find the batch with the given ID.
3161 
         *
3162 
         * @param string $batchId
3163 
         * @return \Illuminate\Bus\Batch|null
3164 
         * @static
3165 
         */
3166 
        public static function findBatch($batchId)
3167 
        {
3168 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3169 
                        return $instance->findBatch($batchId);
3170 
        }
3171 
                    /**
3172 
         * Create a new batch of queueable jobs.
3173 
         *
3174 
         * @param \Illuminate\Support\Collection|array|mixed $jobs
3175 
         * @return \Illuminate\Bus\PendingBatch
3176 
         * @static
3177 
         */
3178 
        public static function batch($jobs)
3179 
        {
3180 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3181 
                        return $instance->batch($jobs);
3182 
        }
3183 
                    /**
3184 
         * Create a new chain of queueable jobs.
3185 
         *
3186 
         * @param \Illuminate\Support\Collection|array $jobs
3187 
         * @return \Illuminate\Foundation\Bus\PendingChain
3188 
         * @static
3189 
         */
3190 
        public static function chain($jobs)
3191 
        {
3192 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3193 
                        return $instance->chain($jobs);
3194 
        }
3195 
                    /**
3196 
         * Determine if the given command has a handler.
3197 
         *
3198 
         * @param mixed $command
3199 
         * @return bool
3200 
         * @static
3201 
         */
3202 
        public static function hasCommandHandler($command)
3203 
        {
3204 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3205 
                        return $instance->hasCommandHandler($command);
3206 
        }
3207 
                    /**
3208 
         * Retrieve the handler for a command.
3209 
         *
3210 
         * @param mixed $command
3211 
         * @return bool|mixed
3212 
         * @static
3213 
         */
3214 
        public static function getCommandHandler($command)
3215 
        {
3216 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3217 
                        return $instance->getCommandHandler($command);
3218 
        }
3219 
                    /**
3220 
         * Dispatch a command to its appropriate handler behind a queue.
3221 
         *
3222 
         * @param mixed $command
3223 
         * @return mixed
3224 
         * @throws \RuntimeException
3225 
         * @static
3226 
         */
3227 
        public static function dispatchToQueue($command)
3228 
        {
3229 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3230 
                        return $instance->dispatchToQueue($command);
3231 
        }
3232 
                    /**
3233 
         * Dispatch a command to its appropriate handler after the current process.
3234 
         *
3235 
         * @param mixed $command
3236 
         * @param mixed $handler
3237 
         * @return void
3238 
         * @static
3239 
         */
3240 
        public static function dispatchAfterResponse($command, $handler = null)
3241 
        {
3242 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3243 
                        $instance->dispatchAfterResponse($command, $handler);
3244 
        }
3245 
                    /**
3246 
         * Set the pipes through which commands should be piped before dispatching.
3247 
         *
3248 
         * @param array $pipes
3249 
         * @return \Illuminate\Bus\Dispatcher
3250 
         * @static
3251 
         */
3252 
        public static function pipeThrough($pipes)
3253 
        {
3254 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3255 
                        return $instance->pipeThrough($pipes);
3256 
        }
3257 
                    /**
3258 
         * Map a command to a handler.
3259 
         *
3260 
         * @param array $map
3261 
         * @return \Illuminate\Bus\Dispatcher
3262 
         * @static
3263 
         */
3264 
        public static function map($map)
3265 
        {
3266 
                        /** @var \Illuminate\Bus\Dispatcher $instance */
3267 
                        return $instance->map($map);
3268 
        }
3269 
                    /**
3270 
         * Specify the jobs that should be dispatched instead of faked.
3271 
         *
3272 
         * @param array|string $jobsToDispatch
3273 
         * @return void
3274 
         * @static
3275 
         */
3276 
        public static function except($jobsToDispatch)
3277 
        {
3278 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3279 
                        $instance->except($jobsToDispatch);
3280 
        }
3281 
                    /**
3282 
         * Assert if a job was dispatched based on a truth-test callback.
3283 
         *
3284 
         * @param string|\Closure $command
3285 
         * @param callable|int|null $callback
3286 
         * @return void
3287 
         * @static
3288 
         */
3289 
        public static function assertDispatched($command, $callback = null)
3290 
        {
3291 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3292 
                        $instance->assertDispatched($command, $callback);
3293 
        }
3294 
                    /**
3295 
         * Assert if a job was pushed a number of times.
3296 
         *
3297 
         * @param string|\Closure $command
3298 
         * @param int $times
3299 
         * @return void
3300 
         * @static
3301 
         */
3302 
        public static function assertDispatchedTimes($command, $times = 1)
3303 
        {
3304 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3305 
                        $instance->assertDispatchedTimes($command, $times);
3306 
        }
3307 
                    /**
3308 
         * Determine if a job was dispatched based on a truth-test callback.
3309 
         *
3310 
         * @param string|\Closure $command
3311 
         * @param callable|null $callback
3312 
         * @return void
3313 
         * @static
3314 
         */
3315 
        public static function assertNotDispatched($command, $callback = null)
3316 
        {
3317 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3318 
                        $instance->assertNotDispatched($command, $callback);
3319 
        }
3320 
                    /**
3321 
         * Assert that no jobs were dispatched.
3322 
         *
3323 
         * @return void
3324 
         * @static
3325 
         */
3326 
        public static function assertNothingDispatched()
3327 
        {
3328 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3329 
                        $instance->assertNothingDispatched();
3330 
        }
3331 
                    /**
3332 
         * Assert if a job was explicitly dispatched synchronously based on a truth-test callback.
3333 
         *
3334 
         * @param string|\Closure $command
3335 
         * @param callable|int|null $callback
3336 
         * @return void
3337 
         * @static
3338 
         */
3339 
        public static function assertDispatchedSync($command, $callback = null)
3340 
        {
3341 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3342 
                        $instance->assertDispatchedSync($command, $callback);
3343 
        }
3344 
                    /**
3345 
         * Assert if a job was pushed synchronously a number of times.
3346 
         *
3347 
         * @param string|\Closure $command
3348 
         * @param int $times
3349 
         * @return void
3350 
         * @static
3351 
         */
3352 
        public static function assertDispatchedSyncTimes($command, $times = 1)
3353 
        {
3354 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3355 
                        $instance->assertDispatchedSyncTimes($command, $times);
3356 
        }
3357 
                    /**
3358 
         * Determine if a job was dispatched based on a truth-test callback.
3359 
         *
3360 
         * @param string|\Closure $command
3361 
         * @param callable|null $callback
3362 
         * @return void
3363 
         * @static
3364 
         */
3365 
        public static function assertNotDispatchedSync($command, $callback = null)
3366 
        {
3367 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3368 
                        $instance->assertNotDispatchedSync($command, $callback);
3369 
        }
3370 
                    /**
3371 
         * Assert if a job was dispatched after the response was sent based on a truth-test callback.
3372 
         *
3373 
         * @param string|\Closure $command
3374 
         * @param callable|int|null $callback
3375 
         * @return void
3376 
         * @static
3377 
         */
3378 
        public static function assertDispatchedAfterResponse($command, $callback = null)
3379 
        {
3380 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3381 
                        $instance->assertDispatchedAfterResponse($command, $callback);
3382 
        }
3383 
                    /**
3384 
         * Assert if a job was pushed after the response was sent a number of times.
3385 
         *
3386 
         * @param string|\Closure $command
3387 
         * @param int $times
3388 
         * @return void
3389 
         * @static
3390 
         */
3391 
        public static function assertDispatchedAfterResponseTimes($command, $times = 1)
3392 
        {
3393 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3394 
                        $instance->assertDispatchedAfterResponseTimes($command, $times);
3395 
        }
3396 
                    /**
3397 
         * Determine if a job was dispatched based on a truth-test callback.
3398 
         *
3399 
         * @param string|\Closure $command
3400 
         * @param callable|null $callback
3401 
         * @return void
3402 
         * @static
3403 
         */
3404 
        public static function assertNotDispatchedAfterResponse($command, $callback = null)
3405 
        {
3406 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3407 
                        $instance->assertNotDispatchedAfterResponse($command, $callback);
3408 
        }
3409 
                    /**
3410 
         * Assert if a chain of jobs was dispatched.
3411 
         *
3412 
         * @param array $expectedChain
3413 
         * @return void
3414 
         * @static
3415 
         */
3416 
        public static function assertChained($expectedChain)
3417 
        {
3418 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3419 
                        $instance->assertChained($expectedChain);
3420 
        }
3421 
                    /**
3422 
         * Assert if a job was dispatched with an empty chain based on a truth-test callback.
3423 
         *
3424 
         * @param string|\Closure $command
3425 
         * @param callable|null $callback
3426 
         * @return void
3427 
         * @static
3428 
         */
3429 
        public static function assertDispatchedWithoutChain($command, $callback = null)
3430 
        {
3431 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3432 
                        $instance->assertDispatchedWithoutChain($command, $callback);
3433 
        }
3434 
                    /**
3435 
         * Assert if a batch was dispatched based on a truth-test callback.
3436 
         *
3437 
         * @param callable $callback
3438 
         * @return void
3439 
         * @static
3440 
         */
3441 
        public static function assertBatched($callback)
3442 
        {
3443 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3444 
                        $instance->assertBatched($callback);
3445 
        }
3446 
                    /**
3447 
         * Assert the number of batches that have been dispatched.
3448 
         *
3449 
         * @param int $count
3450 
         * @return void
3451 
         * @static
3452 
         */
3453 
        public static function assertBatchCount($count)
3454 
        {
3455 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3456 
                        $instance->assertBatchCount($count);
3457 
        }
3458 
                    /**
3459 
         * Assert that no batched jobs were dispatched.
3460 
         *
3461 
         * @return void
3462 
         * @static
3463 
         */
3464 
        public static function assertNothingBatched()
3465 
        {
3466 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3467 
                        $instance->assertNothingBatched();
3468 
        }
3469 
                    /**
3470 
         * Get all of the jobs matching a truth-test callback.
3471 
         *
3472 
         * @param string $command
3473 
         * @param callable|null $callback
3474 
         * @return \Illuminate\Support\Collection
3475 
         * @static
3476 
         */
3477 
        public static function dispatched($command, $callback = null)
3478 
        {
3479 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3480 
                        return $instance->dispatched($command, $callback);
3481 
        }
3482 
                    /**
3483 
         * Get all of the jobs dispatched synchronously matching a truth-test callback.
3484 
         *
3485 
         * @param string $command
3486 
         * @param callable|null $callback
3487 
         * @return \Illuminate\Support\Collection
3488 
         * @static
3489 
         */
3490 
        public static function dispatchedSync($command, $callback = null)
3491 
        {
3492 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3493 
                        return $instance->dispatchedSync($command, $callback);
3494 
        }
3495 
                    /**
3496 
         * Get all of the jobs dispatched after the response was sent matching a truth-test callback.
3497 
         *
3498 
         * @param string $command
3499 
         * @param callable|null $callback
3500 
         * @return \Illuminate\Support\Collection
3501 
         * @static
3502 
         */
3503 
        public static function dispatchedAfterResponse($command, $callback = null)
3504 
        {
3505 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3506 
                        return $instance->dispatchedAfterResponse($command, $callback);
3507 
        }
3508 
                    /**
3509 
         * Get all of the pending batches matching a truth-test callback.
3510 
         *
3511 
         * @param callable $callback
3512 
         * @return \Illuminate\Support\Collection
3513 
         * @static
3514 
         */
3515 
        public static function batched($callback)
3516 
        {
3517 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3518 
                        return $instance->batched($callback);
3519 
        }
3520 
                    /**
3521 
         * Determine if there are any stored commands for a given class.
3522 
         *
3523 
         * @param string $command
3524 
         * @return bool
3525 
         * @static
3526 
         */
3527 
        public static function hasDispatched($command)
3528 
        {
3529 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3530 
                        return $instance->hasDispatched($command);
3531 
        }
3532 
                    /**
3533 
         * Determine if there are any stored commands for a given class.
3534 
         *
3535 
         * @param string $command
3536 
         * @return bool
3537 
         * @static
3538 
         */
3539 
        public static function hasDispatchedSync($command)
3540 
        {
3541 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3542 
                        return $instance->hasDispatchedSync($command);
3543 
        }
3544 
                    /**
3545 
         * Determine if there are any stored commands for a given class.
3546 
         *
3547 
         * @param string $command
3548 
         * @return bool
3549 
         * @static
3550 
         */
3551 
        public static function hasDispatchedAfterResponse($command)
3552 
        {
3553 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3554 
                        return $instance->hasDispatchedAfterResponse($command);
3555 
        }
3556 
                    /**
3557 
         * Dispatch an empty job batch for testing.
3558 
         *
3559 
         * @param string $name
3560 
         * @return \Illuminate\Bus\Batch
3561 
         * @static
3562 
         */
3563 
        public static function dispatchFakeBatch($name = '')
3564 
        {
3565 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3566 
                        return $instance->dispatchFakeBatch($name);
3567 
        }
3568 
                    /**
3569 
         * Record the fake pending batch dispatch.
3570 
         *
3571 
         * @param \Illuminate\Bus\PendingBatch $pendingBatch
3572 
         * @return \Illuminate\Bus\Batch
3573 
         * @static
3574 
         */
3575 
        public static function recordPendingBatch($pendingBatch)
3576 
        {
3577 
                        /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3578 
                        return $instance->recordPendingBatch($pendingBatch);
3579 
        }
3580 
 
3581 
    }
3582 
            /**
3583 
     *
3584 
     *
3585 
     * @see \Illuminate\Cache\CacheManager
3586 
     * @mixin \Illuminate\Cache\Repository
3587 
     */
3588 
        class Cache {
3589 
                    /**
3590 
         * Get a cache store instance by name, wrapped in a repository.
3591 
         *
3592 
         * @param string|null $name
3593 
         * @return \Illuminate\Contracts\Cache\Repository
3594 
         * @static
3595 
         */
3596 
        public static function store($name = null)
3597 
        {
3598 
                        /** @var \Illuminate\Cache\CacheManager $instance */
3599 
                        return $instance->store($name);
3600 
        }
3601 
                    /**
3602 
         * Get a cache driver instance.
3603 
         *
3604 
         * @param string|null $driver
3605 
         * @return \Illuminate\Contracts\Cache\Repository
3606 
         * @static
3607 
         */
3608 
        public static function driver($driver = null)
3609 
        {
3610 
                        /** @var \Illuminate\Cache\CacheManager $instance */
3611 
                        return $instance->driver($driver);
3612 
        }
3613 
                    /**
3614 
         * Create a new cache repository with the given implementation.
3615 
         *
3616 
         * @param \Illuminate\Contracts\Cache\Store $store
3617 
         * @return \Illuminate\Cache\Repository
3618 
         * @static
3619 
         */
3620 
        public static function repository($store)
3621 
        {
3622 
                        /** @var \Illuminate\Cache\CacheManager $instance */
3623 
                        return $instance->repository($store);
3624 
        }
3625 
                    /**
3626 
         * Re-set the event dispatcher on all resolved cache repositories.
3627 
         *
3628 
         * @return void
3629 
         * @static
3630 
         */
3631 
        public static function refreshEventDispatcher()
3632 
        {
3633 
                        /** @var \Illuminate\Cache\CacheManager $instance */
3634 
                        $instance->refreshEventDispatcher();
3635 
        }
3636 
                    /**
3637 
         * Get the default cache driver name.
3638 
         *
3639 
         * @return string
3640 
         * @static
3641 
         */
3642 
        public static function getDefaultDriver()
3643 
        {
3644 
                        /** @var \Illuminate\Cache\CacheManager $instance */
3645 
                        return $instance->getDefaultDriver();
3646 
        }
3647 
                    /**
3648 
         * Set the default cache driver name.
3649 
         *
3650 
         * @param string $name
3651 
         * @return void
3652 
         * @static
3653 
         */
3654 
        public static function setDefaultDriver($name)
3655 
        {
3656 
                        /** @var \Illuminate\Cache\CacheManager $instance */
3657 
                        $instance->setDefaultDriver($name);
3658 
        }
3659 
                    /**
3660 
         * Unset the given driver instances.
3661 
         *
3662 
         * @param array|string|null $name
3663 
         * @return \Illuminate\Cache\CacheManager
3664 
         * @static
3665 
         */
3666 
        public static function forgetDriver($name = null)
3667 
        {
3668 
                        /** @var \Illuminate\Cache\CacheManager $instance */
3669 
                        return $instance->forgetDriver($name);
3670 
        }
3671 
                    /**
3672 
         * Disconnect the given driver and remove from local cache.
3673 
         *
3674 
         * @param string|null $name
3675 
         * @return void
3676 
         * @static
3677 
         */
3678 
        public static function purge($name = null)
3679 
        {
3680 
                        /** @var \Illuminate\Cache\CacheManager $instance */
3681 
                        $instance->purge($name);
3682 
        }
3683 
                    /**
3684 
         * Register a custom driver creator Closure.
3685 
         *
3686 
         * @param string $driver
3687 
         * @param \Closure $callback
3688 
         * @return \Illuminate\Cache\CacheManager
3689 
         * @static
3690 
         */
3691 
        public static function extend($driver, $callback)
3692 
        {
3693 
                        /** @var \Illuminate\Cache\CacheManager $instance */
3694 
                        return $instance->extend($driver, $callback);
3695 
        }
3696 
                    /**
3697 
         * Determine if an item exists in the cache.
3698 
         *
3699 
         * @param array|string $key
3700 
         * @return bool
3701 
         * @static
3702 
         */
3703 
        public static function has($key)
3704 
        {
3705 
                        /** @var \Illuminate\Cache\Repository $instance */
3706 
                        return $instance->has($key);
3707 
        }
3708 
                    /**
3709 
         * Determine if an item doesn't exist in the cache.
3710 
         *
3711 
         * @param string $key
3712 
         * @return bool
3713 
         * @static
3714 
         */
3715 
        public static function missing($key)
3716 
        {
3717 
                        /** @var \Illuminate\Cache\Repository $instance */
3718 
                        return $instance->missing($key);
3719 
        }
3720 
                    /**
3721 
         * Retrieve an item from the cache by key.
3722 
         *
3723 
         * @template TCacheValue
3724 
         * @param array|string $key
3725 
         * @param \Illuminate\Cache\TCacheValue|\Illuminate\Cache\(\Closure():  TCacheValue)  $default
3726 
         * @return \Illuminate\Cache\(TCacheValue is null ? mixed : TCacheValue)
3727 
         * @static
3728 
         */
3729 
        public static function get($key, $default = null)
3730 
        {
3731 
                        /** @var \Illuminate\Cache\Repository $instance */
3732 
                        return $instance->get($key, $default);
3733 
        }
3734 
                    /**
3735 
         * Retrieve multiple items from the cache by key.
3736 
         *
3737 
         * Items not found in the cache will have a null value.
3738 
         *
3739 
         * @param array $keys
3740 
         * @return array
3741 
         * @static
3742 
         */
3743 
        public static function many($keys)
3744 
        {
3745 
                        /** @var \Illuminate\Cache\Repository $instance */
3746 
                        return $instance->many($keys);
3747 
        }
3748 
                    /**
3749 
         * Obtains multiple cache items by their unique keys.
3750 
         *
3751 
         * @return \Illuminate\Cache\iterable
3752 
         * @param \Psr\SimpleCache\iterable<string> $keys A list of keys that can be obtained in a single operation.
3753 
         * @param mixed $default Default value to return for keys that do not exist.
3754 
         * @return \Psr\SimpleCache\iterable<string, mixed> A list of key => value pairs. Cache keys that do not exist or are stale will have $default as value.
3755 
         * @throws \Psr\SimpleCache\InvalidArgumentException
3756 
         *   MUST be thrown if $keys is neither an array nor a Traversable,
3757 
         *   or if any of the $keys are not a legal value.
3758 
         * @static
3759 
         */
3760 
        public static function getMultiple($keys, $default = null)
3761 
        {
3762 
                        /** @var \Illuminate\Cache\Repository $instance */
3763 
                        return $instance->getMultiple($keys, $default);
3764 
        }
3765 
                    /**
3766 
         * Retrieve an item from the cache and delete it.
3767 
         *
3768 
         * @template TCacheValue
3769 
         * @param array|string $key
3770 
         * @param \Illuminate\Cache\TCacheValue|\Illuminate\Cache\(\Closure():  TCacheValue)  $default
3771 
         * @return \Illuminate\Cache\(TCacheValue is null ? mixed : TCacheValue)
3772 
         * @static
3773 
         */
3774 
        public static function pull($key, $default = null)
3775 
        {
3776 
                        /** @var \Illuminate\Cache\Repository $instance */
3777 
                        return $instance->pull($key, $default);
3778 
        }
3779 
                    /**
3780 
         * Store an item in the cache.
3781 
         *
3782 
         * @param array|string $key
3783 
         * @param mixed $value
3784 
         * @param \DateTimeInterface|\DateInterval|int|null $ttl
3785 
         * @return bool
3786 
         * @static
3787 
         */
3788 
        public static function put($key, $value, $ttl = null)
3789 
        {
3790 
                        /** @var \Illuminate\Cache\Repository $instance */
3791 
                        return $instance->put($key, $value, $ttl);
3792 
        }
3793 
                    /**
3794 
         * Persists data in the cache, uniquely referenced by a key with an optional expiration TTL time.
3795 
         *
3796 
         * @return bool
3797 
         * @param string $key The key of the item to store.
3798 
         * @param mixed $value The value of the item to store, must be serializable.
3799 
         * @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and
3800 
         *                                      the driver supports TTL then the library may set a default value
3801 
         *                                      for it or let the driver take care of that.
3802 
         * @return bool True on success and false on failure.
3803 
         * @throws \Psr\SimpleCache\InvalidArgumentException
3804 
         *   MUST be thrown if the $key string is not a legal value.
3805 
         * @static
3806 
         */
3807 
        public static function set($key, $value, $ttl = null)
3808 
        {
3809 
                        /** @var \Illuminate\Cache\Repository $instance */
3810 
                        return $instance->set($key, $value, $ttl);
3811 
        }
3812 
                    /**
3813 
         * Store multiple items in the cache for a given number of seconds.
3814 
         *
3815 
         * @param array $values
3816 
         * @param \DateTimeInterface|\DateInterval|int|null $ttl
3817 
         * @return bool
3818 
         * @static
3819 
         */
3820 
        public static function putMany($values, $ttl = null)
3821 
        {
3822 
                        /** @var \Illuminate\Cache\Repository $instance */
3823 
                        return $instance->putMany($values, $ttl);
3824 
        }
3825 
                    /**
3826 
         * Persists a set of key => value pairs in the cache, with an optional TTL.
3827 
         *
3828 
         * @return bool
3829 
         * @param \Psr\SimpleCache\iterable $values A list of key => value pairs for a multiple-set operation.
3830 
         * @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and
3831 
         *                                       the driver supports TTL then the library may set a default value
3832 
         *                                       for it or let the driver take care of that.
3833 
         * @return bool True on success and false on failure.
3834 
         * @throws \Psr\SimpleCache\InvalidArgumentException
3835 
         *   MUST be thrown if $values is neither an array nor a Traversable,
3836 
         *   or if any of the $values are not a legal value.
3837 
         * @static
3838 
         */
3839 
        public static function setMultiple($values, $ttl = null)
3840 
        {
3841 
                        /** @var \Illuminate\Cache\Repository $instance */
3842 
                        return $instance->setMultiple($values, $ttl);
3843 
        }
3844 
                    /**
3845 
         * Store an item in the cache if the key does not exist.
3846 
         *
3847 
         * @param string $key
3848 
         * @param mixed $value
3849 
         * @param \DateTimeInterface|\DateInterval|int|null $ttl
3850 
         * @return bool
3851 
         * @static
3852 
         */
3853 
        public static function add($key, $value, $ttl = null)
3854 
        {
3855 
                        /** @var \Illuminate\Cache\Repository $instance */
3856 
                        return $instance->add($key, $value, $ttl);
3857 
        }
3858 
                    /**
3859 
         * Increment the value of an item in the cache.
3860 
         *
3861 
         * @param string $key
3862 
         * @param mixed $value
3863 
         * @return int|bool
3864 
         * @static
3865 
         */
3866 
        public static function increment($key, $value = 1)
3867 
        {
3868 
                        /** @var \Illuminate\Cache\Repository $instance */
3869 
                        return $instance->increment($key, $value);
3870 
        }
3871 
                    /**
3872 
         * Decrement the value of an item in the cache.
3873 
         *
3874 
         * @param string $key
3875 
         * @param mixed $value
3876 
         * @return int|bool
3877 
         * @static
3878 
         */
3879 
        public static function decrement($key, $value = 1)
3880 
        {
3881 
                        /** @var \Illuminate\Cache\Repository $instance */
3882 
                        return $instance->decrement($key, $value);
3883 
        }
3884 
                    /**
3885 
         * Store an item in the cache indefinitely.
3886 
         *
3887 
         * @param string $key
3888 
         * @param mixed $value
3889 
         * @return bool
3890 
         * @static
3891 
         */
3892 
        public static function forever($key, $value)
3893 
        {
3894 
                        /** @var \Illuminate\Cache\Repository $instance */
3895 
                        return $instance->forever($key, $value);
3896 
        }
3897 
                    /**
3898 
         * Get an item from the cache, or execute the given Closure and store the result.
3899 
         *
3900 
         * @template TCacheValue
3901 
         * @param string $key
3902 
         * @param \Closure|\DateTimeInterface|\DateInterval|int|null $ttl
3903 
         * @param \Closure():  TCacheValue  $callback
3904 
         * @return \Illuminate\Cache\TCacheValue
3905 
         * @static
3906 
         */
3907 
        public static function remember($key, $ttl, $callback)
3908 
        {
3909 
                        /** @var \Illuminate\Cache\Repository $instance */
3910 
                        return $instance->remember($key, $ttl, $callback);
3911 
        }
3912 
                    /**
3913 
         * Get an item from the cache, or execute the given Closure and store the result forever.
3914 
         *
3915 
         * @template TCacheValue
3916 
         * @param string $key
3917 
         * @param \Closure():  TCacheValue  $callback
3918 
         * @return \Illuminate\Cache\TCacheValue
3919 
         * @static
3920 
         */
3921 
        public static function sear($key, $callback)
3922 
        {
3923 
                        /** @var \Illuminate\Cache\Repository $instance */
3924 
                        return $instance->sear($key, $callback);
3925 
        }
3926 
                    /**
3927 
         * Get an item from the cache, or execute the given Closure and store the result forever.
3928 
         *
3929 
         * @template TCacheValue
3930 
         * @param string $key
3931 
         * @param \Closure():  TCacheValue  $callback
3932 
         * @return \Illuminate\Cache\TCacheValue
3933 
         * @static
3934 
         */
3935 
        public static function rememberForever($key, $callback)
3936 
        {
3937 
                        /** @var \Illuminate\Cache\Repository $instance */
3938 
                        return $instance->rememberForever($key, $callback);
3939 
        }
3940 
                    /**
3941 
         * Remove an item from the cache.
3942 
         *
3943 
         * @param string $key
3944 
         * @return bool
3945 
         * @static
3946 
         */
3947 
        public static function forget($key)
3948 
        {
3949 
                        /** @var \Illuminate\Cache\Repository $instance */
3950 
                        return $instance->forget($key);
3951 
        }
3952 
                    /**
3953 
         * Delete an item from the cache by its unique key.
3954 
         *
3955 
         * @return bool
3956 
         * @param string $key The unique cache key of the item to delete.
3957 
         * @return bool True if the item was successfully removed. False if there was an error.
3958 
         * @throws \Psr\SimpleCache\InvalidArgumentException
3959 
         *   MUST be thrown if the $key string is not a legal value.
3960 
         * @static
3961 
         */
3962 
        public static function delete($key)
3963 
        {
3964 
                        /** @var \Illuminate\Cache\Repository $instance */
3965 
                        return $instance->delete($key);
3966 
        }
3967 
                    /**
3968 
         * Deletes multiple cache items in a single operation.
3969 
         *
3970 
         * @return bool
3971 
         * @param \Psr\SimpleCache\iterable<string> $keys A list of string-based keys to be deleted.
3972 
         * @return bool True if the items were successfully removed. False if there was an error.
3973 
         * @throws \Psr\SimpleCache\InvalidArgumentException
3974 
         *   MUST be thrown if $keys is neither an array nor a Traversable,
3975 
         *   or if any of the $keys are not a legal value.
3976 
         * @static
3977 
         */
3978 
        public static function deleteMultiple($keys)
3979 
        {
3980 
                        /** @var \Illuminate\Cache\Repository $instance */
3981 
                        return $instance->deleteMultiple($keys);
3982 
        }
3983 
                    /**
3984 
         * Wipes clean the entire cache's keys.
3985 
         *
3986 
         * @return bool
3987 
         * @return bool True on success and false on failure.
3988 
         * @static
3989 
         */
3990 
        public static function clear()
3991 
        {
3992 
                        /** @var \Illuminate\Cache\Repository $instance */
3993 
                        return $instance->clear();
3994 
        }
3995 
                    /**
3996 
         * Begin executing a new tags operation if the store supports it.
3997 
         *
3998 
         * @param array|mixed $names
3999 
         * @return \Illuminate\Cache\TaggedCache
4000 
         * @throws \BadMethodCallException
4001 
         * @static
4002 
         */
4003 
        public static function tags($names)
4004 
        {
4005 
                        /** @var \Illuminate\Cache\Repository $instance */
4006 
                        return $instance->tags($names);
4007 
        }
4008 
                    /**
4009 
         * Determine if the current store supports tags.
4010 
         *
4011 
         * @return bool
4012 
         * @static
4013 
         */
4014 
        public static function supportsTags()
4015 
        {
4016 
                        /** @var \Illuminate\Cache\Repository $instance */
4017 
                        return $instance->supportsTags();
4018 
        }
4019 
                    /**
4020 
         * Get the default cache time.
4021 
         *
4022 
         * @return int|null
4023 
         * @static
4024 
         */
4025 
        public static function getDefaultCacheTime()
4026 
        {
4027 
                        /** @var \Illuminate\Cache\Repository $instance */
4028 
                        return $instance->getDefaultCacheTime();
4029 
        }
4030 
                    /**
4031 
         * Set the default cache time in seconds.
4032 
         *
4033 
         * @param int|null $seconds
4034 
         * @return \Illuminate\Cache\Repository
4035 
         * @static
4036 
         */
4037 
        public static function setDefaultCacheTime($seconds)
4038 
        {
4039 
                        /** @var \Illuminate\Cache\Repository $instance */
4040 
                        return $instance->setDefaultCacheTime($seconds);
4041 
        }
4042 
                    /**
4043 
         * Get the cache store implementation.
4044 
         *
4045 
         * @return \Illuminate\Contracts\Cache\Store
4046 
         * @static
4047 
         */
4048 
        public static function getStore()
4049 
        {
4050 
                        /** @var \Illuminate\Cache\Repository $instance */
4051 
                        return $instance->getStore();
4052 
        }
4053 
                    /**
4054 
         * Get the event dispatcher instance.
4055 
         *
4056 
         * @return \Illuminate\Contracts\Events\Dispatcher
4057 
         * @static
4058 
         */
4059 
        public static function getEventDispatcher()
4060 
        {
4061 
                        /** @var \Illuminate\Cache\Repository $instance */
4062 
                        return $instance->getEventDispatcher();
4063 
        }
4064 
                    /**
4065 
         * Set the event dispatcher instance.
4066 
         *
4067 
         * @param \Illuminate\Contracts\Events\Dispatcher $events
4068 
         * @return void
4069 
         * @static
4070 
         */
4071 
        public static function setEventDispatcher($events)
4072 
        {
4073 
                        /** @var \Illuminate\Cache\Repository $instance */
4074 
                        $instance->setEventDispatcher($events);
4075 
        }
4076 
                    /**
4077 
         * Determine if a cached value exists.
4078 
         *
4079 
         * @param string $key
4080 
         * @return bool
4081 
         * @static
4082 
         */
4083 
        public static function offsetExists($key)
4084 
        {
4085 
                        /** @var \Illuminate\Cache\Repository $instance */
4086 
                        return $instance->offsetExists($key);
4087 
        }
4088 
                    /**
4089 
         * Retrieve an item from the cache by key.
4090 
         *
4091 
         * @param string $key
4092 
         * @return mixed
4093 
         * @static
4094 
         */
4095 
        public static function offsetGet($key)
4096 
        {
4097 
                        /** @var \Illuminate\Cache\Repository $instance */
4098 
                        return $instance->offsetGet($key);
4099 
        }
4100 
                    /**
4101 
         * Store an item in the cache for the default time.
4102 
         *
4103 
         * @param string $key
4104 
         * @param mixed $value
4105 
         * @return void
4106 
         * @static
4107 
         */
4108 
        public static function offsetSet($key, $value)
4109 
        {
4110 
                        /** @var \Illuminate\Cache\Repository $instance */
4111 
                        $instance->offsetSet($key, $value);
4112 
        }
4113 
                    /**
4114 
         * Remove an item from the cache.
4115 
         *
4116 
         * @param string $key
4117 
         * @return void
4118 
         * @static
4119 
         */
4120 
        public static function offsetUnset($key)
4121 
        {
4122 
                        /** @var \Illuminate\Cache\Repository $instance */
4123 
                        $instance->offsetUnset($key);
4124 
        }
4125 
                    /**
4126 
         * Register a custom macro.
4127 
         *
4128 
         * @param string $name
4129 
         * @param object|callable $macro
4130 
         * @return void
4131 
         * @static
4132 
         */
4133 
        public static function macro($name, $macro)
4134 
        {
4135 
                        \Illuminate\Cache\Repository::macro($name, $macro);
4136 
        }
4137 
                    /**
4138 
         * Mix another object into the class.
4139 
         *
4140 
         * @param object $mixin
4141 
         * @param bool $replace
4142 
         * @return void
4143 
         * @throws \ReflectionException
4144 
         * @static
4145 
         */
4146 
        public static function mixin($mixin, $replace = true)
4147 
        {
4148 
                        \Illuminate\Cache\Repository::mixin($mixin, $replace);
4149 
        }
4150 
                    /**
4151 
         * Checks if macro is registered.
4152 
         *
4153 
         * @param string $name
4154 
         * @return bool
4155 
         * @static
4156 
         */
4157 
        public static function hasMacro($name)
4158 
        {
4159 
                        return \Illuminate\Cache\Repository::hasMacro($name);
4160 
        }
4161 
                    /**
4162 
         * Flush the existing macros.
4163 
         *
4164 
         * @return void
4165 
         * @static
4166 
         */
4167 
        public static function flushMacros()
4168 
        {
4169 
                        \Illuminate\Cache\Repository::flushMacros();
4170 
        }
4171 
                    /**
4172 
         * Dynamically handle calls to the class.
4173 
         *
4174 
         * @param string $method
4175 
         * @param array $parameters
4176 
         * @return mixed
4177 
         * @throws \BadMethodCallException
4178 
         * @static
4179 
         */
4180 
        public static function macroCall($method, $parameters)
4181 
        {
4182 
                        /** @var \Illuminate\Cache\Repository $instance */
4183 
                        return $instance->macroCall($method, $parameters);
4184 
        }
4185 
                    /**
4186 
         * Get a lock instance.
4187 
         *
4188 
         * @param string $name
4189 
         * @param int $seconds
4190 
         * @param string|null $owner
4191 
         * @return \Illuminate\Contracts\Cache\Lock
4192 
         * @static
4193 
         */
4194 
        public static function lock($name, $seconds = 0, $owner = null)
4195 
        {
4196 
                        /** @var \Illuminate\Cache\FileStore $instance */
4197 
                        return $instance->lock($name, $seconds, $owner);
4198 
        }
4199 
                    /**
4200 
         * Restore a lock instance using the owner identifier.
4201 
         *
4202 
         * @param string $name
4203 
         * @param string $owner
4204 
         * @return \Illuminate\Contracts\Cache\Lock
4205 
         * @static
4206 
         */
4207 
        public static function restoreLock($name, $owner)
4208 
        {
4209 
                        /** @var \Illuminate\Cache\FileStore $instance */
4210 
                        return $instance->restoreLock($name, $owner);
4211 
        }
4212 
                    /**
4213 
         * Remove all items from the cache.
4214 
         *
4215 
         * @return bool
4216 
         * @static
4217 
         */
4218 
        public static function flush()
4219 
        {
4220 
                        /** @var \Illuminate\Cache\FileStore $instance */
4221 
                        return $instance->flush();
4222 
        }
4223 
                    /**
4224 
         * Get the Filesystem instance.
4225 
         *
4226 
         * @return \Illuminate\Filesystem\Filesystem
4227 
         * @static
4228 
         */
4229 
        public static function getFilesystem()
4230 
        {
4231 
                        /** @var \Illuminate\Cache\FileStore $instance */
4232 
                        return $instance->getFilesystem();
4233 
        }
4234 
                    /**
4235 
         * Get the working directory of the cache.
4236 
         *
4237 
         * @return string
4238 
         * @static
4239 
         */
4240 
        public static function getDirectory()
4241 
        {
4242 
                        /** @var \Illuminate\Cache\FileStore $instance */
4243 
                        return $instance->getDirectory();
4244 
        }
4245 
                    /**
4246 
         * Get the cache key prefix.
4247 
         *
4248 
         * @return string
4249 
         * @static
4250 
         */
4251 
        public static function getPrefix()
4252 
        {
4253 
                        /** @var \Illuminate\Cache\FileStore $instance */
4254 
                        return $instance->getPrefix();
4255 
        }
4256 
 
4257 
    }
4258 
            /**
4259 
     *
4260 
     *
4261 
     * @see \Illuminate\Config\Repository
4262 
     */
4263 
        class Config {
4264 
                    /**
4265 
         * Determine if the given configuration value exists.
4266 
         *
4267 
         * @param string $key
4268 
         * @return bool
4269 
         * @static
4270 
         */
4271 
        public static function has($key)
4272 
        {
4273 
                        /** @var \Illuminate\Config\Repository $instance */
4274 
                        return $instance->has($key);
4275 
        }
4276 
                    /**
4277 
         * Get the specified configuration value.
4278 
         *
4279 
         * @param array|string $key
4280 
         * @param mixed $default
4281 
         * @return mixed
4282 
         * @static
4283 
         */
4284 
        public static function get($key, $default = null)
4285 
        {
4286 
                        /** @var \Illuminate\Config\Repository $instance */
4287 
                        return $instance->get($key, $default);
4288 
        }
4289 
                    /**
4290 
         * Get many configuration values.
4291 
         *
4292 
         * @param array $keys
4293 
         * @return array
4294 
         * @static
4295 
         */
4296 
        public static function getMany($keys)
4297 
        {
4298 
                        /** @var \Illuminate\Config\Repository $instance */
4299 
                        return $instance->getMany($keys);
4300 
        }
4301 
                    /**
4302 
         * Set a given configuration value.
4303 
         *
4304 
         * @param array|string $key
4305 
         * @param mixed $value
4306 
         * @return void
4307 
         * @static
4308 
         */
4309 
        public static function set($key, $value = null)
4310 
        {
4311 
                        /** @var \Illuminate\Config\Repository $instance */
4312 
                        $instance->set($key, $value);
4313 
        }
4314 
                    /**
4315 
         * Prepend a value onto an array configuration value.
4316 
         *
4317 
         * @param string $key
4318 
         * @param mixed $value
4319 
         * @return void
4320 
         * @static
4321 
         */
4322 
        public static function prepend($key, $value)
4323 
        {
4324 
                        /** @var \Illuminate\Config\Repository $instance */
4325 
                        $instance->prepend($key, $value);
4326 
        }
4327 
                    /**
4328 
         * Push a value onto an array configuration value.
4329 
         *
4330 
         * @param string $key
4331 
         * @param mixed $value
4332 
         * @return void
4333 
         * @static
4334 
         */
4335 
        public static function push($key, $value)
4336 
        {
4337 
                        /** @var \Illuminate\Config\Repository $instance */
4338 
                        $instance->push($key, $value);
4339 
        }
4340 
                    /**
4341 
         * Get all of the configuration items for the application.
4342 
         *
4343 
         * @return array
4344 
         * @static
4345 
         */
4346 
        public static function all()
4347 
        {
4348 
                        /** @var \Illuminate\Config\Repository $instance */
4349 
                        return $instance->all();
4350 
        }
4351 
                    /**
4352 
         * Determine if the given configuration option exists.
4353 
         *
4354 
         * @param string $key
4355 
         * @return bool
4356 
         * @static
4357 
         */
4358 
        public static function offsetExists($key)
4359 
        {
4360 
                        /** @var \Illuminate\Config\Repository $instance */
4361 
                        return $instance->offsetExists($key);
4362 
        }
4363 
                    /**
4364 
         * Get a configuration option.
4365 
         *
4366 
         * @param string $key
4367 
         * @return mixed
4368 
         * @static
4369 
         */
4370 
        public static function offsetGet($key)
4371 
        {
4372 
                        /** @var \Illuminate\Config\Repository $instance */
4373 
                        return $instance->offsetGet($key);
4374 
        }
4375 
                    /**
4376 
         * Set a configuration option.
4377 
         *
4378 
         * @param string $key
4379 
         * @param mixed $value
4380 
         * @return void
4381 
         * @static
4382 
         */
4383 
        public static function offsetSet($key, $value)
4384 
        {
4385 
                        /** @var \Illuminate\Config\Repository $instance */
4386 
                        $instance->offsetSet($key, $value);
4387 
        }
4388 
                    /**
4389 
         * Unset a configuration option.
4390 
         *
4391 
         * @param string $key
4392 
         * @return void
4393 
         * @static
4394 
         */
4395 
        public static function offsetUnset($key)
4396 
        {
4397 
                        /** @var \Illuminate\Config\Repository $instance */
4398 
                        $instance->offsetUnset($key);
4399 
        }
4400 
                    /**
4401 
         * Register a custom macro.
4402 
         *
4403 
         * @param string $name
4404 
         * @param object|callable $macro
4405 
         * @return void
4406 
         * @static
4407 
         */
4408 
        public static function macro($name, $macro)
4409 
        {
4410 
                        \Illuminate\Config\Repository::macro($name, $macro);
4411 
        }
4412 
                    /**
4413 
         * Mix another object into the class.
4414 
         *
4415 
         * @param object $mixin
4416 
         * @param bool $replace
4417 
         * @return void
4418 
         * @throws \ReflectionException
4419 
         * @static
4420 
         */
4421 
        public static function mixin($mixin, $replace = true)
4422 
        {
4423 
                        \Illuminate\Config\Repository::mixin($mixin, $replace);
4424 
        }
4425 
                    /**
4426 
         * Checks if macro is registered.
4427 
         *
4428 
         * @param string $name
4429 
         * @return bool
4430 
         * @static
4431 
         */
4432 
        public static function hasMacro($name)
4433 
        {
4434 
                        return \Illuminate\Config\Repository::hasMacro($name);
4435 
        }
4436 
                    /**
4437 
         * Flush the existing macros.
4438 
         *
4439 
         * @return void
4440 
         * @static
4441 
         */
4442 
        public static function flushMacros()
4443 
        {
4444 
                        \Illuminate\Config\Repository::flushMacros();
4445 
        }
4446 
 
4447 
    }
4448 
            /**
4449 
     *
4450 
     *
4451 
     * @see \Illuminate\Cookie\CookieJar
4452 
     */
4453 
        class Cookie {
4454 
                    /**
4455 
         * Create a new cookie instance.
4456 
         *
4457 
         * @param string $name
4458 
         * @param string $value
4459 
         * @param int $minutes
4460 
         * @param string|null $path
4461 
         * @param string|null $domain
4462 
         * @param bool|null $secure
4463 
         * @param bool $httpOnly
4464 
         * @param bool $raw
4465 
         * @param string|null $sameSite
4466 
         * @return \Symfony\Component\HttpFoundation\Cookie
4467 
         * @static
4468 
         */
4469 
        public static function make($name, $value, $minutes = 0, $path = null, $domain = null, $secure = null, $httpOnly = true, $raw = false, $sameSite = null)
4470 
        {
4471 
                        /** @var \Illuminate\Cookie\CookieJar $instance */
4472 
                        return $instance->make($name, $value, $minutes, $path, $domain, $secure, $httpOnly, $raw, $sameSite);
4473 
        }
4474 
                    /**
4475 
         * Create a cookie that lasts "forever" (400 days).
4476 
         *
4477 
         * @param string $name
4478 
         * @param string $value
4479 
         * @param string|null $path
4480 
         * @param string|null $domain
4481 
         * @param bool|null $secure
4482 
         * @param bool $httpOnly
4483 
         * @param bool $raw
4484 
         * @param string|null $sameSite
4485 
         * @return \Symfony\Component\HttpFoundation\Cookie
4486 
         * @static
4487 
         */
4488 
        public static function forever($name, $value, $path = null, $domain = null, $secure = null, $httpOnly = true, $raw = false, $sameSite = null)
4489 
        {
4490 
                        /** @var \Illuminate\Cookie\CookieJar $instance */
4491 
                        return $instance->forever($name, $value, $path, $domain, $secure, $httpOnly, $raw, $sameSite);
4492 
        }
4493 
                    /**
4494 
         * Expire the given cookie.
4495 
         *
4496 
         * @param string $name
4497 
         * @param string|null $path
4498 
         * @param string|null $domain
4499 
         * @return \Symfony\Component\HttpFoundation\Cookie
4500 
         * @static
4501 
         */
4502 
        public static function forget($name, $path = null, $domain = null)
4503 
        {
4504 
                        /** @var \Illuminate\Cookie\CookieJar $instance */
4505 
                        return $instance->forget($name, $path, $domain);
4506 
        }
4507 
                    /**
4508 
         * Determine if a cookie has been queued.
4509 
         *
4510 
         * @param string $key
4511 
         * @param string|null $path
4512 
         * @return bool
4513 
         * @static
4514 
         */
4515 
        public static function hasQueued($key, $path = null)
4516 
        {
4517 
                        /** @var \Illuminate\Cookie\CookieJar $instance */
4518 
                        return $instance->hasQueued($key, $path);
4519 
        }
4520 
                    /**
4521 
         * Get a queued cookie instance.
4522 
         *
4523 
         * @param string $key
4524 
         * @param mixed $default
4525 
         * @param string|null $path
4526 
         * @return \Symfony\Component\HttpFoundation\Cookie|null
4527 
         * @static
4528 
         */
4529 
        public static function queued($key, $default = null, $path = null)
4530 
        {
4531 
                        /** @var \Illuminate\Cookie\CookieJar $instance */
4532 
                        return $instance->queued($key, $default, $path);
4533 
        }
4534 
                    /**
4535 
         * Queue a cookie to send with the next response.
4536 
         *
4537 
         * @param mixed $parameters
4538 
         * @return void
4539 
         * @static
4540 
         */
4541 
        public static function queue(...$parameters)
4542 
        {
4543 
                        /** @var \Illuminate\Cookie\CookieJar $instance */
4544 
                        $instance->queue(...$parameters);
4545 
        }
4546 
                    /**
4547 
         * Queue a cookie to expire with the next response.
4548 
         *
4549 
         * @param string $name
4550 
         * @param string|null $path
4551 
         * @param string|null $domain
4552 
         * @return void
4553 
         * @static
4554 
         */
4555 
        public static function expire($name, $path = null, $domain = null)
4556 
        {
4557 
                        /** @var \Illuminate\Cookie\CookieJar $instance */
4558 
                        $instance->expire($name, $path, $domain);
4559 
        }
4560 
                    /**
4561 
         * Remove a cookie from the queue.
4562 
         *
4563 
         * @param string $name
4564 
         * @param string|null $path
4565 
         * @return void
4566 
         * @static
4567 
         */
4568 
        public static function unqueue($name, $path = null)
4569 
        {
4570 
                        /** @var \Illuminate\Cookie\CookieJar $instance */
4571 
                        $instance->unqueue($name, $path);
4572 
        }
4573 
                    /**
4574 
         * Set the default path and domain for the jar.
4575 
         *
4576 
         * @param string $path
4577 
         * @param string|null $domain
4578 
         * @param bool|null $secure
4579 
         * @param string|null $sameSite
4580 
         * @return \Illuminate\Cookie\CookieJar
4581 
         * @static
4582 
         */
4583 
        public static function setDefaultPathAndDomain($path, $domain, $secure = false, $sameSite = null)
4584 
        {
4585 
                        /** @var \Illuminate\Cookie\CookieJar $instance */
4586 
                        return $instance->setDefaultPathAndDomain($path, $domain, $secure, $sameSite);
4587 
        }
4588 
                    /**
4589 
         * Get the cookies which have been queued for the next request.
4590 
         *
4591 
         * @return \Symfony\Component\HttpFoundation\Cookie[]
4592 
         * @static
4593 
         */
4594 
        public static function getQueuedCookies()
4595 
        {
4596 
                        /** @var \Illuminate\Cookie\CookieJar $instance */
4597 
                        return $instance->getQueuedCookies();
4598 
        }
4599 
                    /**
4600 
         * Flush the cookies which have been queued for the next request.
4601 
         *
4602 
         * @return \Illuminate\Cookie\CookieJar
4603 
         * @static
4604 
         */
4605 
        public static function flushQueuedCookies()
4606 
        {
4607 
                        /** @var \Illuminate\Cookie\CookieJar $instance */
4608 
                        return $instance->flushQueuedCookies();
4609 
        }
4610 
                    /**
4611 
         * Register a custom macro.
4612 
         *
4613 
         * @param string $name
4614 
         * @param object|callable $macro
4615 
         * @return void
4616 
         * @static
4617 
         */
4618 
        public static function macro($name, $macro)
4619 
        {
4620 
                        \Illuminate\Cookie\CookieJar::macro($name, $macro);
4621 
        }
4622 
                    /**
4623 
         * Mix another object into the class.
4624 
         *
4625 
         * @param object $mixin
4626 
         * @param bool $replace
4627 
         * @return void
4628 
         * @throws \ReflectionException
4629 
         * @static
4630 
         */
4631 
        public static function mixin($mixin, $replace = true)
4632 
        {
4633 
                        \Illuminate\Cookie\CookieJar::mixin($mixin, $replace);
4634 
        }
4635 
                    /**
4636 
         * Checks if macro is registered.
4637 
         *
4638 
         * @param string $name
4639 
         * @return bool
4640 
         * @static
4641 
         */
4642 
        public static function hasMacro($name)
4643 
        {
4644 
                        return \Illuminate\Cookie\CookieJar::hasMacro($name);
4645 
        }
4646 
                    /**
4647 
         * Flush the existing macros.
4648 
         *
4649 
         * @return void
4650 
         * @static
4651 
         */
4652 
        public static function flushMacros()
4653 
        {
4654 
                        \Illuminate\Cookie\CookieJar::flushMacros();
4655 
        }
4656 
 
4657 
    }
4658 
            /**
4659 
     *
4660 
     *
4661 
     * @see \Illuminate\Encryption\Encrypter
4662 
     */
4663 
        class Crypt {
4664 
                    /**
4665 
         * Determine if the given key and cipher combination is valid.
4666 
         *
4667 
         * @param string $key
4668 
         * @param string $cipher
4669 
         * @return bool
4670 
         * @static
4671 
         */
4672 
        public static function supported($key, $cipher)
4673 
        {
4674 
                        return \Illuminate\Encryption\Encrypter::supported($key, $cipher);
4675 
        }
4676 
                    /**
4677 
         * Create a new encryption key for the given cipher.
4678 
         *
4679 
         * @param string $cipher
4680 
         * @return string
4681 
         * @static
4682 
         */
4683 
        public static function generateKey($cipher)
4684 
        {
4685 
                        return \Illuminate\Encryption\Encrypter::generateKey($cipher);
4686 
        }
4687 
                    /**
4688 
         * Encrypt the given value.
4689 
         *
4690 
         * @param mixed $value
4691 
         * @param bool $serialize
4692 
         * @return string
4693 
         * @throws \Illuminate\Contracts\Encryption\EncryptException
4694 
         * @static
4695 
         */
4696 
        public static function encrypt($value, $serialize = true)
4697 
        {
4698 
                        /** @var \Illuminate\Encryption\Encrypter $instance */
4699 
                        return $instance->encrypt($value, $serialize);
4700 
        }
4701 
                    /**
4702 
         * Encrypt a string without serialization.
4703 
         *
4704 
         * @param string $value
4705 
         * @return string
4706 
         * @throws \Illuminate\Contracts\Encryption\EncryptException
4707 
         * @static
4708 
         */
4709 
        public static function encryptString($value)
4710 
        {
4711 
                        /** @var \Illuminate\Encryption\Encrypter $instance */
4712 
                        return $instance->encryptString($value);
4713 
        }
4714 
                    /**
4715 
         * Decrypt the given value.
4716 
         *
4717 
         * @param string $payload
4718 
         * @param bool $unserialize
4719 
         * @return mixed
4720 
         * @throws \Illuminate\Contracts\Encryption\DecryptException
4721 
         * @static
4722 
         */
4723 
        public static function decrypt($payload, $unserialize = true)
4724 
        {
4725 
                        /** @var \Illuminate\Encryption\Encrypter $instance */
4726 
                        return $instance->decrypt($payload, $unserialize);
4727 
        }
4728 
                    /**
4729 
         * Decrypt the given string without unserialization.
4730 
         *
4731 
         * @param string $payload
4732 
         * @return string
4733 
         * @throws \Illuminate\Contracts\Encryption\DecryptException
4734 
         * @static
4735 
         */
4736 
        public static function decryptString($payload)
4737 
        {
4738 
                        /** @var \Illuminate\Encryption\Encrypter $instance */
4739 
                        return $instance->decryptString($payload);
4740 
        }
4741 
                    /**
4742 
         * Get the encryption key that the encrypter is currently using.
4743 
         *
4744 
         * @return string
4745 
         * @static
4746 
         */
4747 
        public static function getKey()
4748 
        {
4749 
                        /** @var \Illuminate\Encryption\Encrypter $instance */
4750 
                        return $instance->getKey();
4751 
        }
4752 
 
4753 
    }
4754 
            /**
4755 
     *
4756 
     *
4757 
     * @see https://carbon.nesbot.com/docs/
4758 
     * @see https://github.com/briannesbitt/Carbon/blob/master/src/Carbon/Factory.php
4759 
     * @method static \Illuminate\Support\Carbon create($year = 0, $month = 1, $day = 1, $hour = 0, $minute = 0, $second = 0, $tz = null)
4760 
     * @method static \Illuminate\Support\Carbon createFromDate($year = null, $month = null, $day = null, $tz = null)
4761 
     * @method static \Illuminate\Support\Carbon|false createFromFormat($format, $time, $tz = null)
4762 
     * @method static \Illuminate\Support\Carbon createFromTime($hour = 0, $minute = 0, $second = 0, $tz = null)
4763 
     * @method static \Illuminate\Support\Carbon createFromTimeString($time, $tz = null)
4764 
     * @method static \Illuminate\Support\Carbon createFromTimestamp($timestamp, $tz = null)
4765 
     * @method static \Illuminate\Support\Carbon createFromTimestampMs($timestamp, $tz = null)
4766 
     * @method static \Illuminate\Support\Carbon createFromTimestampUTC($timestamp)
4767 
     * @method static \Illuminate\Support\Carbon createMidnightDate($year = null, $month = null, $day = null, $tz = null)
4768 
     * @method static \Illuminate\Support\Carbon|false createSafe($year = null, $month = null, $day = null, $hour = null, $minute = null, $second = null, $tz = null)
4769 
     * @method static void disableHumanDiffOption($humanDiffOption)
4770 
     * @method static void enableHumanDiffOption($humanDiffOption)
4771 
     * @method static mixed executeWithLocale($locale, $func)
4772 
     * @method static \Illuminate\Support\Carbon fromSerialized($value)
4773 
     * @method static array getAvailableLocales()
4774 
     * @method static array getDays()
4775 
     * @method static int getHumanDiffOptions()
4776 
     * @method static array getIsoUnits()
4777 
     * @method static array getLastErrors()
4778 
     * @method static string getLocale()
4779 
     * @method static int getMidDayAt()
4780 
     * @method static \Illuminate\Support\Carbon|null getTestNow()
4781 
     * @method static \Symfony\Component\Translation\TranslatorInterface getTranslator()
4782 
     * @method static int getWeekEndsAt()
4783 
     * @method static int getWeekStartsAt()
4784 
     * @method static array getWeekendDays()
4785 
     * @method static bool hasFormat($date, $format)
4786 
     * @method static bool hasMacro($name)
4787 
     * @method static bool hasRelativeKeywords($time)
4788 
     * @method static bool hasTestNow()
4789 
     * @method static \Illuminate\Support\Carbon instance($date)
4790 
     * @method static bool isImmutable()
4791 
     * @method static bool isModifiableUnit($unit)
4792 
     * @method static bool isMutable()
4793 
     * @method static bool isStrictModeEnabled()
4794 
     * @method static bool localeHasDiffOneDayWords($locale)
4795 
     * @method static bool localeHasDiffSyntax($locale)
4796 
     * @method static bool localeHasDiffTwoDayWords($locale)
4797 
     * @method static bool localeHasPeriodSyntax($locale)
4798 
     * @method static bool localeHasShortUnits($locale)
4799 
     * @method static void macro($name, $macro)
4800 
     * @method static \Illuminate\Support\Carbon|null make($var)
4801 
     * @method static \Illuminate\Support\Carbon maxValue()
4802 
     * @method static \Illuminate\Support\Carbon minValue()
4803 
     * @method static void mixin($mixin)
4804 
     * @method static \Illuminate\Support\Carbon now($tz = null)
4805 
     * @method static \Illuminate\Support\Carbon parse($time = null, $tz = null)
4806 
     * @method static string pluralUnit(string $unit)
4807 
     * @method static void resetMonthsOverflow()
4808 
     * @method static void resetToStringFormat()
4809 
     * @method static void resetYearsOverflow()
4810 
     * @method static void serializeUsing($callback)
4811 
     * @method static void setHumanDiffOptions($humanDiffOptions)
4812 
     * @method static bool setLocale($locale)
4813 
     * @method static void setMidDayAt($hour)
4814 
     * @method static void setTestNow($testNow = null)
4815 
     * @method static void setToStringFormat($format)
4816 
     * @method static void setTranslator(\Symfony\Component\Translation\TranslatorInterface $translator)
4817 
     * @method static void setUtf8($utf8)
4818 
     * @method static void setWeekEndsAt($day)
4819 
     * @method static void setWeekStartsAt($day)
4820 
     * @method static void setWeekendDays($days)
4821 
     * @method static bool shouldOverflowMonths()
4822 
     * @method static bool shouldOverflowYears()
4823 
     * @method static string singularUnit(string $unit)
4824 
     * @method static \Illuminate\Support\Carbon today($tz = null)
4825 
     * @method static \Illuminate\Support\Carbon tomorrow($tz = null)
4826 
     * @method static void useMonthsOverflow($monthsOverflow = true)
4827 
     * @method static void useStrictMode($strictModeEnabled = true)
4828 
     * @method static void useYearsOverflow($yearsOverflow = true)
4829 
     * @method static \Illuminate\Support\Carbon yesterday($tz = null)
4830 
     * @see \Illuminate\Support\DateFactory
4831 
     */
4832 
        class Date {
4833 
                    /**
4834 
         * Use the given handler when generating dates (class name, callable, or factory).
4835 
         *
4836 
         * @param mixed $handler
4837 
         * @return mixed
4838 
         * @throws \InvalidArgumentException
4839 
         * @static
4840 
         */
4841 
        public static function use($handler)
4842 
        {
4843 
                        return \Illuminate\Support\DateFactory::use($handler);
4844 
        }
4845 
                    /**
4846 
         * Use the default date class when generating dates.
4847 
         *
4848 
         * @return void
4849 
         * @static
4850 
         */
4851 
        public static function useDefault()
4852 
        {
4853 
                        \Illuminate\Support\DateFactory::useDefault();
4854 
        }
4855 
                    /**
4856 
         * Execute the given callable on each date creation.
4857 
         *
4858 
         * @param callable $callable
4859 
         * @return void
4860 
         * @static
4861 
         */
4862 
        public static function useCallable($callable)
4863 
        {
4864 
                        \Illuminate\Support\DateFactory::useCallable($callable);
4865 
        }
4866 
                    /**
4867 
         * Use the given date type (class) when generating dates.
4868 
         *
4869 
         * @param string $dateClass
4870 
         * @return void
4871 
         * @static
4872 
         */
4873 
        public static function useClass($dateClass)
4874 
        {
4875 
                        \Illuminate\Support\DateFactory::useClass($dateClass);
4876 
        }
4877 
                    /**
4878 
         * Use the given Carbon factory when generating dates.
4879 
         *
4880 
         * @param object $factory
4881 
         * @return void
4882 
         * @static
4883 
         */
4884 
        public static function useFactory($factory)
4885 
        {
4886 
                        \Illuminate\Support\DateFactory::useFactory($factory);
4887 
        }
4888 
 
4889 
    }
4890 
            /**
4891 
     *
4892 
     *
4893 
     * @see \Illuminate\Database\DatabaseManager
4894 
     */
4895 
        class DB {
4896 
                    /**
4897 
         * Get a database connection instance.
4898 
         *
4899 
         * @param string|null $name
4900 
         * @return \Illuminate\Database\Connection
4901 
         * @static
4902 
         */
4903 
        public static function connection($name = null)
4904 
        {
4905 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
4906 
                        return $instance->connection($name);
4907 
        }
4908 
                    /**
4909 
         * Register a custom Doctrine type.
4910 
         *
4911 
         * @param string $class
4912 
         * @param string $name
4913 
         * @param string $type
4914 
         * @return void
4915 
         * @throws \Doctrine\DBAL\DBALException
4916 
         * @throws \RuntimeException
4917 
         * @static
4918 
         */
4919 
        public static function registerDoctrineType($class, $name, $type)
4920 
        {
4921 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
4922 
                        $instance->registerDoctrineType($class, $name, $type);
4923 
        }
4924 
                    /**
4925 
         * Disconnect from the given database and remove from local cache.
4926 
         *
4927 
         * @param string|null $name
4928 
         * @return void
4929 
         * @static
4930 
         */
4931 
        public static function purge($name = null)
4932 
        {
4933 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
4934 
                        $instance->purge($name);
4935 
        }
4936 
                    /**
4937 
         * Disconnect from the given database.
4938 
         *
4939 
         * @param string|null $name
4940 
         * @return void
4941 
         * @static
4942 
         */
4943 
        public static function disconnect($name = null)
4944 
        {
4945 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
4946 
                        $instance->disconnect($name);
4947 
        }
4948 
                    /**
4949 
         * Reconnect to the given database.
4950 
         *
4951 
         * @param string|null $name
4952 
         * @return \Illuminate\Database\Connection
4953 
         * @static
4954 
         */
4955 
        public static function reconnect($name = null)
4956 
        {
4957 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
4958 
                        return $instance->reconnect($name);
4959 
        }
4960 
                    /**
4961 
         * Set the default database connection for the callback execution.
4962 
         *
4963 
         * @param string $name
4964 
         * @param callable $callback
4965 
         * @return mixed
4966 
         * @static
4967 
         */
4968 
        public static function usingConnection($name, $callback)
4969 
        {
4970 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
4971 
                        return $instance->usingConnection($name, $callback);
4972 
        }
4973 
                    /**
4974 
         * Get the default connection name.
4975 
         *
4976 
         * @return string
4977 
         * @static
4978 
         */
4979 
        public static function getDefaultConnection()
4980 
        {
4981 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
4982 
                        return $instance->getDefaultConnection();
4983 
        }
4984 
                    /**
4985 
         * Set the default connection name.
4986 
         *
4987 
         * @param string $name
4988 
         * @return void
4989 
         * @static
4990 
         */
4991 
        public static function setDefaultConnection($name)
4992 
        {
4993 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
4994 
                        $instance->setDefaultConnection($name);
4995 
        }
4996 
                    /**
4997 
         * Get all of the support drivers.
4998 
         *
4999 
         * @return string[]
5000 
         * @static
5001 
         */
5002 
        public static function supportedDrivers()
5003 
        {
5004 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
5005 
                        return $instance->supportedDrivers();
5006 
        }
5007 
                    /**
5008 
         * Get all of the drivers that are actually available.
5009 
         *
5010 
         * @return string[]
5011 
         * @static
5012 
         */
5013 
        public static function availableDrivers()
5014 
        {
5015 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
5016 
                        return $instance->availableDrivers();
5017 
        }
5018 
                    /**
5019 
         * Register an extension connection resolver.
5020 
         *
5021 
         * @param string $name
5022 
         * @param callable $resolver
5023 
         * @return void
5024 
         * @static
5025 
         */
5026 
        public static function extend($name, $resolver)
5027 
        {
5028 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
5029 
                        $instance->extend($name, $resolver);
5030 
        }
5031 
                    /**
5032 
         * Remove an extension connection resolver.
5033 
         *
5034 
         * @param string $name
5035 
         * @return void
5036 
         * @static
5037 
         */
5038 
        public static function forgetExtension($name)
5039 
        {
5040 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
5041 
                        $instance->forgetExtension($name);
5042 
        }
5043 
                    /**
5044 
         * Return all of the created connections.
5045 
         *
5046 
         * @return array<string, \Illuminate\Database\Connection>
5047 
         * @static
5048 
         */
5049 
        public static function getConnections()
5050 
        {
5051 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
5052 
                        return $instance->getConnections();
5053 
        }
5054 
                    /**
5055 
         * Set the database reconnector callback.
5056 
         *
5057 
         * @param callable $reconnector
5058 
         * @return void
5059 
         * @static
5060 
         */
5061 
        public static function setReconnector($reconnector)
5062 
        {
5063 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
5064 
                        $instance->setReconnector($reconnector);
5065 
        }
5066 
                    /**
5067 
         * Set the application instance used by the manager.
5068 
         *
5069 
         * @param \Illuminate\Contracts\Foundation\Application $app
5070 
         * @return \Illuminate\Database\DatabaseManager
5071 
         * @static
5072 
         */
5073 
        public static function setApplication($app)
5074 
        {
5075 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
5076 
                        return $instance->setApplication($app);
5077 
        }
5078 
                    /**
5079 
         * Register a custom macro.
5080 
         *
5081 
         * @param string $name
5082 
         * @param object|callable $macro
5083 
         * @return void
5084 
         * @static
5085 
         */
5086 
        public static function macro($name, $macro)
5087 
        {
5088 
                        \Illuminate\Database\DatabaseManager::macro($name, $macro);
5089 
        }
5090 
                    /**
5091 
         * Mix another object into the class.
5092 
         *
5093 
         * @param object $mixin
5094 
         * @param bool $replace
5095 
         * @return void
5096 
         * @throws \ReflectionException
5097 
         * @static
5098 
         */
5099 
        public static function mixin($mixin, $replace = true)
5100 
        {
5101 
                        \Illuminate\Database\DatabaseManager::mixin($mixin, $replace);
5102 
        }
5103 
                    /**
5104 
         * Checks if macro is registered.
5105 
         *
5106 
         * @param string $name
5107 
         * @return bool
5108 
         * @static
5109 
         */
5110 
        public static function hasMacro($name)
5111 
        {
5112 
                        return \Illuminate\Database\DatabaseManager::hasMacro($name);
5113 
        }
5114 
                    /**
5115 
         * Flush the existing macros.
5116 
         *
5117 
         * @return void
5118 
         * @static
5119 
         */
5120 
        public static function flushMacros()
5121 
        {
5122 
                        \Illuminate\Database\DatabaseManager::flushMacros();
5123 
        }
5124 
                    /**
5125 
         * Dynamically handle calls to the class.
5126 
         *
5127 
         * @param string $method
5128 
         * @param array $parameters
5129 
         * @return mixed
5130 
         * @throws \BadMethodCallException
5131 
         * @static
5132 
         */
5133 
        public static function macroCall($method, $parameters)
5134 
        {
5135 
                        /** @var \Illuminate\Database\DatabaseManager $instance */
5136 
                        return $instance->macroCall($method, $parameters);
5137 
        }
5138 
                    /**
5139 
         * Determine if the connected database is a MariaDB database.
5140 
         *
5141 
         * @return bool
5142 
         * @static
5143 
         */
5144 
        public static function isMaria()
5145 
        {
5146 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5147 
                        return $instance->isMaria();
5148 
        }
5149 
                    /**
5150 
         * Get a schema builder instance for the connection.
5151 
         *
5152 
         * @return \Illuminate\Database\Schema\MySqlBuilder
5153 
         * @static
5154 
         */
5155 
        public static function getSchemaBuilder()
5156 
        {
5157 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5158 
                        return $instance->getSchemaBuilder();
5159 
        }
5160 
                    /**
5161 
         * Get the schema state for the connection.
5162 
         *
5163 
         * @param \Illuminate\Filesystem\Filesystem|null $files
5164 
         * @param callable|null $processFactory
5165 
         * @return \Illuminate\Database\Schema\MySqlSchemaState
5166 
         * @static
5167 
         */
5168 
        public static function getSchemaState($files = null, $processFactory = null)
5169 
        {
5170 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5171 
                        return $instance->getSchemaState($files, $processFactory);
5172 
        }
5173 
                    /**
5174 
         * Set the query grammar to the default implementation.
5175 
         *
5176 
         * @return void
5177 
         * @static
5178 
         */
5179 
        public static function useDefaultQueryGrammar()
5180 
        {            //Method inherited from \Illuminate\Database\Connection
5181 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5182 
                        $instance->useDefaultQueryGrammar();
5183 
        }
5184 
                    /**
5185 
         * Set the schema grammar to the default implementation.
5186 
         *
5187 
         * @return void
5188 
         * @static
5189 
         */
5190 
        public static function useDefaultSchemaGrammar()
5191 
        {            //Method inherited from \Illuminate\Database\Connection
5192 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5193 
                        $instance->useDefaultSchemaGrammar();
5194 
        }
5195 
                    /**
5196 
         * Set the query post processor to the default implementation.
5197 
         *
5198 
         * @return void
5199 
         * @static
5200 
         */
5201 
        public static function useDefaultPostProcessor()
5202 
        {            //Method inherited from \Illuminate\Database\Connection
5203 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5204 
                        $instance->useDefaultPostProcessor();
5205 
        }
5206 
                    /**
5207 
         * Begin a fluent query against a database table.
5208 
         *
5209 
         * @param \Closure|\Illuminate\Database\Query\Builder|string $table
5210 
         * @param string|null $as
5211 
         * @return \Illuminate\Database\Query\Builder
5212 
         * @static
5213 
         */
5214 
        public static function table($table, $as = null)
5215 
        {            //Method inherited from \Illuminate\Database\Connection
5216 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5217 
                        return $instance->table($table, $as);
5218 
        }
5219 
                    /**
5220 
         * Get a new query builder instance.
5221 
         *
5222 
         * @return \Illuminate\Database\Query\Builder
5223 
         * @static
5224 
         */
5225 
        public static function query()
5226 
        {            //Method inherited from \Illuminate\Database\Connection
5227 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5228 
                        return $instance->query();
5229 
        }
5230 
                    /**
5231 
         * Run a select statement and return a single result.
5232 
         *
5233 
         * @param string $query
5234 
         * @param array $bindings
5235 
         * @param bool $useReadPdo
5236 
         * @return mixed
5237 
         * @static
5238 
         */
5239 
        public static function selectOne($query, $bindings = [], $useReadPdo = true)
5240 
        {            //Method inherited from \Illuminate\Database\Connection
5241 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5242 
                        return $instance->selectOne($query, $bindings, $useReadPdo);
5243 
        }
5244 
                    /**
5245 
         * Run a select statement and return the first column of the first row.
5246 
         *
5247 
         * @param string $query
5248 
         * @param array $bindings
5249 
         * @param bool $useReadPdo
5250 
         * @return mixed
5251 
         * @throws \Illuminate\Database\MultipleColumnsSelectedException
5252 
         * @static
5253 
         */
5254 
        public static function scalar($query, $bindings = [], $useReadPdo = true)
5255 
        {            //Method inherited from \Illuminate\Database\Connection
5256 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5257 
                        return $instance->scalar($query, $bindings, $useReadPdo);
5258 
        }
5259 
                    /**
5260 
         * Run a select statement against the database.
5261 
         *
5262 
         * @param string $query
5263 
         * @param array $bindings
5264 
         * @return array
5265 
         * @static
5266 
         */
5267 
        public static function selectFromWriteConnection($query, $bindings = [])
5268 
        {            //Method inherited from \Illuminate\Database\Connection
5269 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5270 
                        return $instance->selectFromWriteConnection($query, $bindings);
5271 
        }
5272 
                    /**
5273 
         * Run a select statement against the database.
5274 
         *
5275 
         * @param string $query
5276 
         * @param array $bindings
5277 
         * @param bool $useReadPdo
5278 
         * @return array
5279 
         * @static
5280 
         */
5281 
        public static function select($query, $bindings = [], $useReadPdo = true)
5282 
        {            //Method inherited from \Illuminate\Database\Connection
5283 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5284 
                        return $instance->select($query, $bindings, $useReadPdo);
5285 
        }
5286 
                    /**
5287 
         * Run a select statement against the database and returns a generator.
5288 
         *
5289 
         * @param string $query
5290 
         * @param array $bindings
5291 
         * @param bool $useReadPdo
5292 
         * @return \Generator
5293 
         * @static
5294 
         */
5295 
        public static function cursor($query, $bindings = [], $useReadPdo = true)
5296 
        {            //Method inherited from \Illuminate\Database\Connection
5297 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5298 
                        return $instance->cursor($query, $bindings, $useReadPdo);
5299 
        }
5300 
                    /**
5301 
         * Run an insert statement against the database.
5302 
         *
5303 
         * @param string $query
5304 
         * @param array $bindings
5305 
         * @return bool
5306 
         * @static
5307 
         */
5308 
        public static function insert($query, $bindings = [])
5309 
        {            //Method inherited from \Illuminate\Database\Connection
5310 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5311 
                        return $instance->insert($query, $bindings);
5312 
        }
5313 
                    /**
5314 
         * Run an update statement against the database.
5315 
         *
5316 
         * @param string $query
5317 
         * @param array $bindings
5318 
         * @return int
5319 
         * @static
5320 
         */
5321 
        public static function update($query, $bindings = [])
5322 
        {            //Method inherited from \Illuminate\Database\Connection
5323 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5324 
                        return $instance->update($query, $bindings);
5325 
        }
5326 
                    /**
5327 
         * Run a delete statement against the database.
5328 
         *
5329 
         * @param string $query
5330 
         * @param array $bindings
5331 
         * @return int
5332 
         * @static
5333 
         */
5334 
        public static function delete($query, $bindings = [])
5335 
        {            //Method inherited from \Illuminate\Database\Connection
5336 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5337 
                        return $instance->delete($query, $bindings);
5338 
        }
5339 
                    /**
5340 
         * Execute an SQL statement and return the boolean result.
5341 
         *
5342 
         * @param string $query
5343 
         * @param array $bindings
5344 
         * @return bool
5345 
         * @static
5346 
         */
5347 
        public static function statement($query, $bindings = [])
5348 
        {            //Method inherited from \Illuminate\Database\Connection
5349 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5350 
                        return $instance->statement($query, $bindings);
5351 
        }
5352 
                    /**
5353 
         * Run an SQL statement and get the number of rows affected.
5354 
         *
5355 
         * @param string $query
5356 
         * @param array $bindings
5357 
         * @return int
5358 
         * @static
5359 
         */
5360 
        public static function affectingStatement($query, $bindings = [])
5361 
        {            //Method inherited from \Illuminate\Database\Connection
5362 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5363 
                        return $instance->affectingStatement($query, $bindings);
5364 
        }
5365 
                    /**
5366 
         * Run a raw, unprepared query against the PDO connection.
5367 
         *
5368 
         * @param string $query
5369 
         * @return bool
5370 
         * @static
5371 
         */
5372 
        public static function unprepared($query)
5373 
        {            //Method inherited from \Illuminate\Database\Connection
5374 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5375 
                        return $instance->unprepared($query);
5376 
        }
5377 
                    /**
5378 
         * Execute the given callback in "dry run" mode.
5379 
         *
5380 
         * @param \Closure $callback
5381 
         * @return array
5382 
         * @static
5383 
         */
5384 
        public static function pretend($callback)
5385 
        {            //Method inherited from \Illuminate\Database\Connection
5386 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5387 
                        return $instance->pretend($callback);
5388 
        }
5389 
                    /**
5390 
         * Bind values to their parameters in the given statement.
5391 
         *
5392 
         * @param \PDOStatement $statement
5393 
         * @param array $bindings
5394 
         * @return void
5395 
         * @static
5396 
         */
5397 
        public static function bindValues($statement, $bindings)
5398 
        {            //Method inherited from \Illuminate\Database\Connection
5399 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5400 
                        $instance->bindValues($statement, $bindings);
5401 
        }
5402 
                    /**
5403 
         * Prepare the query bindings for execution.
5404 
         *
5405 
         * @param array $bindings
5406 
         * @return array
5407 
         * @static
5408 
         */
5409 
        public static function prepareBindings($bindings)
5410 
        {            //Method inherited from \Illuminate\Database\Connection
5411 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5412 
                        return $instance->prepareBindings($bindings);
5413 
        }
5414 
                    /**
5415 
         * Log a query in the connection's query log.
5416 
         *
5417 
         * @param string $query
5418 
         * @param array $bindings
5419 
         * @param float|null $time
5420 
         * @return void
5421 
         * @static
5422 
         */
5423 
        public static function logQuery($query, $bindings, $time = null)
5424 
        {            //Method inherited from \Illuminate\Database\Connection
5425 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5426 
                        $instance->logQuery($query, $bindings, $time);
5427 
        }
5428 
                    /**
5429 
         * Register a callback to be invoked when the connection queries for longer than a given amount of time.
5430 
         *
5431 
         * @param \DateTimeInterface|\Carbon\CarbonInterval|float|int $threshold
5432 
         * @param callable $handler
5433 
         * @return void
5434 
         * @static
5435 
         */
5436 
        public static function whenQueryingForLongerThan($threshold, $handler)
5437 
        {            //Method inherited from \Illuminate\Database\Connection
5438 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5439 
                        $instance->whenQueryingForLongerThan($threshold, $handler);
5440 
        }
5441 
                    /**
5442 
         * Allow all the query duration handlers to run again, even if they have already run.
5443 
         *
5444 
         * @return void
5445 
         * @static
5446 
         */
5447 
        public static function allowQueryDurationHandlersToRunAgain()
5448 
        {            //Method inherited from \Illuminate\Database\Connection
5449 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5450 
                        $instance->allowQueryDurationHandlersToRunAgain();
5451 
        }
5452 
                    /**
5453 
         * Get the duration of all run queries in milliseconds.
5454 
         *
5455 
         * @return float
5456 
         * @static
5457 
         */
5458 
        public static function totalQueryDuration()
5459 
        {            //Method inherited from \Illuminate\Database\Connection
5460 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5461 
                        return $instance->totalQueryDuration();
5462 
        }
5463 
                    /**
5464 
         * Reset the duration of all run queries.
5465 
         *
5466 
         * @return void
5467 
         * @static
5468 
         */
5469 
        public static function resetTotalQueryDuration()
5470 
        {            //Method inherited from \Illuminate\Database\Connection
5471 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5472 
                        $instance->resetTotalQueryDuration();
5473 
        }
5474 
                    /**
5475 
         * Register a hook to be run just before a database query is executed.
5476 
         *
5477 
         * @param \Closure $callback
5478 
         * @return \Illuminate\Database\MySqlConnection
5479 
         * @static
5480 
         */
5481 
        public static function beforeExecuting($callback)
5482 
        {            //Method inherited from \Illuminate\Database\Connection
5483 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5484 
                        return $instance->beforeExecuting($callback);
5485 
        }
5486 
                    /**
5487 
         * Register a database query listener with the connection.
5488 
         *
5489 
         * @param \Closure $callback
5490 
         * @return void
5491 
         * @static
5492 
         */
5493 
        public static function listen($callback)
5494 
        {            //Method inherited from \Illuminate\Database\Connection
5495 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5496 
                        $instance->listen($callback);
5497 
        }
5498 
                    /**
5499 
         * Get a new raw query expression.
5500 
         *
5501 
         * @param mixed $value
5502 
         * @return \Illuminate\Database\Query\Expression
5503 
         * @static
5504 
         */
5505 
        public static function raw($value)
5506 
        {            //Method inherited from \Illuminate\Database\Connection
5507 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5508 
                        return $instance->raw($value);
5509 
        }
5510 
                    /**
5511 
         * Determine if the database connection has modified any database records.
5512 
         *
5513 
         * @return bool
5514 
         * @static
5515 
         */
5516 
        public static function hasModifiedRecords()
5517 
        {            //Method inherited from \Illuminate\Database\Connection
5518 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5519 
                        return $instance->hasModifiedRecords();
5520 
        }
5521 
                    /**
5522 
         * Indicate if any records have been modified.
5523 
         *
5524 
         * @param bool $value
5525 
         * @return void
5526 
         * @static
5527 
         */
5528 
        public static function recordsHaveBeenModified($value = true)
5529 
        {            //Method inherited from \Illuminate\Database\Connection
5530 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5531 
                        $instance->recordsHaveBeenModified($value);
5532 
        }
5533 
                    /**
5534 
         * Set the record modification state.
5535 
         *
5536 
         * @param bool $value
5537 
         * @return \Illuminate\Database\MySqlConnection
5538 
         * @static
5539 
         */
5540 
        public static function setRecordModificationState($value)
5541 
        {            //Method inherited from \Illuminate\Database\Connection
5542 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5543 
                        return $instance->setRecordModificationState($value);
5544 
        }
5545 
                    /**
5546 
         * Reset the record modification state.
5547 
         *
5548 
         * @return void
5549 
         * @static
5550 
         */
5551 
        public static function forgetRecordModificationState()
5552 
        {            //Method inherited from \Illuminate\Database\Connection
5553 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5554 
                        $instance->forgetRecordModificationState();
5555 
        }
5556 
                    /**
5557 
         * Indicate that the connection should use the write PDO connection for reads.
5558 
         *
5559 
         * @param bool $value
5560 
         * @return \Illuminate\Database\MySqlConnection
5561 
         * @static
5562 
         */
5563 
        public static function useWriteConnectionWhenReading($value = true)
5564 
        {            //Method inherited from \Illuminate\Database\Connection
5565 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5566 
                        return $instance->useWriteConnectionWhenReading($value);
5567 
        }
5568 
                    /**
5569 
         * Is Doctrine available?
5570 
         *
5571 
         * @return bool
5572 
         * @static
5573 
         */
5574 
        public static function isDoctrineAvailable()
5575 
        {            //Method inherited from \Illuminate\Database\Connection
5576 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5577 
                        return $instance->isDoctrineAvailable();
5578 
        }
5579 
                    /**
5580 
         * Indicates whether native alter operations will be used when dropping or renaming columns, even if Doctrine DBAL is installed.
5581 
         *
5582 
         * @return bool
5583 
         * @static
5584 
         */
5585 
        public static function usingNativeSchemaOperations()
5586 
        {            //Method inherited from \Illuminate\Database\Connection
5587 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5588 
                        return $instance->usingNativeSchemaOperations();
5589 
        }
5590 
                    /**
5591 
         * Get a Doctrine Schema Column instance.
5592 
         *
5593 
         * @param string $table
5594 
         * @param string $column
5595 
         * @return \Doctrine\DBAL\Schema\Column
5596 
         * @static
5597 
         */
5598 
        public static function getDoctrineColumn($table, $column)
5599 
        {            //Method inherited from \Illuminate\Database\Connection
5600 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5601 
                        return $instance->getDoctrineColumn($table, $column);
5602 
        }
5603 
                    /**
5604 
         * Get the Doctrine DBAL schema manager for the connection.
5605 
         *
5606 
         * @return \Doctrine\DBAL\Schema\AbstractSchemaManager
5607 
         * @static
5608 
         */
5609 
        public static function getDoctrineSchemaManager()
5610 
        {            //Method inherited from \Illuminate\Database\Connection
5611 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5612 
                        return $instance->getDoctrineSchemaManager();
5613 
        }
5614 
                    /**
5615 
         * Get the Doctrine DBAL database connection instance.
5616 
         *
5617 
         * @return \Doctrine\DBAL\Connection
5618 
         * @static
5619 
         */
5620 
        public static function getDoctrineConnection()
5621 
        {            //Method inherited from \Illuminate\Database\Connection
5622 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5623 
                        return $instance->getDoctrineConnection();
5624 
        }
5625 
                    /**
5626 
         * Get the current PDO connection.
5627 
         *
5628 
         * @return \PDO
5629 
         * @static
5630 
         */
5631 
        public static function getPdo()
5632 
        {            //Method inherited from \Illuminate\Database\Connection
5633 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5634 
                        return $instance->getPdo();
5635 
        }
5636 
                    /**
5637 
         * Get the current PDO connection parameter without executing any reconnect logic.
5638 
         *
5639 
         * @return \PDO|\Closure|null
5640 
         * @static
5641 
         */
5642 
        public static function getRawPdo()
5643 
        {            //Method inherited from \Illuminate\Database\Connection
5644 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5645 
                        return $instance->getRawPdo();
5646 
        }
5647 
                    /**
5648 
         * Get the current PDO connection used for reading.
5649 
         *
5650 
         * @return \PDO
5651 
         * @static
5652 
         */
5653 
        public static function getReadPdo()
5654 
        {            //Method inherited from \Illuminate\Database\Connection
5655 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5656 
                        return $instance->getReadPdo();
5657 
        }
5658 
                    /**
5659 
         * Get the current read PDO connection parameter without executing any reconnect logic.
5660 
         *
5661 
         * @return \PDO|\Closure|null
5662 
         * @static
5663 
         */
5664 
        public static function getRawReadPdo()
5665 
        {            //Method inherited from \Illuminate\Database\Connection
5666 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5667 
                        return $instance->getRawReadPdo();
5668 
        }
5669 
                    /**
5670 
         * Set the PDO connection.
5671 
         *
5672 
         * @param \PDO|\Closure|null $pdo
5673 
         * @return \Illuminate\Database\MySqlConnection
5674 
         * @static
5675 
         */
5676 
        public static function setPdo($pdo)
5677 
        {            //Method inherited from \Illuminate\Database\Connection
5678 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5679 
                        return $instance->setPdo($pdo);
5680 
        }
5681 
                    /**
5682 
         * Set the PDO connection used for reading.
5683 
         *
5684 
         * @param \PDO|\Closure|null $pdo
5685 
         * @return \Illuminate\Database\MySqlConnection
5686 
         * @static
5687 
         */
5688 
        public static function setReadPdo($pdo)
5689 
        {            //Method inherited from \Illuminate\Database\Connection
5690 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5691 
                        return $instance->setReadPdo($pdo);
5692 
        }
5693 
                    /**
5694 
         * Get the database connection name.
5695 
         *
5696 
         * @return string|null
5697 
         * @static
5698 
         */
5699 
        public static function getName()
5700 
        {            //Method inherited from \Illuminate\Database\Connection
5701 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5702 
                        return $instance->getName();
5703 
        }
5704 
                    /**
5705 
         * Get the database connection full name.
5706 
         *
5707 
         * @return string|null
5708 
         * @static
5709 
         */
5710 
        public static function getNameWithReadWriteType()
5711 
        {            //Method inherited from \Illuminate\Database\Connection
5712 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5713 
                        return $instance->getNameWithReadWriteType();
5714 
        }
5715 
                    /**
5716 
         * Get an option from the configuration options.
5717 
         *
5718 
         * @param string|null $option
5719 
         * @return mixed
5720 
         * @static
5721 
         */
5722 
        public static function getConfig($option = null)
5723 
        {            //Method inherited from \Illuminate\Database\Connection
5724 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5725 
                        return $instance->getConfig($option);
5726 
        }
5727 
                    /**
5728 
         * Get the PDO driver name.
5729 
         *
5730 
         * @return string
5731 
         * @static
5732 
         */
5733 
        public static function getDriverName()
5734 
        {            //Method inherited from \Illuminate\Database\Connection
5735 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5736 
                        return $instance->getDriverName();
5737 
        }
5738 
                    /**
5739 
         * Get the query grammar used by the connection.
5740 
         *
5741 
         * @return \Illuminate\Database\Query\Grammars\Grammar
5742 
         * @static
5743 
         */
5744 
        public static function getQueryGrammar()
5745 
        {            //Method inherited from \Illuminate\Database\Connection
5746 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5747 
                        return $instance->getQueryGrammar();
5748 
        }
5749 
                    /**
5750 
         * Set the query grammar used by the connection.
5751 
         *
5752 
         * @param \Illuminate\Database\Query\Grammars\Grammar $grammar
5753 
         * @return \Illuminate\Database\MySqlConnection
5754 
         * @static
5755 
         */
5756 
        public static function setQueryGrammar($grammar)
5757 
        {            //Method inherited from \Illuminate\Database\Connection
5758 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5759 
                        return $instance->setQueryGrammar($grammar);
5760 
        }
5761 
                    /**
5762 
         * Get the schema grammar used by the connection.
5763 
         *
5764 
         * @return \Illuminate\Database\Schema\Grammars\Grammar
5765 
         * @static
5766 
         */
5767 
        public static function getSchemaGrammar()
5768 
        {            //Method inherited from \Illuminate\Database\Connection
5769 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5770 
                        return $instance->getSchemaGrammar();
5771 
        }
5772 
                    /**
5773 
         * Set the schema grammar used by the connection.
5774 
         *
5775 
         * @param \Illuminate\Database\Schema\Grammars\Grammar $grammar
5776 
         * @return \Illuminate\Database\MySqlConnection
5777 
         * @static
5778 
         */
5779 
        public static function setSchemaGrammar($grammar)
5780 
        {            //Method inherited from \Illuminate\Database\Connection
5781 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5782 
                        return $instance->setSchemaGrammar($grammar);
5783 
        }
5784 
                    /**
5785 
         * Get the query post processor used by the connection.
5786 
         *
5787 
         * @return \Illuminate\Database\Query\Processors\Processor
5788 
         * @static
5789 
         */
5790 
        public static function getPostProcessor()
5791 
        {            //Method inherited from \Illuminate\Database\Connection
5792 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5793 
                        return $instance->getPostProcessor();
5794 
        }
5795 
                    /**
5796 
         * Set the query post processor used by the connection.
5797 
         *
5798 
         * @param \Illuminate\Database\Query\Processors\Processor $processor
5799 
         * @return \Illuminate\Database\MySqlConnection
5800 
         * @static
5801 
         */
5802 
        public static function setPostProcessor($processor)
5803 
        {            //Method inherited from \Illuminate\Database\Connection
5804 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5805 
                        return $instance->setPostProcessor($processor);
5806 
        }
5807 
                    /**
5808 
         * Get the event dispatcher used by the connection.
5809 
         *
5810 
         * @return \Illuminate\Contracts\Events\Dispatcher
5811 
         * @static
5812 
         */
5813 
        public static function getEventDispatcher()
5814 
        {            //Method inherited from \Illuminate\Database\Connection
5815 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5816 
                        return $instance->getEventDispatcher();
5817 
        }
5818 
                    /**
5819 
         * Set the event dispatcher instance on the connection.
5820 
         *
5821 
         * @param \Illuminate\Contracts\Events\Dispatcher $events
5822 
         * @return \Illuminate\Database\MySqlConnection
5823 
         * @static
5824 
         */
5825 
        public static function setEventDispatcher($events)
5826 
        {            //Method inherited from \Illuminate\Database\Connection
5827 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5828 
                        return $instance->setEventDispatcher($events);
5829 
        }
5830 
                    /**
5831 
         * Unset the event dispatcher for this connection.
5832 
         *
5833 
         * @return void
5834 
         * @static
5835 
         */
5836 
        public static function unsetEventDispatcher()
5837 
        {            //Method inherited from \Illuminate\Database\Connection
5838 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5839 
                        $instance->unsetEventDispatcher();
5840 
        }
5841 
                    /**
5842 
         * Set the transaction manager instance on the connection.
5843 
         *
5844 
         * @param \Illuminate\Database\DatabaseTransactionsManager $manager
5845 
         * @return \Illuminate\Database\MySqlConnection
5846 
         * @static
5847 
         */
5848 
        public static function setTransactionManager($manager)
5849 
        {            //Method inherited from \Illuminate\Database\Connection
5850 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5851 
                        return $instance->setTransactionManager($manager);
5852 
        }
5853 
                    /**
5854 
         * Unset the transaction manager for this connection.
5855 
         *
5856 
         * @return void
5857 
         * @static
5858 
         */
5859 
        public static function unsetTransactionManager()
5860 
        {            //Method inherited from \Illuminate\Database\Connection
5861 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5862 
                        $instance->unsetTransactionManager();
5863 
        }
5864 
                    /**
5865 
         * Determine if the connection is in a "dry run".
5866 
         *
5867 
         * @return bool
5868 
         * @static
5869 
         */
5870 
        public static function pretending()
5871 
        {            //Method inherited from \Illuminate\Database\Connection
5872 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5873 
                        return $instance->pretending();
5874 
        }
5875 
                    /**
5876 
         * Get the connection query log.
5877 
         *
5878 
         * @return array
5879 
         * @static
5880 
         */
5881 
        public static function getQueryLog()
5882 
        {            //Method inherited from \Illuminate\Database\Connection
5883 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5884 
                        return $instance->getQueryLog();
5885 
        }
5886 
                    /**
5887 
         * Clear the query log.
5888 
         *
5889 
         * @return void
5890 
         * @static
5891 
         */
5892 
        public static function flushQueryLog()
5893 
        {            //Method inherited from \Illuminate\Database\Connection
5894 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5895 
                        $instance->flushQueryLog();
5896 
        }
5897 
                    /**
5898 
         * Enable the query log on the connection.
5899 
         *
5900 
         * @return void
5901 
         * @static
5902 
         */
5903 
        public static function enableQueryLog()
5904 
        {            //Method inherited from \Illuminate\Database\Connection
5905 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5906 
                        $instance->enableQueryLog();
5907 
        }
5908 
                    /**
5909 
         * Disable the query log on the connection.
5910 
         *
5911 
         * @return void
5912 
         * @static
5913 
         */
5914 
        public static function disableQueryLog()
5915 
        {            //Method inherited from \Illuminate\Database\Connection
5916 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5917 
                        $instance->disableQueryLog();
5918 
        }
5919 
                    /**
5920 
         * Determine whether we're logging queries.
5921 
         *
5922 
         * @return bool
5923 
         * @static
5924 
         */
5925 
        public static function logging()
5926 
        {            //Method inherited from \Illuminate\Database\Connection
5927 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5928 
                        return $instance->logging();
5929 
        }
5930 
                    /**
5931 
         * Get the name of the connected database.
5932 
         *
5933 
         * @return string
5934 
         * @static
5935 
         */
5936 
        public static function getDatabaseName()
5937 
        {            //Method inherited from \Illuminate\Database\Connection
5938 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5939 
                        return $instance->getDatabaseName();
5940 
        }
5941 
                    /**
5942 
         * Set the name of the connected database.
5943 
         *
5944 
         * @param string $database
5945 
         * @return \Illuminate\Database\MySqlConnection
5946 
         * @static
5947 
         */
5948 
        public static function setDatabaseName($database)
5949 
        {            //Method inherited from \Illuminate\Database\Connection
5950 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5951 
                        return $instance->setDatabaseName($database);
5952 
        }
5953 
                    /**
5954 
         * Set the read / write type of the connection.
5955 
         *
5956 
         * @param string|null $readWriteType
5957 
         * @return \Illuminate\Database\MySqlConnection
5958 
         * @static
5959 
         */
5960 
        public static function setReadWriteType($readWriteType)
5961 
        {            //Method inherited from \Illuminate\Database\Connection
5962 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5963 
                        return $instance->setReadWriteType($readWriteType);
5964 
        }
5965 
                    /**
5966 
         * Get the table prefix for the connection.
5967 
         *
5968 
         * @return string
5969 
         * @static
5970 
         */
5971 
        public static function getTablePrefix()
5972 
        {            //Method inherited from \Illuminate\Database\Connection
5973 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5974 
                        return $instance->getTablePrefix();
5975 
        }
5976 
                    /**
5977 
         * Set the table prefix in use by the connection.
5978 
         *
5979 
         * @param string $prefix
5980 
         * @return \Illuminate\Database\MySqlConnection
5981 
         * @static
5982 
         */
5983 
        public static function setTablePrefix($prefix)
5984 
        {            //Method inherited from \Illuminate\Database\Connection
5985 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5986 
                        return $instance->setTablePrefix($prefix);
5987 
        }
5988 
                    /**
5989 
         * Set the table prefix and return the grammar.
5990 
         *
5991 
         * @param \Illuminate\Database\Grammar $grammar
5992 
         * @return \Illuminate\Database\Grammar
5993 
         * @static
5994 
         */
5995 
        public static function withTablePrefix($grammar)
5996 
        {            //Method inherited from \Illuminate\Database\Connection
5997 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
5998 
                        return $instance->withTablePrefix($grammar);
5999 
        }
6000 
                    /**
6001 
         * Register a connection resolver.
6002 
         *
6003 
         * @param string $driver
6004 
         * @param \Closure $callback
6005 
         * @return void
6006 
         * @static
6007 
         */
6008 
        public static function resolverFor($driver, $callback)
6009 
        {            //Method inherited from \Illuminate\Database\Connection
6010 
                        \Illuminate\Database\MySqlConnection::resolverFor($driver, $callback);
6011 
        }
6012 
                    /**
6013 
         * Get the connection resolver for the given driver.
6014 
         *
6015 
         * @param string $driver
6016 
         * @return mixed
6017 
         * @static
6018 
         */
6019 
        public static function getResolver($driver)
6020 
        {            //Method inherited from \Illuminate\Database\Connection
6021 
                        return \Illuminate\Database\MySqlConnection::getResolver($driver);
6022 
        }
6023 
                    /**
6024 
         * Execute a Closure within a transaction.
6025 
         *
6026 
         * @param \Closure $callback
6027 
         * @param int $attempts
6028 
         * @return mixed
6029 
         * @throws \Throwable
6030 
         * @static
6031 
         */
6032 
        public static function transaction($callback, $attempts = 1)
6033 
        {            //Method inherited from \Illuminate\Database\Connection
6034 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
6035 
                        return $instance->transaction($callback, $attempts);
6036 
        }
6037 
                    /**
6038 
         * Start a new database transaction.
6039 
         *
6040 
         * @return void
6041 
         * @throws \Throwable
6042 
         * @static
6043 
         */
6044 
        public static function beginTransaction()
6045 
        {            //Method inherited from \Illuminate\Database\Connection
6046 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
6047 
                        $instance->beginTransaction();
6048 
        }
6049 
                    /**
6050 
         * Commit the active database transaction.
6051 
         *
6052 
         * @return void
6053 
         * @throws \Throwable
6054 
         * @static
6055 
         */
6056 
        public static function commit()
6057 
        {            //Method inherited from \Illuminate\Database\Connection
6058 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
6059 
                        $instance->commit();
6060 
        }
6061 
                    /**
6062 
         * Rollback the active database transaction.
6063 
         *
6064 
         * @param int|null $toLevel
6065 
         * @return void
6066 
         * @throws \Throwable
6067 
         * @static
6068 
         */
6069 
        public static function rollBack($toLevel = null)
6070 
        {            //Method inherited from \Illuminate\Database\Connection
6071 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
6072 
                        $instance->rollBack($toLevel);
6073 
        }
6074 
                    /**
6075 
         * Get the number of active transactions.
6076 
         *
6077 
         * @return int
6078 
         * @static
6079 
         */
6080 
        public static function transactionLevel()
6081 
        {            //Method inherited from \Illuminate\Database\Connection
6082 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
6083 
                        return $instance->transactionLevel();
6084 
        }
6085 
                    /**
6086 
         * Execute the callback after a transaction commits.
6087 
         *
6088 
         * @param callable $callback
6089 
         * @return void
6090 
         * @throws \RuntimeException
6091 
         * @static
6092 
         */
6093 
        public static function afterCommit($callback)
6094 
        {            //Method inherited from \Illuminate\Database\Connection
6095 
                        /** @var \Illuminate\Database\MySqlConnection $instance */
6096 
                        $instance->afterCommit($callback);
6097 
        }
6098 
 
6099 
    }
6100 
            /**
6101 
     *
6102 
     *
6103 
     * @see \Illuminate\Events\Dispatcher
6104 
     * @see \Illuminate\Support\Testing\Fakes\EventFake
6105 
     */
6106 
        class Event {
6107 
                    /**
6108 
         * Register an event listener with the dispatcher.
6109 
         *
6110 
         * @param \Closure|string|array $events
6111 
         * @param \Closure|string|array|null $listener
6112 
         * @return void
6113 
         * @static
6114 
         */
6115 
        public static function listen($events, $listener = null)
6116 
        {
6117 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6118 
                        $instance->listen($events, $listener);
6119 
        }
6120 
                    /**
6121 
         * Determine if a given event has listeners.
6122 
         *
6123 
         * @param string $eventName
6124 
         * @return bool
6125 
         * @static
6126 
         */
6127 
        public static function hasListeners($eventName)
6128 
        {
6129 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6130 
                        return $instance->hasListeners($eventName);
6131 
        }
6132 
                    /**
6133 
         * Determine if the given event has any wildcard listeners.
6134 
         *
6135 
         * @param string $eventName
6136 
         * @return bool
6137 
         * @static
6138 
         */
6139 
        public static function hasWildcardListeners($eventName)
6140 
        {
6141 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6142 
                        return $instance->hasWildcardListeners($eventName);
6143 
        }
6144 
                    /**
6145 
         * Register an event and payload to be fired later.
6146 
         *
6147 
         * @param string $event
6148 
         * @param object|array $payload
6149 
         * @return void
6150 
         * @static
6151 
         */
6152 
        public static function push($event, $payload = [])
6153 
        {
6154 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6155 
                        $instance->push($event, $payload);
6156 
        }
6157 
                    /**
6158 
         * Flush a set of pushed events.
6159 
         *
6160 
         * @param string $event
6161 
         * @return void
6162 
         * @static
6163 
         */
6164 
        public static function flush($event)
6165 
        {
6166 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6167 
                        $instance->flush($event);
6168 
        }
6169 
                    /**
6170 
         * Register an event subscriber with the dispatcher.
6171 
         *
6172 
         * @param object|string $subscriber
6173 
         * @return void
6174 
         * @static
6175 
         */
6176 
        public static function subscribe($subscriber)
6177 
        {
6178 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6179 
                        $instance->subscribe($subscriber);
6180 
        }
6181 
                    /**
6182 
         * Fire an event until the first non-null response is returned.
6183 
         *
6184 
         * @param string|object $event
6185 
         * @param mixed $payload
6186 
         * @return array|null
6187 
         * @static
6188 
         */
6189 
        public static function until($event, $payload = [])
6190 
        {
6191 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6192 
                        return $instance->until($event, $payload);
6193 
        }
6194 
                    /**
6195 
         * Fire an event and call the listeners.
6196 
         *
6197 
         * @param string|object $event
6198 
         * @param mixed $payload
6199 
         * @param bool $halt
6200 
         * @return array|null
6201 
         * @static
6202 
         */
6203 
        public static function dispatch($event, $payload = [], $halt = false)
6204 
        {
6205 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6206 
                        return $instance->dispatch($event, $payload, $halt);
6207 
        }
6208 
                    /**
6209 
         * Get all of the listeners for a given event name.
6210 
         *
6211 
         * @param string $eventName
6212 
         * @return array
6213 
         * @static
6214 
         */
6215 
        public static function getListeners($eventName)
6216 
        {
6217 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6218 
                        return $instance->getListeners($eventName);
6219 
        }
6220 
                    /**
6221 
         * Register an event listener with the dispatcher.
6222 
         *
6223 
         * @param \Closure|string|array $listener
6224 
         * @param bool $wildcard
6225 
         * @return \Closure
6226 
         * @static
6227 
         */
6228 
        public static function makeListener($listener, $wildcard = false)
6229 
        {
6230 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6231 
                        return $instance->makeListener($listener, $wildcard);
6232 
        }
6233 
                    /**
6234 
         * Create a class based listener using the IoC container.
6235 
         *
6236 
         * @param string $listener
6237 
         * @param bool $wildcard
6238 
         * @return \Closure
6239 
         * @static
6240 
         */
6241 
        public static function createClassListener($listener, $wildcard = false)
6242 
        {
6243 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6244 
                        return $instance->createClassListener($listener, $wildcard);
6245 
        }
6246 
                    /**
6247 
         * Remove a set of listeners from the dispatcher.
6248 
         *
6249 
         * @param string $event
6250 
         * @return void
6251 
         * @static
6252 
         */
6253 
        public static function forget($event)
6254 
        {
6255 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6256 
                        $instance->forget($event);
6257 
        }
6258 
                    /**
6259 
         * Forget all of the pushed listeners.
6260 
         *
6261 
         * @return void
6262 
         * @static
6263 
         */
6264 
        public static function forgetPushed()
6265 
        {
6266 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6267 
                        $instance->forgetPushed();
6268 
        }
6269 
                    /**
6270 
         * Set the queue resolver implementation.
6271 
         *
6272 
         * @param callable $resolver
6273 
         * @return \Illuminate\Events\Dispatcher
6274 
         * @static
6275 
         */
6276 
        public static function setQueueResolver($resolver)
6277 
        {
6278 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6279 
                        return $instance->setQueueResolver($resolver);
6280 
        }
6281 
                    /**
6282 
         * Gets the raw, unprepared listeners.
6283 
         *
6284 
         * @return array
6285 
         * @static
6286 
         */
6287 
        public static function getRawListeners()
6288 
        {
6289 
                        /** @var \Illuminate\Events\Dispatcher $instance */
6290 
                        return $instance->getRawListeners();
6291 
        }
6292 
                    /**
6293 
         * Register a custom macro.
6294 
         *
6295 
         * @param string $name
6296 
         * @param object|callable $macro
6297 
         * @return void
6298 
         * @static
6299 
         */
6300 
        public static function macro($name, $macro)
6301 
        {
6302 
                        \Illuminate\Events\Dispatcher::macro($name, $macro);
6303 
        }
6304 
                    /**
6305 
         * Mix another object into the class.
6306 
         *
6307 
         * @param object $mixin
6308 
         * @param bool $replace
6309 
         * @return void
6310 
         * @throws \ReflectionException
6311 
         * @static
6312 
         */
6313 
        public static function mixin($mixin, $replace = true)
6314 
        {
6315 
                        \Illuminate\Events\Dispatcher::mixin($mixin, $replace);
6316 
        }
6317 
                    /**
6318 
         * Checks if macro is registered.
6319 
         *
6320 
         * @param string $name
6321 
         * @return bool
6322 
         * @static
6323 
         */
6324 
        public static function hasMacro($name)
6325 
        {
6326 
                        return \Illuminate\Events\Dispatcher::hasMacro($name);
6327 
        }
6328 
                    /**
6329 
         * Flush the existing macros.
6330 
         *
6331 
         * @return void
6332 
         * @static
6333 
         */
6334 
        public static function flushMacros()
6335 
        {
6336 
                        \Illuminate\Events\Dispatcher::flushMacros();
6337 
        }
6338 
                    /**
6339 
         * Specify the events that should be dispatched instead of faked.
6340 
         *
6341 
         * @param array|string $eventsToDispatch
6342 
         * @return \Illuminate\Support\Testing\Fakes\EventFake
6343 
         * @static
6344 
         */
6345 
        public static function except($eventsToDispatch)
6346 
        {
6347 
                        /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6348 
                        return $instance->except($eventsToDispatch);
6349 
        }
6350 
                    /**
6351 
         * Assert if an event has a listener attached to it.
6352 
         *
6353 
         * @param string $expectedEvent
6354 
         * @param string|array $expectedListener
6355 
         * @return void
6356 
         * @static
6357 
         */
6358 
        public static function assertListening($expectedEvent, $expectedListener)
6359 
        {
6360 
                        /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6361 
                        $instance->assertListening($expectedEvent, $expectedListener);
6362 
        }
6363 
                    /**
6364 
         * Assert if an event was dispatched based on a truth-test callback.
6365 
         *
6366 
         * @param string|\Closure $event
6367 
         * @param callable|int|null $callback
6368 
         * @return void
6369 
         * @static
6370 
         */
6371 
        public static function assertDispatched($event, $callback = null)
6372 
        {
6373 
                        /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6374 
                        $instance->assertDispatched($event, $callback);
6375 
        }
6376 
                    /**
6377 
         * Assert if an event was dispatched a number of times.
6378 
         *
6379 
         * @param string $event
6380 
         * @param int $times
6381 
         * @return void
6382 
         * @static
6383 
         */
6384 
        public static function assertDispatchedTimes($event, $times = 1)
6385 
        {
6386 
                        /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6387 
                        $instance->assertDispatchedTimes($event, $times);
6388 
        }
6389 
                    /**
6390 
         * Determine if an event was dispatched based on a truth-test callback.
6391 
         *
6392 
         * @param string|\Closure $event
6393 
         * @param callable|null $callback
6394 
         * @return void
6395 
         * @static
6396 
         */
6397 
        public static function assertNotDispatched($event, $callback = null)
6398 
        {
6399 
                        /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6400 
                        $instance->assertNotDispatched($event, $callback);
6401 
        }
6402 
                    /**
6403 
         * Assert that no events were dispatched.
6404 
         *
6405 
         * @return void
6406 
         * @static
6407 
         */
6408 
        public static function assertNothingDispatched()
6409 
        {
6410 
                        /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6411 
                        $instance->assertNothingDispatched();
6412 
        }
6413 
                    /**
6414 
         * Get all of the events matching a truth-test callback.
6415 
         *
6416 
         * @param string $event
6417 
         * @param callable|null $callback
6418 
         * @return \Illuminate\Support\Collection
6419 
         * @static
6420 
         */
6421 
        public static function dispatched($event, $callback = null)
6422 
        {
6423 
                        /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6424 
                        return $instance->dispatched($event, $callback);
6425 
        }
6426 
                    /**
6427 
         * Determine if the given event has been dispatched.
6428 
         *
6429 
         * @param string $event
6430 
         * @return bool
6431 
         * @static
6432 
         */
6433 
        public static function hasDispatched($event)
6434 
        {
6435 
                        /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6436 
                        return $instance->hasDispatched($event);
6437 
        }
6438 
 
6439 
    }
6440 
            /**
6441 
     *
6442 
     *
6443 
     * @see \Illuminate\Filesystem\Filesystem
6444 
     */
6445 
        class File {
6446 
                    /**
6447 
         * Determine if a file or directory exists.
6448 
         *
6449 
         * @param string $path
6450 
         * @return bool
6451 
         * @static
6452 
         */
6453 
        public static function exists($path)
6454 
        {
6455 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6456 
                        return $instance->exists($path);
6457 
        }
6458 
                    /**
6459 
         * Determine if a file or directory is missing.
6460 
         *
6461 
         * @param string $path
6462 
         * @return bool
6463 
         * @static
6464 
         */
6465 
        public static function missing($path)
6466 
        {
6467 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6468 
                        return $instance->missing($path);
6469 
        }
6470 
                    /**
6471 
         * Get the contents of a file.
6472 
         *
6473 
         * @param string $path
6474 
         * @param bool $lock
6475 
         * @return string
6476 
         * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
6477 
         * @static
6478 
         */
6479 
        public static function get($path, $lock = false)
6480 
        {
6481 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6482 
                        return $instance->get($path, $lock);
6483 
        }
6484 
                    /**
6485 
         * Get contents of a file with shared access.
6486 
         *
6487 
         * @param string $path
6488 
         * @return string
6489 
         * @static
6490 
         */
6491 
        public static function sharedGet($path)
6492 
        {
6493 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6494 
                        return $instance->sharedGet($path);
6495 
        }
6496 
                    /**
6497 
         * Get the returned value of a file.
6498 
         *
6499 
         * @param string $path
6500 
         * @param array $data
6501 
         * @return mixed
6502 
         * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
6503 
         * @static
6504 
         */
6505 
        public static function getRequire($path, $data = [])
6506 
        {
6507 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6508 
                        return $instance->getRequire($path, $data);
6509 
        }
6510 
                    /**
6511 
         * Require the given file once.
6512 
         *
6513 
         * @param string $path
6514 
         * @param array $data
6515 
         * @return mixed
6516 
         * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
6517 
         * @static
6518 
         */
6519 
        public static function requireOnce($path, $data = [])
6520 
        {
6521 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6522 
                        return $instance->requireOnce($path, $data);
6523 
        }
6524 
                    /**
6525 
         * Get the contents of a file one line at a time.
6526 
         *
6527 
         * @param string $path
6528 
         * @return \Illuminate\Support\LazyCollection
6529 
         * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
6530 
         * @static
6531 
         */
6532 
        public static function lines($path)
6533 
        {
6534 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6535 
                        return $instance->lines($path);
6536 
        }
6537 
                    /**
6538 
         * Get the hash of the file at the given path.
6539 
         *
6540 
         * @param string $path
6541 
         * @param string $algorithm
6542 
         * @return string
6543 
         * @static
6544 
         */
6545 
        public static function hash($path, $algorithm = 'md5')
6546 
        {
6547 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6548 
                        return $instance->hash($path, $algorithm);
6549 
        }
6550 
                    /**
6551 
         * Write the contents of a file.
6552 
         *
6553 
         * @param string $path
6554 
         * @param string $contents
6555 
         * @param bool $lock
6556 
         * @return int|bool
6557 
         * @static
6558 
         */
6559 
        public static function put($path, $contents, $lock = false)
6560 
        {
6561 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6562 
                        return $instance->put($path, $contents, $lock);
6563 
        }
6564 
                    /**
6565 
         * Write the contents of a file, replacing it atomically if it already exists.
6566 
         *
6567 
         * @param string $path
6568 
         * @param string $content
6569 
         * @param int|null $mode
6570 
         * @return void
6571 
         * @static
6572 
         */
6573 
        public static function replace($path, $content, $mode = null)
6574 
        {
6575 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6576 
                        $instance->replace($path, $content, $mode);
6577 
        }
6578 
                    /**
6579 
         * Replace a given string within a given file.
6580 
         *
6581 
         * @param array|string $search
6582 
         * @param array|string $replace
6583 
         * @param string $path
6584 
         * @return void
6585 
         * @static
6586 
         */
6587 
        public static function replaceInFile($search, $replace, $path)
6588 
        {
6589 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6590 
                        $instance->replaceInFile($search, $replace, $path);
6591 
        }
6592 
                    /**
6593 
         * Prepend to a file.
6594 
         *
6595 
         * @param string $path
6596 
         * @param string $data
6597 
         * @return int
6598 
         * @static
6599 
         */
6600 
        public static function prepend($path, $data)
6601 
        {
6602 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6603 
                        return $instance->prepend($path, $data);
6604 
        }
6605 
                    /**
6606 
         * Append to a file.
6607 
         *
6608 
         * @param string $path
6609 
         * @param string $data
6610 
         * @return int
6611 
         * @static
6612 
         */
6613 
        public static function append($path, $data)
6614 
        {
6615 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6616 
                        return $instance->append($path, $data);
6617 
        }
6618 
                    /**
6619 
         * Get or set UNIX mode of a file or directory.
6620 
         *
6621 
         * @param string $path
6622 
         * @param int|null $mode
6623 
         * @return mixed
6624 
         * @static
6625 
         */
6626 
        public static function chmod($path, $mode = null)
6627 
        {
6628 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6629 
                        return $instance->chmod($path, $mode);
6630 
        }
6631 
                    /**
6632 
         * Delete the file at a given path.
6633 
         *
6634 
         * @param string|array $paths
6635 
         * @return bool
6636 
         * @static
6637 
         */
6638 
        public static function delete($paths)
6639 
        {
6640 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6641 
                        return $instance->delete($paths);
6642 
        }
6643 
                    /**
6644 
         * Move a file to a new location.
6645 
         *
6646 
         * @param string $path
6647 
         * @param string $target
6648 
         * @return bool
6649 
         * @static
6650 
         */
6651 
        public static function move($path, $target)
6652 
        {
6653 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6654 
                        return $instance->move($path, $target);
6655 
        }
6656 
                    /**
6657 
         * Copy a file to a new location.
6658 
         *
6659 
         * @param string $path
6660 
         * @param string $target
6661 
         * @return bool
6662 
         * @static
6663 
         */
6664 
        public static function copy($path, $target)
6665 
        {
6666 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6667 
                        return $instance->copy($path, $target);
6668 
        }
6669 
                    /**
6670 
         * Create a symlink to the target file or directory. On Windows, a hard link is created if the target is a file.
6671 
         *
6672 
         * @param string $target
6673 
         * @param string $link
6674 
         * @return void
6675 
         * @static
6676 
         */
6677 
        public static function link($target, $link)
6678 
        {
6679 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6680 
                        $instance->link($target, $link);
6681 
        }
6682 
                    /**
6683 
         * Create a relative symlink to the target file or directory.
6684 
         *
6685 
         * @param string $target
6686 
         * @param string $link
6687 
         * @return void
6688 
         * @throws \RuntimeException
6689 
         * @static
6690 
         */
6691 
        public static function relativeLink($target, $link)
6692 
        {
6693 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6694 
                        $instance->relativeLink($target, $link);
6695 
        }
6696 
                    /**
6697 
         * Extract the file name from a file path.
6698 
         *
6699 
         * @param string $path
6700 
         * @return string
6701 
         * @static
6702 
         */
6703 
        public static function name($path)
6704 
        {
6705 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6706 
                        return $instance->name($path);
6707 
        }
6708 
                    /**
6709 
         * Extract the trailing name component from a file path.
6710 
         *
6711 
         * @param string $path
6712 
         * @return string
6713 
         * @static
6714 
         */
6715 
        public static function basename($path)
6716 
        {
6717 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6718 
                        return $instance->basename($path);
6719 
        }
6720 
                    /**
6721 
         * Extract the parent directory from a file path.
6722 
         *
6723 
         * @param string $path
6724 
         * @return string
6725 
         * @static
6726 
         */
6727 
        public static function dirname($path)
6728 
        {
6729 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6730 
                        return $instance->dirname($path);
6731 
        }
6732 
                    /**
6733 
         * Extract the file extension from a file path.
6734 
         *
6735 
         * @param string $path
6736 
         * @return string
6737 
         * @static
6738 
         */
6739 
        public static function extension($path)
6740 
        {
6741 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6742 
                        return $instance->extension($path);
6743 
        }
6744 
                    /**
6745 
         * Guess the file extension from the mime-type of a given file.
6746 
         *
6747 
         * @param string $path
6748 
         * @return string|null
6749 
         * @throws \RuntimeException
6750 
         * @static
6751 
         */
6752 
        public static function guessExtension($path)
6753 
        {
6754 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6755 
                        return $instance->guessExtension($path);
6756 
        }
6757 
                    /**
6758 
         * Get the file type of a given file.
6759 
         *
6760 
         * @param string $path
6761 
         * @return string
6762 
         * @static
6763 
         */
6764 
        public static function type($path)
6765 
        {
6766 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6767 
                        return $instance->type($path);
6768 
        }
6769 
                    /**
6770 
         * Get the mime-type of a given file.
6771 
         *
6772 
         * @param string $path
6773 
         * @return string|false
6774 
         * @static
6775 
         */
6776 
        public static function mimeType($path)
6777 
        {
6778 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6779 
                        return $instance->mimeType($path);
6780 
        }
6781 
                    /**
6782 
         * Get the file size of a given file.
6783 
         *
6784 
         * @param string $path
6785 
         * @return int
6786 
         * @static
6787 
         */
6788 
        public static function size($path)
6789 
        {
6790 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6791 
                        return $instance->size($path);
6792 
        }
6793 
                    /**
6794 
         * Get the file's last modification time.
6795 
         *
6796 
         * @param string $path
6797 
         * @return int
6798 
         * @static
6799 
         */
6800 
        public static function lastModified($path)
6801 
        {
6802 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6803 
                        return $instance->lastModified($path);
6804 
        }
6805 
                    /**
6806 
         * Determine if the given path is a directory.
6807 
         *
6808 
         * @param string $directory
6809 
         * @return bool
6810 
         * @static
6811 
         */
6812 
        public static function isDirectory($directory)
6813 
        {
6814 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6815 
                        return $instance->isDirectory($directory);
6816 
        }
6817 
                    /**
6818 
         * Determine if the given path is a directory that does not contain any other files or directories.
6819 
         *
6820 
         * @param string $directory
6821 
         * @param bool $ignoreDotFiles
6822 
         * @return bool
6823 
         * @static
6824 
         */
6825 
        public static function isEmptyDirectory($directory, $ignoreDotFiles = false)
6826 
        {
6827 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6828 
                        return $instance->isEmptyDirectory($directory, $ignoreDotFiles);
6829 
        }
6830 
                    /**
6831 
         * Determine if the given path is readable.
6832 
         *
6833 
         * @param string $path
6834 
         * @return bool
6835 
         * @static
6836 
         */
6837 
        public static function isReadable($path)
6838 
        {
6839 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6840 
                        return $instance->isReadable($path);
6841 
        }
6842 
                    /**
6843 
         * Determine if the given path is writable.
6844 
         *
6845 
         * @param string $path
6846 
         * @return bool
6847 
         * @static
6848 
         */
6849 
        public static function isWritable($path)
6850 
        {
6851 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6852 
                        return $instance->isWritable($path);
6853 
        }
6854 
                    /**
6855 
         * Determine if two files are the same by comparing their hashes.
6856 
         *
6857 
         * @param string $firstFile
6858 
         * @param string $secondFile
6859 
         * @return bool
6860 
         * @static
6861 
         */
6862 
        public static function hasSameHash($firstFile, $secondFile)
6863 
        {
6864 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6865 
                        return $instance->hasSameHash($firstFile, $secondFile);
6866 
        }
6867 
                    /**
6868 
         * Determine if the given path is a file.
6869 
         *
6870 
         * @param string $file
6871 
         * @return bool
6872 
         * @static
6873 
         */
6874 
        public static function isFile($file)
6875 
        {
6876 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6877 
                        return $instance->isFile($file);
6878 
        }
6879 
                    /**
6880 
         * Find path names matching a given pattern.
6881 
         *
6882 
         * @param string $pattern
6883 
         * @param int $flags
6884 
         * @return array
6885 
         * @static
6886 
         */
6887 
        public static function glob($pattern, $flags = 0)
6888 
        {
6889 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6890 
                        return $instance->glob($pattern, $flags);
6891 
        }
6892 
                    /**
6893 
         * Get an array of all files in a directory.
6894 
         *
6895 
         * @param string $directory
6896 
         * @param bool $hidden
6897 
         * @return \Symfony\Component\Finder\SplFileInfo[]
6898 
         * @static
6899 
         */
6900 
        public static function files($directory, $hidden = false)
6901 
        {
6902 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6903 
                        return $instance->files($directory, $hidden);
6904 
        }
6905 
                    /**
6906 
         * Get all of the files from the given directory (recursive).
6907 
         *
6908 
         * @param string $directory
6909 
         * @param bool $hidden
6910 
         * @return \Symfony\Component\Finder\SplFileInfo[]
6911 
         * @static
6912 
         */
6913 
        public static function allFiles($directory, $hidden = false)
6914 
        {
6915 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6916 
                        return $instance->allFiles($directory, $hidden);
6917 
        }
6918 
                    /**
6919 
         * Get all of the directories within a given directory.
6920 
         *
6921 
         * @param string $directory
6922 
         * @return array
6923 
         * @static
6924 
         */
6925 
        public static function directories($directory)
6926 
        {
6927 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6928 
                        return $instance->directories($directory);
6929 
        }
6930 
                    /**
6931 
         * Ensure a directory exists.
6932 
         *
6933 
         * @param string $path
6934 
         * @param int $mode
6935 
         * @param bool $recursive
6936 
         * @return void
6937 
         * @static
6938 
         */
6939 
        public static function ensureDirectoryExists($path, $mode = 493, $recursive = true)
6940 
        {
6941 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6942 
                        $instance->ensureDirectoryExists($path, $mode, $recursive);
6943 
        }
6944 
                    /**
6945 
         * Create a directory.
6946 
         *
6947 
         * @param string $path
6948 
         * @param int $mode
6949 
         * @param bool $recursive
6950 
         * @param bool $force
6951 
         * @return bool
6952 
         * @static
6953 
         */
6954 
        public static function makeDirectory($path, $mode = 493, $recursive = false, $force = false)
6955 
        {
6956 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6957 
                        return $instance->makeDirectory($path, $mode, $recursive, $force);
6958 
        }
6959 
                    /**
6960 
         * Move a directory.
6961 
         *
6962 
         * @param string $from
6963 
         * @param string $to
6964 
         * @param bool $overwrite
6965 
         * @return bool
6966 
         * @static
6967 
         */
6968 
        public static function moveDirectory($from, $to, $overwrite = false)
6969 
        {
6970 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6971 
                        return $instance->moveDirectory($from, $to, $overwrite);
6972 
        }
6973 
                    /**
6974 
         * Copy a directory from one location to another.
6975 
         *
6976 
         * @param string $directory
6977 
         * @param string $destination
6978 
         * @param int|null $options
6979 
         * @return bool
6980 
         * @static
6981 
         */
6982 
        public static function copyDirectory($directory, $destination, $options = null)
6983 
        {
6984 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
6985 
                        return $instance->copyDirectory($directory, $destination, $options);
6986 
        }
6987 
                    /**
6988 
         * Recursively delete a directory.
6989 
         *
6990 
         * The directory itself may be optionally preserved.
6991 
         *
6992 
         * @param string $directory
6993 
         * @param bool $preserve
6994 
         * @return bool
6995 
         * @static
6996 
         */
6997 
        public static function deleteDirectory($directory, $preserve = false)
6998 
        {
6999 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
7000 
                        return $instance->deleteDirectory($directory, $preserve);
7001 
        }
7002 
                    /**
7003 
         * Remove all of the directories within a given directory.
7004 
         *
7005 
         * @param string $directory
7006 
         * @return bool
7007 
         * @static
7008 
         */
7009 
        public static function deleteDirectories($directory)
7010 
        {
7011 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
7012 
                        return $instance->deleteDirectories($directory);
7013 
        }
7014 
                    /**
7015 
         * Empty the specified directory of all files and folders.
7016 
         *
7017 
         * @param string $directory
7018 
         * @return bool
7019 
         * @static
7020 
         */
7021 
        public static function cleanDirectory($directory)
7022 
        {
7023 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
7024 
                        return $instance->cleanDirectory($directory);
7025 
        }
7026 
                    /**
7027 
         * Apply the callback if the given "value" is (or resolves to) truthy.
7028 
         *
7029 
         * @template TWhenParameter
7030 
         * @template TWhenReturnType
7031 
         * @param \Illuminate\Filesystem\(\Closure($this):  TWhenParameter)|TWhenParameter|null  $value
7032 
         * @param \Illuminate\Filesystem\(callable($this,  TWhenParameter): TWhenReturnType)|null  $callback
7033 
         * @param \Illuminate\Filesystem\(callable($this,  TWhenParameter): TWhenReturnType)|null  $default
7034 
         * @return $this|\Illuminate\Filesystem\TWhenReturnType
7035 
         * @static
7036 
         */
7037 
        public static function when($value = null, $callback = null, $default = null)
7038 
        {
7039 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
7040 
                        return $instance->when($value, $callback, $default);
7041 
        }
7042 
                    /**
7043 
         * Apply the callback if the given "value" is (or resolves to) falsy.
7044 
         *
7045 
         * @template TUnlessParameter
7046 
         * @template TUnlessReturnType
7047 
         * @param \Illuminate\Filesystem\(\Closure($this):  TUnlessParameter)|TUnlessParameter|null  $value
7048 
         * @param \Illuminate\Filesystem\(callable($this,  TUnlessParameter): TUnlessReturnType)|null  $callback
7049 
         * @param \Illuminate\Filesystem\(callable($this,  TUnlessParameter): TUnlessReturnType)|null  $default
7050 
         * @return $this|\Illuminate\Filesystem\TUnlessReturnType
7051 
         * @static
7052 
         */
7053 
        public static function unless($value = null, $callback = null, $default = null)
7054 
        {
7055 
                        /** @var \Illuminate\Filesystem\Filesystem $instance */
7056 
                        return $instance->unless($value, $callback, $default);
7057 
        }
7058 
                    /**
7059 
         * Register a custom macro.
7060 
         *
7061 
         * @param string $name
7062 
         * @param object|callable $macro
7063 
         * @return void
7064 
         * @static
7065 
         */
7066 
        public static function macro($name, $macro)
7067 
        {
7068 
                        \Illuminate\Filesystem\Filesystem::macro($name, $macro);
7069 
        }
7070 
                    /**
7071 
         * Mix another object into the class.
7072 
         *
7073 
         * @param object $mixin
7074 
         * @param bool $replace
7075 
         * @return void
7076 
         * @throws \ReflectionException
7077 
         * @static
7078 
         */
7079 
        public static function mixin($mixin, $replace = true)
7080 
        {
7081 
                        \Illuminate\Filesystem\Filesystem::mixin($mixin, $replace);
7082 
        }
7083 
                    /**
7084 
         * Checks if macro is registered.
7085 
         *
7086 
         * @param string $name
7087 
         * @return bool
7088 
         * @static
7089 
         */
7090 
        public static function hasMacro($name)
7091 
        {
7092 
                        return \Illuminate\Filesystem\Filesystem::hasMacro($name);
7093 
        }
7094 
                    /**
7095 
         * Flush the existing macros.
7096 
         *
7097 
         * @return void
7098 
         * @static
7099 
         */
7100 
        public static function flushMacros()
7101 
        {
7102 
                        \Illuminate\Filesystem\Filesystem::flushMacros();
7103 
        }
7104 
 
7105 
    }
7106 
            /**
7107 
     *
7108 
     *
7109 
     * @see \Illuminate\Auth\Access\Gate
7110 
     */
7111 
        class Gate {
7112 
                    /**
7113 
         * Determine if a given ability has been defined.
7114 
         *
7115 
         * @param string|array $ability
7116 
         * @return bool
7117 
         * @static
7118 
         */
7119 
        public static function has($ability)
7120 
        {
7121 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7122 
                        return $instance->has($ability);
7123 
        }
7124 
                    /**
7125 
         * Perform an on-demand authorization check. Throw an authorization exception if the condition or callback is false.
7126 
         *
7127 
         * @param \Illuminate\Auth\Access\Response|\Closure|bool $condition
7128 
         * @param string|null $message
7129 
         * @param string|null $code
7130 
         * @return \Illuminate\Auth\Access\Response
7131 
         * @throws \Illuminate\Auth\Access\AuthorizationException
7132 
         * @static
7133 
         */
7134 
        public static function allowIf($condition, $message = null, $code = null)
7135 
        {
7136 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7137 
                        return $instance->allowIf($condition, $message, $code);
7138 
        }
7139 
                    /**
7140 
         * Perform an on-demand authorization check. Throw an authorization exception if the condition or callback is true.
7141 
         *
7142 
         * @param \Illuminate\Auth\Access\Response|\Closure|bool $condition
7143 
         * @param string|null $message
7144 
         * @param string|null $code
7145 
         * @return \Illuminate\Auth\Access\Response
7146 
         * @throws \Illuminate\Auth\Access\AuthorizationException
7147 
         * @static
7148 
         */
7149 
        public static function denyIf($condition, $message = null, $code = null)
7150 
        {
7151 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7152 
                        return $instance->denyIf($condition, $message, $code);
7153 
        }
7154 
                    /**
7155 
         * Define a new ability.
7156 
         *
7157 
         * @param string $ability
7158 
         * @param callable|array|string $callback
7159 
         * @return \Illuminate\Auth\Access\Gate
7160 
         * @throws \InvalidArgumentException
7161 
         * @static
7162 
         */
7163 
        public static function define($ability, $callback)
7164 
        {
7165 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7166 
                        return $instance->define($ability, $callback);
7167 
        }
7168 
                    /**
7169 
         * Define abilities for a resource.
7170 
         *
7171 
         * @param string $name
7172 
         * @param string $class
7173 
         * @param array|null $abilities
7174 
         * @return \Illuminate\Auth\Access\Gate
7175 
         * @static
7176 
         */
7177 
        public static function resource($name, $class, $abilities = null)
7178 
        {
7179 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7180 
                        return $instance->resource($name, $class, $abilities);
7181 
        }
7182 
                    /**
7183 
         * Define a policy class for a given class type.
7184 
         *
7185 
         * @param string $class
7186 
         * @param string $policy
7187 
         * @return \Illuminate\Auth\Access\Gate
7188 
         * @static
7189 
         */
7190 
        public static function policy($class, $policy)
7191 
        {
7192 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7193 
                        return $instance->policy($class, $policy);
7194 
        }
7195 
                    /**
7196 
         * Register a callback to run before all Gate checks.
7197 
         *
7198 
         * @param callable $callback
7199 
         * @return \Illuminate\Auth\Access\Gate
7200 
         * @static
7201 
         */
7202 
        public static function before($callback)
7203 
        {
7204 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7205 
                        return $instance->before($callback);
7206 
        }
7207 
                    /**
7208 
         * Register a callback to run after all Gate checks.
7209 
         *
7210 
         * @param callable $callback
7211 
         * @return \Illuminate\Auth\Access\Gate
7212 
         * @static
7213 
         */
7214 
        public static function after($callback)
7215 
        {
7216 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7217 
                        return $instance->after($callback);
7218 
        }
7219 
                    /**
7220 
         * Determine if the given ability should be granted for the current user.
7221 
         *
7222 
         * @param string $ability
7223 
         * @param array|mixed $arguments
7224 
         * @return bool
7225 
         * @static
7226 
         */
7227 
        public static function allows($ability, $arguments = [])
7228 
        {
7229 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7230 
                        return $instance->allows($ability, $arguments);
7231 
        }
7232 
                    /**
7233 
         * Determine if the given ability should be denied for the current user.
7234 
         *
7235 
         * @param string $ability
7236 
         * @param array|mixed $arguments
7237 
         * @return bool
7238 
         * @static
7239 
         */
7240 
        public static function denies($ability, $arguments = [])
7241 
        {
7242 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7243 
                        return $instance->denies($ability, $arguments);
7244 
        }
7245 
                    /**
7246 
         * Determine if all of the given abilities should be granted for the current user.
7247 
         *
7248 
         * @param \Illuminate\Auth\Access\iterable|string $abilities
7249 
         * @param array|mixed $arguments
7250 
         * @return bool
7251 
         * @static
7252 
         */
7253 
        public static function check($abilities, $arguments = [])
7254 
        {
7255 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7256 
                        return $instance->check($abilities, $arguments);
7257 
        }
7258 
                    /**
7259 
         * Determine if any one of the given abilities should be granted for the current user.
7260 
         *
7261 
         * @param \Illuminate\Auth\Access\iterable|string $abilities
7262 
         * @param array|mixed $arguments
7263 
         * @return bool
7264 
         * @static
7265 
         */
7266 
        public static function any($abilities, $arguments = [])
7267 
        {
7268 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7269 
                        return $instance->any($abilities, $arguments);
7270 
        }
7271 
                    /**
7272 
         * Determine if all of the given abilities should be denied for the current user.
7273 
         *
7274 
         * @param \Illuminate\Auth\Access\iterable|string $abilities
7275 
         * @param array|mixed $arguments
7276 
         * @return bool
7277 
         * @static
7278 
         */
7279 
        public static function none($abilities, $arguments = [])
7280 
        {
7281 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7282 
                        return $instance->none($abilities, $arguments);
7283 
        }
7284 
                    /**
7285 
         * Determine if the given ability should be granted for the current user.
7286 
         *
7287 
         * @param string $ability
7288 
         * @param array|mixed $arguments
7289 
         * @return \Illuminate\Auth\Access\Response
7290 
         * @throws \Illuminate\Auth\Access\AuthorizationException
7291 
         * @static
7292 
         */
7293 
        public static function authorize($ability, $arguments = [])
7294 
        {
7295 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7296 
                        return $instance->authorize($ability, $arguments);
7297 
        }
7298 
                    /**
7299 
         * Inspect the user for the given ability.
7300 
         *
7301 
         * @param string $ability
7302 
         * @param array|mixed $arguments
7303 
         * @return \Illuminate\Auth\Access\Response
7304 
         * @static
7305 
         */
7306 
        public static function inspect($ability, $arguments = [])
7307 
        {
7308 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7309 
                        return $instance->inspect($ability, $arguments);
7310 
        }
7311 
                    /**
7312 
         * Get the raw result from the authorization callback.
7313 
         *
7314 
         * @param string $ability
7315 
         * @param array|mixed $arguments
7316 
         * @return mixed
7317 
         * @throws \Illuminate\Auth\Access\AuthorizationException
7318 
         * @static
7319 
         */
7320 
        public static function raw($ability, $arguments = [])
7321 
        {
7322 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7323 
                        return $instance->raw($ability, $arguments);
7324 
        }
7325 
                    /**
7326 
         * Get a policy instance for a given class.
7327 
         *
7328 
         * @param object|string $class
7329 
         * @return mixed
7330 
         * @static
7331 
         */
7332 
        public static function getPolicyFor($class)
7333 
        {
7334 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7335 
                        return $instance->getPolicyFor($class);
7336 
        }
7337 
                    /**
7338 
         * Specify a callback to be used to guess policy names.
7339 
         *
7340 
         * @param callable $callback
7341 
         * @return \Illuminate\Auth\Access\Gate
7342 
         * @static
7343 
         */
7344 
        public static function guessPolicyNamesUsing($callback)
7345 
        {
7346 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7347 
                        return $instance->guessPolicyNamesUsing($callback);
7348 
        }
7349 
                    /**
7350 
         * Build a policy class instance of the given type.
7351 
         *
7352 
         * @param object|string $class
7353 
         * @return mixed
7354 
         * @throws \Illuminate\Contracts\Container\BindingResolutionException
7355 
         * @static
7356 
         */
7357 
        public static function resolvePolicy($class)
7358 
        {
7359 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7360 
                        return $instance->resolvePolicy($class);
7361 
        }
7362 
                    /**
7363 
         * Get a gate instance for the given user.
7364 
         *
7365 
         * @param \Illuminate\Contracts\Auth\Authenticatable|mixed $user
7366 
         * @return static
7367 
         * @static
7368 
         */
7369 
        public static function forUser($user)
7370 
        {
7371 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7372 
                        return $instance->forUser($user);
7373 
        }
7374 
                    /**
7375 
         * Get all of the defined abilities.
7376 
         *
7377 
         * @return array
7378 
         * @static
7379 
         */
7380 
        public static function abilities()
7381 
        {
7382 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7383 
                        return $instance->abilities();
7384 
        }
7385 
                    /**
7386 
         * Get all of the defined policies.
7387 
         *
7388 
         * @return array
7389 
         * @static
7390 
         */
7391 
        public static function policies()
7392 
        {
7393 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7394 
                        return $instance->policies();
7395 
        }
7396 
                    /**
7397 
         * Set the container instance used by the gate.
7398 
         *
7399 
         * @param \Illuminate\Contracts\Container\Container $container
7400 
         * @return \Illuminate\Auth\Access\Gate
7401 
         * @static
7402 
         */
7403 
        public static function setContainer($container)
7404 
        {
7405 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7406 
                        return $instance->setContainer($container);
7407 
        }
7408 
                    /**
7409 
         * Deny with a HTTP status code.
7410 
         *
7411 
         * @param int $status
7412 
         * @param string|null $message
7413 
         * @param int|null $code
7414 
         * @return \Illuminate\Auth\Access\Response
7415 
         * @static
7416 
         */
7417 
        public static function denyWithStatus($status, $message = null, $code = null)
7418 
        {
7419 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7420 
                        return $instance->denyWithStatus($status, $message, $code);
7421 
        }
7422 
                    /**
7423 
         * Deny with a 404 HTTP status code.
7424 
         *
7425 
         * @param string|null $message
7426 
         * @param int|null $code
7427 
         * @return \Illuminate\Auth\Access\Response
7428 
         * @static
7429 
         */
7430 
        public static function denyAsNotFound($message = null, $code = null)
7431 
        {
7432 
                        /** @var \Illuminate\Auth\Access\Gate $instance */
7433 
                        return $instance->denyAsNotFound($message, $code);
7434 
        }
7435 
 
7436 
    }
7437 
            /**
7438 
     *
7439 
     *
7440 
     * @see \Illuminate\Hashing\HashManager
7441 
     * @see \Illuminate\Hashing\AbstractHasher
7442 
     */
7443 
        class Hash {
7444 
                    /**
7445 
         * Create an instance of the Bcrypt hash Driver.
7446 
         *
7447 
         * @return \Illuminate\Hashing\BcryptHasher
7448 
         * @static
7449 
         */
7450 
        public static function createBcryptDriver()
7451 
        {
7452 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7453 
                        return $instance->createBcryptDriver();
7454 
        }
7455 
                    /**
7456 
         * Create an instance of the Argon2i hash Driver.
7457 
         *
7458 
         * @return \Illuminate\Hashing\ArgonHasher
7459 
         * @static
7460 
         */
7461 
        public static function createArgonDriver()
7462 
        {
7463 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7464 
                        return $instance->createArgonDriver();
7465 
        }
7466 
                    /**
7467 
         * Create an instance of the Argon2id hash Driver.
7468 
         *
7469 
         * @return \Illuminate\Hashing\Argon2IdHasher
7470 
         * @static
7471 
         */
7472 
        public static function createArgon2idDriver()
7473 
        {
7474 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7475 
                        return $instance->createArgon2idDriver();
7476 
        }
7477 
                    /**
7478 
         * Get information about the given hashed value.
7479 
         *
7480 
         * @param string $hashedValue
7481 
         * @return array
7482 
         * @static
7483 
         */
7484 
        public static function info($hashedValue)
7485 
        {
7486 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7487 
                        return $instance->info($hashedValue);
7488 
        }
7489 
                    /**
7490 
         * Hash the given value.
7491 
         *
7492 
         * @param string $value
7493 
         * @param array $options
7494 
         * @return string
7495 
         * @static
7496 
         */
7497 
        public static function make($value, $options = [])
7498 
        {
7499 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7500 
                        return $instance->make($value, $options);
7501 
        }
7502 
                    /**
7503 
         * Check the given plain value against a hash.
7504 
         *
7505 
         * @param string $value
7506 
         * @param string $hashedValue
7507 
         * @param array $options
7508 
         * @return bool
7509 
         * @static
7510 
         */
7511 
        public static function check($value, $hashedValue, $options = [])
7512 
        {
7513 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7514 
                        return $instance->check($value, $hashedValue, $options);
7515 
        }
7516 
                    /**
7517 
         * Check if the given hash has been hashed using the given options.
7518 
         *
7519 
         * @param string $hashedValue
7520 
         * @param array $options
7521 
         * @return bool
7522 
         * @static
7523 
         */
7524 
        public static function needsRehash($hashedValue, $options = [])
7525 
        {
7526 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7527 
                        return $instance->needsRehash($hashedValue, $options);
7528 
        }
7529 
                    /**
7530 
         * Get the default driver name.
7531 
         *
7532 
         * @return string
7533 
         * @static
7534 
         */
7535 
        public static function getDefaultDriver()
7536 
        {
7537 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7538 
                        return $instance->getDefaultDriver();
7539 
        }
7540 
                    /**
7541 
         * Get a driver instance.
7542 
         *
7543 
         * @param string|null $driver
7544 
         * @return mixed
7545 
         * @throws \InvalidArgumentException
7546 
         * @static
7547 
         */
7548 
        public static function driver($driver = null)
7549 
        {            //Method inherited from \Illuminate\Support\Manager
7550 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7551 
                        return $instance->driver($driver);
7552 
        }
7553 
                    /**
7554 
         * Register a custom driver creator Closure.
7555 
         *
7556 
         * @param string $driver
7557 
         * @param \Closure $callback
7558 
         * @return \Illuminate\Hashing\HashManager
7559 
         * @static
7560 
         */
7561 
        public static function extend($driver, $callback)
7562 
        {            //Method inherited from \Illuminate\Support\Manager
7563 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7564 
                        return $instance->extend($driver, $callback);
7565 
        }
7566 
                    /**
7567 
         * Get all of the created "drivers".
7568 
         *
7569 
         * @return array
7570 
         * @static
7571 
         */
7572 
        public static function getDrivers()
7573 
        {            //Method inherited from \Illuminate\Support\Manager
7574 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7575 
                        return $instance->getDrivers();
7576 
        }
7577 
                    /**
7578 
         * Get the container instance used by the manager.
7579 
         *
7580 
         * @return \Illuminate\Contracts\Container\Container
7581 
         * @static
7582 
         */
7583 
        public static function getContainer()
7584 
        {            //Method inherited from \Illuminate\Support\Manager
7585 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7586 
                        return $instance->getContainer();
7587 
        }
7588 
                    /**
7589 
         * Set the container instance used by the manager.
7590 
         *
7591 
         * @param \Illuminate\Contracts\Container\Container $container
7592 
         * @return \Illuminate\Hashing\HashManager
7593 
         * @static
7594 
         */
7595 
        public static function setContainer($container)
7596 
        {            //Method inherited from \Illuminate\Support\Manager
7597 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7598 
                        return $instance->setContainer($container);
7599 
        }
7600 
                    /**
7601 
         * Forget all of the resolved driver instances.
7602 
         *
7603 
         * @return \Illuminate\Hashing\HashManager
7604 
         * @static
7605 
         */
7606 
        public static function forgetDrivers()
7607 
        {            //Method inherited from \Illuminate\Support\Manager
7608 
                        /** @var \Illuminate\Hashing\HashManager $instance */
7609 
                        return $instance->forgetDrivers();
7610 
        }
7611 
 
7612 
    }
7613 
            /**
7614 
     *
7615 
     *
7616 
     * @method static \Illuminate\Http\Client\PendingRequest baseUrl(string $url)
7617 
     * @method static \Illuminate\Http\Client\PendingRequest withBody(string $content, string $contentType)
7618 
     * @method static \Illuminate\Http\Client\PendingRequest asJson()
7619 
     * @method static \Illuminate\Http\Client\PendingRequest asForm()
7620 
     * @method static \Illuminate\Http\Client\PendingRequest attach(string|array $name, string|resource $contents = '', string|null $filename = null, array $headers = [])
7621 
     * @method static \Illuminate\Http\Client\PendingRequest asMultipart()
7622 
     * @method static \Illuminate\Http\Client\PendingRequest bodyFormat(string $format)
7623 
     * @method static \Illuminate\Http\Client\PendingRequest contentType(string $contentType)
7624 
     * @method static \Illuminate\Http\Client\PendingRequest acceptJson()
7625 
     * @method static \Illuminate\Http\Client\PendingRequest accept(string $contentType)
7626 
     * @method static \Illuminate\Http\Client\PendingRequest withHeaders(array $headers)
7627 
     * @method static \Illuminate\Http\Client\PendingRequest withBasicAuth(string $username, string $password)
7628 
     * @method static \Illuminate\Http\Client\PendingRequest withDigestAuth(string $username, string $password)
7629 
     * @method static \Illuminate\Http\Client\PendingRequest withToken(string $token, string $type = 'Bearer')
7630 
     * @method static \Illuminate\Http\Client\PendingRequest withUserAgent(string $userAgent)
7631 
     * @method static \Illuminate\Http\Client\PendingRequest withUrlParameters(array $parameters = [])
7632 
     * @method static \Illuminate\Http\Client\PendingRequest withCookies(array $cookies, string $domain)
7633 
     * @method static \Illuminate\Http\Client\PendingRequest maxRedirects(int $max)
7634 
     * @method static \Illuminate\Http\Client\PendingRequest withoutRedirecting()
7635 
     * @method static \Illuminate\Http\Client\PendingRequest withoutVerifying()
7636 
     * @method static \Illuminate\Http\Client\PendingRequest sink(string|resource $to)
7637 
     * @method static \Illuminate\Http\Client\PendingRequest timeout(int $seconds)
7638 
     * @method static \Illuminate\Http\Client\PendingRequest connectTimeout(int $seconds)
7639 
     * @method static \Illuminate\Http\Client\PendingRequest retry(int $times, int $sleepMilliseconds = 0, callable|null $when = null, bool $throw = true)
7640 
     * @method static \Illuminate\Http\Client\PendingRequest withOptions(array $options)
7641 
     * @method static \Illuminate\Http\Client\PendingRequest withMiddleware(callable $middleware)
7642 
     * @method static \Illuminate\Http\Client\PendingRequest beforeSending(callable $callback)
7643 
     * @method static \Illuminate\Http\Client\PendingRequest throw(callable|null $callback = null)
7644 
     * @method static \Illuminate\Http\Client\PendingRequest throwIf(callable|bool $condition, callable|null $throwCallback = null)
7645 
     * @method static \Illuminate\Http\Client\PendingRequest throwUnless(bool $condition)
7646 
     * @method static \Illuminate\Http\Client\PendingRequest dump()
7647 
     * @method static \Illuminate\Http\Client\PendingRequest dd()
7648 
     * @method static \Illuminate\Http\Client\Response get(string $url, array|string|null $query = null)
7649 
     * @method static \Illuminate\Http\Client\Response head(string $url, array|string|null $query = null)
7650 
     * @method static \Illuminate\Http\Client\Response post(string $url, array $data = [])
7651 
     * @method static \Illuminate\Http\Client\Response patch(string $url, array $data = [])
7652 
     * @method static \Illuminate\Http\Client\Response put(string $url, array $data = [])
7653 
     * @method static \Illuminate\Http\Client\Response delete(string $url, array $data = [])
7654 
     * @method static array pool(callable $callback)
7655 
     * @method static \Illuminate\Http\Client\Response send(string $method, string $url, array $options = [])
7656 
     * @method static \GuzzleHttp\Client buildClient()
7657 
     * @method static \GuzzleHttp\Client createClient(\GuzzleHttp\HandlerStack $handlerStack)
7658 
     * @method static \GuzzleHttp\HandlerStack buildHandlerStack()
7659 
     * @method static \GuzzleHttp\HandlerStack pushHandlers(\GuzzleHttp\HandlerStack $handlerStack)
7660 
     * @method static \Closure buildBeforeSendingHandler()
7661 
     * @method static \Closure buildRecorderHandler()
7662 
     * @method static \Closure buildStubHandler()
7663 
     * @method static \GuzzleHttp\Psr7\RequestInterface runBeforeSendingCallbacks(\GuzzleHttp\Psr7\RequestInterface $request, array $options)
7664 
     * @method static array mergeOptions(array ...$options)
7665 
     * @method static \Illuminate\Http\Client\PendingRequest stub(callable $callback)
7666 
     * @method static \Illuminate\Http\Client\PendingRequest async(bool $async = true)
7667 
     * @method static \GuzzleHttp\Promise\PromiseInterface|null getPromise()
7668 
     * @method static \Illuminate\Http\Client\PendingRequest setClient(\GuzzleHttp\Client $client)
7669 
     * @method static \Illuminate\Http\Client\PendingRequest setHandler(callable $handler)
7670 
     * @method static array getOptions()
7671 
     * @method static \Illuminate\Http\Client\PendingRequest|mixed when(\Closure|mixed|null $value = null, callable|null $callback = null, callable|null $default = null)
7672 
     * @method static \Illuminate\Http\Client\PendingRequest|mixed unless(\Closure|mixed|null $value = null, callable|null $callback = null, callable|null $default = null)
7673 
     * @see \Illuminate\Http\Client\Factory
7674 
     */
7675 
        class Http {
7676 
                    /**
7677 
         * Create a new response instance for use during stubbing.
7678 
         *
7679 
         * @param array|string|null $body
7680 
         * @param int $status
7681 
         * @param array $headers
7682 
         * @return \GuzzleHttp\Promise\PromiseInterface
7683 
         * @static
7684 
         */
7685 
        public static function response($body = null, $status = 200, $headers = [])
7686 
        {
7687 
                        return \Illuminate\Http\Client\Factory::response($body, $status, $headers);
7688 
        }
7689 
                    /**
7690 
         * Get an invokable object that returns a sequence of responses in order for use during stubbing.
7691 
         *
7692 
         * @param array $responses
7693 
         * @return \Illuminate\Http\Client\ResponseSequence
7694 
         * @static
7695 
         */
7696 
        public static function sequence($responses = [])
7697 
        {
7698 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7699 
                        return $instance->sequence($responses);
7700 
        }
7701 
                    /**
7702 
         * Register a stub callable that will intercept requests and be able to return stub responses.
7703 
         *
7704 
         * @param callable|array|null $callback
7705 
         * @return \Illuminate\Http\Client\Factory
7706 
         * @static
7707 
         */
7708 
        public static function fake($callback = null)
7709 
        {
7710 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7711 
                        return $instance->fake($callback);
7712 
        }
7713 
                    /**
7714 
         * Register a response sequence for the given URL pattern.
7715 
         *
7716 
         * @param string $url
7717 
         * @return \Illuminate\Http\Client\ResponseSequence
7718 
         * @static
7719 
         */
7720 
        public static function fakeSequence($url = '*')
7721 
        {
7722 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7723 
                        return $instance->fakeSequence($url);
7724 
        }
7725 
                    /**
7726 
         * Stub the given URL using the given callback.
7727 
         *
7728 
         * @param string $url
7729 
         * @param \Illuminate\Http\Client\Response|\GuzzleHttp\Promise\PromiseInterface|callable $callback
7730 
         * @return \Illuminate\Http\Client\Factory
7731 
         * @static
7732 
         */
7733 
        public static function stubUrl($url, $callback)
7734 
        {
7735 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7736 
                        return $instance->stubUrl($url, $callback);
7737 
        }
7738 
                    /**
7739 
         * Indicate that an exception should be thrown if any request is not faked.
7740 
         *
7741 
         * @param bool $prevent
7742 
         * @return \Illuminate\Http\Client\Factory
7743 
         * @static
7744 
         */
7745 
        public static function preventStrayRequests($prevent = true)
7746 
        {
7747 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7748 
                        return $instance->preventStrayRequests($prevent);
7749 
        }
7750 
                    /**
7751 
         * Indicate that an exception should not be thrown if any request is not faked.
7752 
         *
7753 
         * @return \Illuminate\Http\Client\Factory
7754 
         * @static
7755 
         */
7756 
        public static function allowStrayRequests()
7757 
        {
7758 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7759 
                        return $instance->allowStrayRequests();
7760 
        }
7761 
                    /**
7762 
         * Record a request response pair.
7763 
         *
7764 
         * @param \Illuminate\Http\Client\Request $request
7765 
         * @param \Illuminate\Http\Client\Response $response
7766 
         * @return void
7767 
         * @static
7768 
         */
7769 
        public static function recordRequestResponsePair($request, $response)
7770 
        {
7771 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7772 
                        $instance->recordRequestResponsePair($request, $response);
7773 
        }
7774 
                    /**
7775 
         * Assert that a request / response pair was recorded matching a given truth test.
7776 
         *
7777 
         * @param callable $callback
7778 
         * @return void
7779 
         * @static
7780 
         */
7781 
        public static function assertSent($callback)
7782 
        {
7783 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7784 
                        $instance->assertSent($callback);
7785 
        }
7786 
                    /**
7787 
         * Assert that the given request was sent in the given order.
7788 
         *
7789 
         * @param array $callbacks
7790 
         * @return void
7791 
         * @static
7792 
         */
7793 
        public static function assertSentInOrder($callbacks)
7794 
        {
7795 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7796 
                        $instance->assertSentInOrder($callbacks);
7797 
        }
7798 
                    /**
7799 
         * Assert that a request / response pair was not recorded matching a given truth test.
7800 
         *
7801 
         * @param callable $callback
7802 
         * @return void
7803 
         * @static
7804 
         */
7805 
        public static function assertNotSent($callback)
7806 
        {
7807 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7808 
                        $instance->assertNotSent($callback);
7809 
        }
7810 
                    /**
7811 
         * Assert that no request / response pair was recorded.
7812 
         *
7813 
         * @return void
7814 
         * @static
7815 
         */
7816 
        public static function assertNothingSent()
7817 
        {
7818 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7819 
                        $instance->assertNothingSent();
7820 
        }
7821 
                    /**
7822 
         * Assert how many requests have been recorded.
7823 
         *
7824 
         * @param int $count
7825 
         * @return void
7826 
         * @static
7827 
         */
7828 
        public static function assertSentCount($count)
7829 
        {
7830 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7831 
                        $instance->assertSentCount($count);
7832 
        }
7833 
                    /**
7834 
         * Assert that every created response sequence is empty.
7835 
         *
7836 
         * @return void
7837 
         * @static
7838 
         */
7839 
        public static function assertSequencesAreEmpty()
7840 
        {
7841 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7842 
                        $instance->assertSequencesAreEmpty();
7843 
        }
7844 
                    /**
7845 
         * Get a collection of the request / response pairs matching the given truth test.
7846 
         *
7847 
         * @param callable $callback
7848 
         * @return \Illuminate\Support\Collection
7849 
         * @static
7850 
         */
7851 
        public static function recorded($callback = null)
7852 
        {
7853 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7854 
                        return $instance->recorded($callback);
7855 
        }
7856 
                    /**
7857 
         * Get the current event dispatcher implementation.
7858 
         *
7859 
         * @return \Illuminate\Contracts\Events\Dispatcher|null
7860 
         * @static
7861 
         */
7862 
        public static function getDispatcher()
7863 
        {
7864 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7865 
                        return $instance->getDispatcher();
7866 
        }
7867 
                    /**
7868 
         * Register a custom macro.
7869 
         *
7870 
         * @param string $name
7871 
         * @param object|callable $macro
7872 
         * @return void
7873 
         * @static
7874 
         */
7875 
        public static function macro($name, $macro)
7876 
        {
7877 
                        \Illuminate\Http\Client\Factory::macro($name, $macro);
7878 
        }
7879 
                    /**
7880 
         * Mix another object into the class.
7881 
         *
7882 
         * @param object $mixin
7883 
         * @param bool $replace
7884 
         * @return void
7885 
         * @throws \ReflectionException
7886 
         * @static
7887 
         */
7888 
        public static function mixin($mixin, $replace = true)
7889 
        {
7890 
                        \Illuminate\Http\Client\Factory::mixin($mixin, $replace);
7891 
        }
7892 
                    /**
7893 
         * Checks if macro is registered.
7894 
         *
7895 
         * @param string $name
7896 
         * @return bool
7897 
         * @static
7898 
         */
7899 
        public static function hasMacro($name)
7900 
        {
7901 
                        return \Illuminate\Http\Client\Factory::hasMacro($name);
7902 
        }
7903 
                    /**
7904 
         * Flush the existing macros.
7905 
         *
7906 
         * @return void
7907 
         * @static
7908 
         */
7909 
        public static function flushMacros()
7910 
        {
7911 
                        \Illuminate\Http\Client\Factory::flushMacros();
7912 
        }
7913 
                    /**
7914 
         * Dynamically handle calls to the class.
7915 
         *
7916 
         * @param string $method
7917 
         * @param array $parameters
7918 
         * @return mixed
7919 
         * @throws \BadMethodCallException
7920 
         * @static
7921 
         */
7922 
        public static function macroCall($method, $parameters)
7923 
        {
7924 
                        /** @var \Illuminate\Http\Client\Factory $instance */
7925 
                        return $instance->macroCall($method, $parameters);
7926 
        }
7927 
 
7928 
    }
7929 
            /**
7930 
     *
7931 
     *
7932 
     * @see \Illuminate\Translation\Translator
7933 
     */
7934 
        class Lang {
7935 
                    /**
7936 
         * Determine if a translation exists for a given locale.
7937 
         *
7938 
         * @param string $key
7939 
         * @param string|null $locale
7940 
         * @return bool
7941 
         * @static
7942 
         */
7943 
        public static function hasForLocale($key, $locale = null)
7944 
        {
7945 
                        /** @var \Illuminate\Translation\Translator $instance */
7946 
                        return $instance->hasForLocale($key, $locale);
7947 
        }
7948 
                    /**
7949 
         * Determine if a translation exists.
7950 
         *
7951 
         * @param string $key
7952 
         * @param string|null $locale
7953 
         * @param bool $fallback
7954 
         * @return bool
7955 
         * @static
7956 
         */
7957 
        public static function has($key, $locale = null, $fallback = true)
7958 
        {
7959 
                        /** @var \Illuminate\Translation\Translator $instance */
7960 
                        return $instance->has($key, $locale, $fallback);
7961 
        }
7962 
                    /**
7963 
         * Get the translation for the given key.
7964 
         *
7965 
         * @param string $key
7966 
         * @param array $replace
7967 
         * @param string|null $locale
7968 
         * @param bool $fallback
7969 
         * @return string|array
7970 
         * @static
7971 
         */
7972 
        public static function get($key, $replace = [], $locale = null, $fallback = true)
7973 
        {
7974 
                        /** @var \Illuminate\Translation\Translator $instance */
7975 
                        return $instance->get($key, $replace, $locale, $fallback);
7976 
        }
7977 
                    /**
7978 
         * Get a translation according to an integer value.
7979 
         *
7980 
         * @param string $key
7981 
         * @param \Countable|int|array $number
7982 
         * @param array $replace
7983 
         * @param string|null $locale
7984 
         * @return string
7985 
         * @static
7986 
         */
7987 
        public static function choice($key, $number, $replace = [], $locale = null)
7988 
        {
7989 
                        /** @var \Illuminate\Translation\Translator $instance */
7990 
                        return $instance->choice($key, $number, $replace, $locale);
7991 
        }
7992 
                    /**
7993 
         * Add translation lines to the given locale.
7994 
         *
7995 
         * @param array $lines
7996 
         * @param string $locale
7997 
         * @param string $namespace
7998 
         * @return void
7999 
         * @static
8000 
         */
8001 
        public static function addLines($lines, $locale, $namespace = '*')
8002 
        {
8003 
                        /** @var \Illuminate\Translation\Translator $instance */
8004 
                        $instance->addLines($lines, $locale, $namespace);
8005 
        }
8006 
                    /**
8007 
         * Load the specified language group.
8008 
         *
8009 
         * @param string $namespace
8010 
         * @param string $group
8011 
         * @param string $locale
8012 
         * @return void
8013 
         * @static
8014 
         */
8015 
        public static function load($namespace, $group, $locale)
8016 
        {
8017 
                        /** @var \Illuminate\Translation\Translator $instance */
8018 
                        $instance->load($namespace, $group, $locale);
8019 
        }
8020 
                    /**
8021 
         * Add a new namespace to the loader.
8022 
         *
8023 
         * @param string $namespace
8024 
         * @param string $hint
8025 
         * @return void
8026 
         * @static
8027 
         */
8028 
        public static function addNamespace($namespace, $hint)
8029 
        {
8030 
                        /** @var \Illuminate\Translation\Translator $instance */
8031 
                        $instance->addNamespace($namespace, $hint);
8032 
        }
8033 
                    /**
8034 
         * Add a new JSON path to the loader.
8035 
         *
8036 
         * @param string $path
8037 
         * @return void
8038 
         * @static
8039 
         */
8040 
        public static function addJsonPath($path)
8041 
        {
8042 
                        /** @var \Illuminate\Translation\Translator $instance */
8043 
                        $instance->addJsonPath($path);
8044 
        }
8045 
                    /**
8046 
         * Parse a key into namespace, group, and item.
8047 
         *
8048 
         * @param string $key
8049 
         * @return array
8050 
         * @static
8051 
         */
8052 
        public static function parseKey($key)
8053 
        {
8054 
                        /** @var \Illuminate\Translation\Translator $instance */
8055 
                        return $instance->parseKey($key);
8056 
        }
8057 
                    /**
8058 
         * Specify a callback that should be invoked to determined the applicable locale array.
8059 
         *
8060 
         * @param callable $callback
8061 
         * @return void
8062 
         * @static
8063 
         */
8064 
        public static function determineLocalesUsing($callback)
8065 
        {
8066 
                        /** @var \Illuminate\Translation\Translator $instance */
8067 
                        $instance->determineLocalesUsing($callback);
8068 
        }
8069 
                    /**
8070 
         * Get the message selector instance.
8071 
         *
8072 
         * @return \Illuminate\Translation\MessageSelector
8073 
         * @static
8074 
         */
8075 
        public static function getSelector()
8076 
        {
8077 
                        /** @var \Illuminate\Translation\Translator $instance */
8078 
                        return $instance->getSelector();
8079 
        }
8080 
                    /**
8081 
         * Set the message selector instance.
8082 
         *
8083 
         * @param \Illuminate\Translation\MessageSelector $selector
8084 
         * @return void
8085 
         * @static
8086 
         */
8087 
        public static function setSelector($selector)
8088 
        {
8089 
                        /** @var \Illuminate\Translation\Translator $instance */
8090 
                        $instance->setSelector($selector);
8091 
        }
8092 
                    /**
8093 
         * Get the language line loader implementation.
8094 
         *
8095 
         * @return \Illuminate\Contracts\Translation\Loader
8096 
         * @static
8097 
         */
8098 
        public static function getLoader()
8099 
        {
8100 
                        /** @var \Illuminate\Translation\Translator $instance */
8101 
                        return $instance->getLoader();
8102 
        }
8103 
                    /**
8104 
         * Get the default locale being used.
8105 
         *
8106 
         * @return string
8107 
         * @static
8108 
         */
8109 
        public static function locale()
8110 
        {
8111 
                        /** @var \Illuminate\Translation\Translator $instance */
8112 
                        return $instance->locale();
8113 
        }
8114 
                    /**
8115 
         * Get the default locale being used.
8116 
         *
8117 
         * @return string
8118 
         * @static
8119 
         */
8120 
        public static function getLocale()
8121 
        {
8122 
                        /** @var \Illuminate\Translation\Translator $instance */
8123 
                        return $instance->getLocale();
8124 
        }
8125 
                    /**
8126 
         * Set the default locale.
8127 
         *
8128 
         * @param string $locale
8129 
         * @return void
8130 
         * @throws \InvalidArgumentException
8131 
         * @static
8132 
         */
8133 
        public static function setLocale($locale)
8134 
        {
8135 
                        /** @var \Illuminate\Translation\Translator $instance */
8136 
                        $instance->setLocale($locale);
8137 
        }
8138 
                    /**
8139 
         * Get the fallback locale being used.
8140 
         *
8141 
         * @return string
8142 
         * @static
8143 
         */
8144 
        public static function getFallback()
8145 
        {
8146 
                        /** @var \Illuminate\Translation\Translator $instance */
8147 
                        return $instance->getFallback();
8148 
        }
8149 
                    /**
8150 
         * Set the fallback locale being used.
8151 
         *
8152 
         * @param string $fallback
8153 
         * @return void
8154 
         * @static
8155 
         */
8156 
        public static function setFallback($fallback)
8157 
        {
8158 
                        /** @var \Illuminate\Translation\Translator $instance */
8159 
                        $instance->setFallback($fallback);
8160 
        }
8161 
                    /**
8162 
         * Set the loaded translation groups.
8163 
         *
8164 
         * @param array $loaded
8165 
         * @return void
8166 
         * @static
8167 
         */
8168 
        public static function setLoaded($loaded)
8169 
        {
8170 
                        /** @var \Illuminate\Translation\Translator $instance */
8171 
                        $instance->setLoaded($loaded);
8172 
        }
8173 
                    /**
8174 
         * Add a handler to be executed in order to format a given class to a string during translation replacements.
8175 
         *
8176 
         * @param callable|string $class
8177 
         * @param callable|null $handler
8178 
         * @return void
8179 
         * @static
8180 
         */
8181 
        public static function stringable($class, $handler = null)
8182 
        {
8183 
                        /** @var \Illuminate\Translation\Translator $instance */
8184 
                        $instance->stringable($class, $handler);
8185 
        }
8186 
                    /**
8187 
         * Set the parsed value of a key.
8188 
         *
8189 
         * @param string $key
8190 
         * @param array $parsed
8191 
         * @return void
8192 
         * @static
8193 
         */
8194 
        public static function setParsedKey($key, $parsed)
8195 
        {            //Method inherited from \Illuminate\Support\NamespacedItemResolver
8196 
                        /** @var \Illuminate\Translation\Translator $instance */
8197 
                        $instance->setParsedKey($key, $parsed);
8198 
        }
8199 
                    /**
8200 
         * Flush the cache of parsed keys.
8201 
         *
8202 
         * @return void
8203 
         * @static
8204 
         */
8205 
        public static function flushParsedKeys()
8206 
        {            //Method inherited from \Illuminate\Support\NamespacedItemResolver
8207 
                        /** @var \Illuminate\Translation\Translator $instance */
8208 
                        $instance->flushParsedKeys();
8209 
        }
8210 
                    /**
8211 
         * Register a custom macro.
8212 
         *
8213 
         * @param string $name
8214 
         * @param object|callable $macro
8215 
         * @return void
8216 
         * @static
8217 
         */
8218 
        public static function macro($name, $macro)
8219 
        {
8220 
                        \Illuminate\Translation\Translator::macro($name, $macro);
8221 
        }
8222 
                    /**
8223 
         * Mix another object into the class.
8224 
         *
8225 
         * @param object $mixin
8226 
         * @param bool $replace
8227 
         * @return void
8228 
         * @throws \ReflectionException
8229 
         * @static
8230 
         */
8231 
        public static function mixin($mixin, $replace = true)
8232 
        {
8233 
                        \Illuminate\Translation\Translator::mixin($mixin, $replace);
8234 
        }
8235 
                    /**
8236 
         * Checks if macro is registered.
8237 
         *
8238 
         * @param string $name
8239 
         * @return bool
8240 
         * @static
8241 
         */
8242 
        public static function hasMacro($name)
8243 
        {
8244 
                        return \Illuminate\Translation\Translator::hasMacro($name);
8245 
        }
8246 
                    /**
8247 
         * Flush the existing macros.
8248 
         *
8249 
         * @return void
8250 
         * @static
8251 
         */
8252 
        public static function flushMacros()
8253 
        {
8254 
                        \Illuminate\Translation\Translator::flushMacros();
8255 
        }
8256 
 
8257 
    }
8258 
            /**
8259 
     *
8260 
     *
8261 
     * @method static void write(string $level, \Illuminate\Contracts\Support\Arrayable|\Illuminate\Contracts\Support\Jsonable|\Illuminate\Support\Stringable|array|string $message, array $context = [])
8262 
     * @method static \Illuminate\Log\Logger withContext(array $context = [])
8263 
     * @method static \Illuminate\Log\Logger withoutContext()
8264 
     * @method static void listen(\Closure $callback)
8265 
     * @method static \Psr\Log\LoggerInterface getLogger()
8266 
     * @method static \Illuminate\Contracts\Events\Dispatcher getEventDispatcher()
8267 
     * @method static void setEventDispatcher(\Illuminate\Contracts\Events\Dispatcher $dispatcher)
8268 
     * @see \Illuminate\Log\LogManager
8269 
     */
8270 
        class Log {
8271 
                    /**
8272 
         * Build an on-demand log channel.
8273 
         *
8274 
         * @param array $config
8275 
         * @return \Psr\Log\LoggerInterface
8276 
         * @static
8277 
         */
8278 
        public static function build($config)
8279 
        {
8280 
                        /** @var \Illuminate\Log\LogManager $instance */
8281 
                        return $instance->build($config);
8282 
        }
8283 
                    /**
8284 
         * Create a new, on-demand aggregate logger instance.
8285 
         *
8286 
         * @param array $channels
8287 
         * @param string|null $channel
8288 
         * @return \Psr\Log\LoggerInterface
8289 
         * @static
8290 
         */
8291 
        public static function stack($channels, $channel = null)
8292 
        {
8293 
                        /** @var \Illuminate\Log\LogManager $instance */
8294 
                        return $instance->stack($channels, $channel);
8295 
        }
8296 
                    /**
8297 
         * Get a log channel instance.
8298 
         *
8299 
         * @param string|null $channel
8300 
         * @return \Psr\Log\LoggerInterface
8301 
         * @static
8302 
         */
8303 
        public static function channel($channel = null)
8304 
        {
8305 
                        /** @var \Illuminate\Log\LogManager $instance */
8306 
                        return $instance->channel($channel);
8307 
        }
8308 
                    /**
8309 
         * Get a log driver instance.
8310 
         *
8311 
         * @param string|null $driver
8312 
         * @return \Psr\Log\LoggerInterface
8313 
         * @static
8314 
         */
8315 
        public static function driver($driver = null)
8316 
        {
8317 
                        /** @var \Illuminate\Log\LogManager $instance */
8318 
                        return $instance->driver($driver);
8319 
        }
8320 
                    /**
8321 
         * Share context across channels and stacks.
8322 
         *
8323 
         * @param array $context
8324 
         * @return \Illuminate\Log\LogManager
8325 
         * @static
8326 
         */
8327 
        public static function shareContext($context)
8328 
        {
8329 
                        /** @var \Illuminate\Log\LogManager $instance */
8330 
                        return $instance->shareContext($context);
8331 
        }
8332 
                    /**
8333 
         * The context shared across channels and stacks.
8334 
         *
8335 
         * @return array
8336 
         * @static
8337 
         */
8338 
        public static function sharedContext()
8339 
        {
8340 
                        /** @var \Illuminate\Log\LogManager $instance */
8341 
                        return $instance->sharedContext();
8342 
        }
8343 
                    /**
8344 
         * Flush the shared context.
8345 
         *
8346 
         * @return \Illuminate\Log\LogManager
8347 
         * @static
8348 
         */
8349 
        public static function flushSharedContext()
8350 
        {
8351 
                        /** @var \Illuminate\Log\LogManager $instance */
8352 
                        return $instance->flushSharedContext();
8353 
        }
8354 
                    /**
8355 
         * Get the default log driver name.
8356 
         *
8357 
         * @return string|null
8358 
         * @static
8359 
         */
8360 
        public static function getDefaultDriver()
8361 
        {
8362 
                        /** @var \Illuminate\Log\LogManager $instance */
8363 
                        return $instance->getDefaultDriver();
8364 
        }
8365 
                    /**
8366 
         * Set the default log driver name.
8367 
         *
8368 
         * @param string $name
8369 
         * @return void
8370 
         * @static
8371 
         */
8372 
        public static function setDefaultDriver($name)
8373 
        {
8374 
                        /** @var \Illuminate\Log\LogManager $instance */
8375 
                        $instance->setDefaultDriver($name);
8376 
        }
8377 
                    /**
8378 
         * Register a custom driver creator Closure.
8379 
         *
8380 
         * @param string $driver
8381 
         * @param \Closure $callback
8382 
         * @return \Illuminate\Log\LogManager
8383 
         * @static
8384 
         */
8385 
        public static function extend($driver, $callback)
8386 
        {
8387 
                        /** @var \Illuminate\Log\LogManager $instance */
8388 
                        return $instance->extend($driver, $callback);
8389 
        }
8390 
                    /**
8391 
         * Unset the given channel instance.
8392 
         *
8393 
         * @param string|null $driver
8394 
         * @return void
8395 
         * @static
8396 
         */
8397 
        public static function forgetChannel($driver = null)
8398 
        {
8399 
                        /** @var \Illuminate\Log\LogManager $instance */
8400 
                        $instance->forgetChannel($driver);
8401 
        }
8402 
                    /**
8403 
         * Get all of the resolved log channels.
8404 
         *
8405 
         * @return array
8406 
         * @static
8407 
         */
8408 
        public static function getChannels()
8409 
        {
8410 
                        /** @var \Illuminate\Log\LogManager $instance */
8411 
                        return $instance->getChannels();
8412 
        }
8413 
                    /**
8414 
         * System is unusable.
8415 
         *
8416 
         * @param string $message
8417 
         * @param array $context
8418 
         * @return void
8419 
         * @static
8420 
         */
8421 
        public static function emergency($message, $context = [])
8422 
        {
8423 
                        /** @var \Illuminate\Log\LogManager $instance */
8424 
                        $instance->emergency($message, $context);
8425 
        }
8426 
                    /**
8427 
         * Action must be taken immediately.
8428 
         *
8429 
         * Example: Entire website down, database unavailable, etc. This should
8430 
         * trigger the SMS alerts and wake you up.
8431 
         *
8432 
         * @param string $message
8433 
         * @param array $context
8434 
         * @return void
8435 
         * @static
8436 
         */
8437 
        public static function alert($message, $context = [])
8438 
        {
8439 
                        /** @var \Illuminate\Log\LogManager $instance */
8440 
                        $instance->alert($message, $context);
8441 
        }
8442 
                    /**
8443 
         * Critical conditions.
8444 
         *
8445 
         * Example: Application component unavailable, unexpected exception.
8446 
         *
8447 
         * @param string $message
8448 
         * @param array $context
8449 
         * @return void
8450 
         * @static
8451 
         */
8452 
        public static function critical($message, $context = [])
8453 
        {
8454 
                        /** @var \Illuminate\Log\LogManager $instance */
8455 
                        $instance->critical($message, $context);
8456 
        }
8457 
                    /**
8458 
         * Runtime errors that do not require immediate action but should typically
8459 
         * be logged and monitored.
8460 
         *
8461 
         * @param string $message
8462 
         * @param array $context
8463 
         * @return void
8464 
         * @static
8465 
         */
8466 
        public static function error($message, $context = [])
8467 
        {
8468 
                        /** @var \Illuminate\Log\LogManager $instance */
8469 
                        $instance->error($message, $context);
8470 
        }
8471 
                    /**
8472 
         * Exceptional occurrences that are not errors.
8473 
         *
8474 
         * Example: Use of deprecated APIs, poor use of an API, undesirable things
8475 
         * that are not necessarily wrong.
8476 
         *
8477 
         * @param string $message
8478 
         * @param array $context
8479 
         * @return void
8480 
         * @static
8481 
         */
8482 
        public static function warning($message, $context = [])
8483 
        {
8484 
                        /** @var \Illuminate\Log\LogManager $instance */
8485 
                        $instance->warning($message, $context);
8486 
        }
8487 
                    /**
8488 
         * Normal but significant events.
8489 
         *
8490 
         * @param string $message
8491 
         * @param array $context
8492 
         * @return void
8493 
         * @static
8494 
         */
8495 
        public static function notice($message, $context = [])
8496 
        {
8497 
                        /** @var \Illuminate\Log\LogManager $instance */
8498 
                        $instance->notice($message, $context);
8499 
        }
8500 
                    /**
8501 
         * Interesting events.
8502 
         *
8503 
         * Example: User logs in, SQL logs.
8504 
         *
8505 
         * @param string $message
8506 
         * @param array $context
8507 
         * @return void
8508 
         * @static
8509 
         */
8510 
        public static function info($message, $context = [])
8511 
        {
8512 
                        /** @var \Illuminate\Log\LogManager $instance */
8513 
                        $instance->info($message, $context);
8514 
        }
8515 
                    /**
8516 
         * Detailed debug information.
8517 
         *
8518 
         * @param string $message
8519 
         * @param array $context
8520 
         * @return void
8521 
         * @static
8522 
         */
8523 
        public static function debug($message, $context = [])
8524 
        {
8525 
                        /** @var \Illuminate\Log\LogManager $instance */
8526 
                        $instance->debug($message, $context);
8527 
        }
8528 
                    /**
8529 
         * Logs with an arbitrary level.
8530 
         *
8531 
         * @param mixed $level
8532 
         * @param string $message
8533 
         * @param array $context
8534 
         * @return void
8535 
         * @static
8536 
         */
8537 
        public static function log($level, $message, $context = [])
8538 
        {
8539 
                        /** @var \Illuminate\Log\LogManager $instance */
8540 
                        $instance->log($level, $message, $context);
8541 
        }
8542 
 
8543 
    }
8544 
            /**
8545 
     *
8546 
     *
8547 
     * @method static void alwaysFrom(string $address, string|null $name = null)
8548 
     * @method static void alwaysReplyTo(string $address, string|null $name = null)
8549 
     * @method static void alwaysReturnPath(string $address)
8550 
     * @method static void alwaysTo(string $address, string|null $name = null)
8551 
     * @method static \Illuminate\Mail\SentMessage|null html(string $html, mixed $callback)
8552 
     * @method static \Illuminate\Mail\SentMessage|null plain(string $view, array $data, mixed $callback)
8553 
     * @method static string render(string|array $view, array $data = [])
8554 
     * @method static mixed onQueue(string $queue, \Illuminate\Contracts\Mail\Mailable $view)
8555 
     * @method static mixed queueOn(string $queue, \Illuminate\Contracts\Mail\Mailable $view)
8556 
     * @method static mixed laterOn(string $queue, \DateTimeInterface|\DateInterval|int $delay, \Illuminate\Contracts\Mail\Mailable $view)
8557 
     * @method static \Symfony\Component\Mailer\Transport\TransportInterface getSymfonyTransport()
8558 
     * @method static \Illuminate\Contracts\View\Factory getViewFactory()
8559 
     * @method static void setSymfonyTransport(\Symfony\Component\Mailer\Transport\TransportInterface $transport)
8560 
     * @method static \Illuminate\Mail\Mailer setQueue(\Illuminate\Contracts\Queue\Factory $queue)
8561 
     * @method static void macro(string $name, object|callable $macro)
8562 
     * @method static void mixin(object $mixin, bool $replace = true)
8563 
     * @method static bool hasMacro(string $name)
8564 
     * @method static void flushMacros()
8565 
     * @see \Illuminate\Mail\MailManager
8566 
     * @see \Illuminate\Support\Testing\Fakes\MailFake
8567 
     */
8568 
        class Mail {
8569 
                    /**
8570 
         * Get a mailer instance by name.
8571 
         *
8572 
         * @param string|null $name
8573 
         * @return \Illuminate\Contracts\Mail\Mailer
8574 
         * @static
8575 
         */
8576 
        public static function mailer($name = null)
8577 
        {
8578 
                        /** @var \Illuminate\Mail\MailManager $instance */
8579 
                        return $instance->mailer($name);
8580 
        }
8581 
                    /**
8582 
         * Get a mailer driver instance.
8583 
         *
8584 
         * @param string|null $driver
8585 
         * @return \Illuminate\Mail\Mailer
8586 
         * @static
8587 
         */
8588 
        public static function driver($driver = null)
8589 
        {
8590 
                        /** @var \Illuminate\Mail\MailManager $instance */
8591 
                        return $instance->driver($driver);
8592 
        }
8593 
                    /**
8594 
         * Create a new transport instance.
8595 
         *
8596 
         * @param array $config
8597 
         * @return \Symfony\Component\Mailer\Transport\TransportInterface
8598 
         * @throws \InvalidArgumentException
8599 
         * @static
8600 
         */
8601 
        public static function createSymfonyTransport($config)
8602 
        {
8603 
                        /** @var \Illuminate\Mail\MailManager $instance */
8604 
                        return $instance->createSymfonyTransport($config);
8605 
        }
8606 
                    /**
8607 
         * Get the default mail driver name.
8608 
         *
8609 
         * @return string
8610 
         * @static
8611 
         */
8612 
        public static function getDefaultDriver()
8613 
        {
8614 
                        /** @var \Illuminate\Mail\MailManager $instance */
8615 
                        return $instance->getDefaultDriver();
8616 
        }
8617 
                    /**
8618 
         * Set the default mail driver name.
8619 
         *
8620 
         * @param string $name
8621 
         * @return void
8622 
         * @static
8623 
         */
8624 
        public static function setDefaultDriver($name)
8625 
        {
8626 
                        /** @var \Illuminate\Mail\MailManager $instance */
8627 
                        $instance->setDefaultDriver($name);
8628 
        }
8629 
                    /**
8630 
         * Disconnect the given mailer and remove from local cache.
8631 
         *
8632 
         * @param string|null $name
8633 
         * @return void
8634 
         * @static
8635 
         */
8636 
        public static function purge($name = null)
8637 
        {
8638 
                        /** @var \Illuminate\Mail\MailManager $instance */
8639 
                        $instance->purge($name);
8640 
        }
8641 
                    /**
8642 
         * Register a custom transport creator Closure.
8643 
         *
8644 
         * @param string $driver
8645 
         * @param \Closure $callback
8646 
         * @return \Illuminate\Mail\MailManager
8647 
         * @static
8648 
         */
8649 
        public static function extend($driver, $callback)
8650 
        {
8651 
                        /** @var \Illuminate\Mail\MailManager $instance */
8652 
                        return $instance->extend($driver, $callback);
8653 
        }
8654 
                    /**
8655 
         * Get the application instance used by the manager.
8656 
         *
8657 
         * @return \Illuminate\Contracts\Foundation\Application
8658 
         * @static
8659 
         */
8660 
        public static function getApplication()
8661 
        {
8662 
                        /** @var \Illuminate\Mail\MailManager $instance */
8663 
                        return $instance->getApplication();
8664 
        }
8665 
                    /**
8666 
         * Set the application instance used by the manager.
8667 
         *
8668 
         * @param \Illuminate\Contracts\Foundation\Application $app
8669 
         * @return \Illuminate\Mail\MailManager
8670 
         * @static
8671 
         */
8672 
        public static function setApplication($app)
8673 
        {
8674 
                        /** @var \Illuminate\Mail\MailManager $instance */
8675 
                        return $instance->setApplication($app);
8676 
        }
8677 
                    /**
8678 
         * Forget all of the resolved mailer instances.
8679 
         *
8680 
         * @return \Illuminate\Mail\MailManager
8681 
         * @static
8682 
         */
8683 
        public static function forgetMailers()
8684 
        {
8685 
                        /** @var \Illuminate\Mail\MailManager $instance */
8686 
                        return $instance->forgetMailers();
8687 
        }
8688 
                    /**
8689 
         * Assert if a mailable was sent based on a truth-test callback.
8690 
         *
8691 
         * @param string|\Closure $mailable
8692 
         * @param callable|int|null $callback
8693 
         * @return void
8694 
         * @static
8695 
         */
8696 
        public static function assertSent($mailable, $callback = null)
8697 
        {
8698 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8699 
                        $instance->assertSent($mailable, $callback);
8700 
        }
8701 
                    /**
8702 
         * Determine if a mailable was not sent or queued to be sent based on a truth-test callback.
8703 
         *
8704 
         * @param string|\Closure $mailable
8705 
         * @param callable|null $callback
8706 
         * @return void
8707 
         * @static
8708 
         */
8709 
        public static function assertNotOutgoing($mailable, $callback = null)
8710 
        {
8711 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8712 
                        $instance->assertNotOutgoing($mailable, $callback);
8713 
        }
8714 
                    /**
8715 
         * Determine if a mailable was not sent based on a truth-test callback.
8716 
         *
8717 
         * @param string|\Closure $mailable
8718 
         * @param callable|null $callback
8719 
         * @return void
8720 
         * @static
8721 
         */
8722 
        public static function assertNotSent($mailable, $callback = null)
8723 
        {
8724 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8725 
                        $instance->assertNotSent($mailable, $callback);
8726 
        }
8727 
                    /**
8728 
         * Assert that no mailables were sent or queued to be sent.
8729 
         *
8730 
         * @return void
8731 
         * @static
8732 
         */
8733 
        public static function assertNothingOutgoing()
8734 
        {
8735 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8736 
                        $instance->assertNothingOutgoing();
8737 
        }
8738 
                    /**
8739 
         * Assert that no mailables were sent.
8740 
         *
8741 
         * @return void
8742 
         * @static
8743 
         */
8744 
        public static function assertNothingSent()
8745 
        {
8746 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8747 
                        $instance->assertNothingSent();
8748 
        }
8749 
                    /**
8750 
         * Assert if a mailable was queued based on a truth-test callback.
8751 
         *
8752 
         * @param string|\Closure $mailable
8753 
         * @param callable|int|null $callback
8754 
         * @return void
8755 
         * @static
8756 
         */
8757 
        public static function assertQueued($mailable, $callback = null)
8758 
        {
8759 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8760 
                        $instance->assertQueued($mailable, $callback);
8761 
        }
8762 
                    /**
8763 
         * Determine if a mailable was not queued based on a truth-test callback.
8764 
         *
8765 
         * @param string|\Closure $mailable
8766 
         * @param callable|null $callback
8767 
         * @return void
8768 
         * @static
8769 
         */
8770 
        public static function assertNotQueued($mailable, $callback = null)
8771 
        {
8772 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8773 
                        $instance->assertNotQueued($mailable, $callback);
8774 
        }
8775 
                    /**
8776 
         * Assert that no mailables were queued.
8777 
         *
8778 
         * @return void
8779 
         * @static
8780 
         */
8781 
        public static function assertNothingQueued()
8782 
        {
8783 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8784 
                        $instance->assertNothingQueued();
8785 
        }
8786 
                    /**
8787 
         * Get all of the mailables matching a truth-test callback.
8788 
         *
8789 
         * @param string|\Closure $mailable
8790 
         * @param callable|null $callback
8791 
         * @return \Illuminate\Support\Collection
8792 
         * @static
8793 
         */
8794 
        public static function sent($mailable, $callback = null)
8795 
        {
8796 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8797 
                        return $instance->sent($mailable, $callback);
8798 
        }
8799 
                    /**
8800 
         * Determine if the given mailable has been sent.
8801 
         *
8802 
         * @param string $mailable
8803 
         * @return bool
8804 
         * @static
8805 
         */
8806 
        public static function hasSent($mailable)
8807 
        {
8808 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8809 
                        return $instance->hasSent($mailable);
8810 
        }
8811 
                    /**
8812 
         * Get all of the queued mailables matching a truth-test callback.
8813 
         *
8814 
         * @param string|\Closure $mailable
8815 
         * @param callable|null $callback
8816 
         * @return \Illuminate\Support\Collection
8817 
         * @static
8818 
         */
8819 
        public static function queued($mailable, $callback = null)
8820 
        {
8821 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8822 
                        return $instance->queued($mailable, $callback);
8823 
        }
8824 
                    /**
8825 
         * Determine if the given mailable has been queued.
8826 
         *
8827 
         * @param string $mailable
8828 
         * @return bool
8829 
         * @static
8830 
         */
8831 
        public static function hasQueued($mailable)
8832 
        {
8833 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8834 
                        return $instance->hasQueued($mailable);
8835 
        }
8836 
                    /**
8837 
         * Begin the process of mailing a mailable class instance.
8838 
         *
8839 
         * @param mixed $users
8840 
         * @return \Illuminate\Mail\PendingMail
8841 
         * @static
8842 
         */
8843 
        public static function to($users)
8844 
        {
8845 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8846 
                        return $instance->to($users);
8847 
        }
8848 
                    /**
8849 
         * Begin the process of mailing a mailable class instance.
8850 
         *
8851 
         * @param mixed $users
8852 
         * @return \Illuminate\Mail\PendingMail
8853 
         * @static
8854 
         */
8855 
        public static function cc($users)
8856 
        {
8857 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8858 
                        return $instance->cc($users);
8859 
        }
8860 
                    /**
8861 
         * Begin the process of mailing a mailable class instance.
8862 
         *
8863 
         * @param mixed $users
8864 
         * @return \Illuminate\Mail\PendingMail
8865 
         * @static
8866 
         */
8867 
        public static function bcc($users)
8868 
        {
8869 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8870 
                        return $instance->bcc($users);
8871 
        }
8872 
                    /**
8873 
         * Send a new message with only a raw text part.
8874 
         *
8875 
         * @param string $text
8876 
         * @param \Closure|string $callback
8877 
         * @return void
8878 
         * @static
8879 
         */
8880 
        public static function raw($text, $callback)
8881 
        {
8882 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8883 
                        $instance->raw($text, $callback);
8884 
        }
8885 
                    /**
8886 
         * Send a new message using a view.
8887 
         *
8888 
         * @param \Illuminate\Contracts\Mail\Mailable|string|array $view
8889 
         * @param array $data
8890 
         * @param \Closure|string|null $callback
8891 
         * @return void
8892 
         * @static
8893 
         */
8894 
        public static function send($view, $data = [], $callback = null)
8895 
        {
8896 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8897 
                        $instance->send($view, $data, $callback);
8898 
        }
8899 
                    /**
8900 
         * Queue a new e-mail message for sending.
8901 
         *
8902 
         * @param \Illuminate\Contracts\Mail\Mailable|string|array $view
8903 
         * @param string|null $queue
8904 
         * @return mixed
8905 
         * @static
8906 
         */
8907 
        public static function queue($view, $queue = null)
8908 
        {
8909 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8910 
                        return $instance->queue($view, $queue);
8911 
        }
8912 
                    /**
8913 
         * Queue a new e-mail message for sending after (n) seconds.
8914 
         *
8915 
         * @param \DateTimeInterface|\DateInterval|int $delay
8916 
         * @param \Illuminate\Contracts\Mail\Mailable|string|array $view
8917 
         * @param string|null $queue
8918 
         * @return mixed
8919 
         * @static
8920 
         */
8921 
        public static function later($delay, $view, $queue = null)
8922 
        {
8923 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8924 
                        return $instance->later($delay, $view, $queue);
8925 
        }
8926 
                    /**
8927 
         * Get the array of failed recipients.
8928 
         *
8929 
         * @return array
8930 
         * @static
8931 
         */
8932 
        public static function failures()
8933 
        {
8934 
                        /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8935 
                        return $instance->failures();
8936 
        }
8937 
 
8938 
    }
8939 
            /**
8940 
     *
8941 
     *
8942 
     * @see \Illuminate\Notifications\ChannelManager
8943 
     * @see \Illuminate\Support\Testing\Fakes\NotificationFake
8944 
     */
8945 
        class Notification {
8946 
                    /**
8947 
         * Send the given notification to the given notifiable entities.
8948 
         *
8949 
         * @param \Illuminate\Support\Collection|array|mixed $notifiables
8950 
         * @param mixed $notification
8951 
         * @return void
8952 
         * @static
8953 
         */
8954 
        public static function send($notifiables, $notification)
8955 
        {
8956 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
8957 
                        $instance->send($notifiables, $notification);
8958 
        }
8959 
                    /**
8960 
         * Send the given notification immediately.
8961 
         *
8962 
         * @param \Illuminate\Support\Collection|array|mixed $notifiables
8963 
         * @param mixed $notification
8964 
         * @param array|null $channels
8965 
         * @return void
8966 
         * @static
8967 
         */
8968 
        public static function sendNow($notifiables, $notification, $channels = null)
8969 
        {
8970 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
8971 
                        $instance->sendNow($notifiables, $notification, $channels);
8972 
        }
8973 
                    /**
8974 
         * Get a channel instance.
8975 
         *
8976 
         * @param string|null $name
8977 
         * @return mixed
8978 
         * @static
8979 
         */
8980 
        public static function channel($name = null)
8981 
        {
8982 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
8983 
                        return $instance->channel($name);
8984 
        }
8985 
                    /**
8986 
         * Get the default channel driver name.
8987 
         *
8988 
         * @return string
8989 
         * @static
8990 
         */
8991 
        public static function getDefaultDriver()
8992 
        {
8993 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
8994 
                        return $instance->getDefaultDriver();
8995 
        }
8996 
                    /**
8997 
         * Get the default channel driver name.
8998 
         *
8999 
         * @return string
9000 
         * @static
9001 
         */
9002 
        public static function deliversVia()
9003 
        {
9004 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
9005 
                        return $instance->deliversVia();
9006 
        }
9007 
                    /**
9008 
         * Set the default channel driver name.
9009 
         *
9010 
         * @param string $channel
9011 
         * @return void
9012 
         * @static
9013 
         */
9014 
        public static function deliverVia($channel)
9015 
        {
9016 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
9017 
                        $instance->deliverVia($channel);
9018 
        }
9019 
                    /**
9020 
         * Set the locale of notifications.
9021 
         *
9022 
         * @param string $locale
9023 
         * @return \Illuminate\Notifications\ChannelManager
9024 
         * @static
9025 
         */
9026 
        public static function locale($locale)
9027 
        {
9028 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
9029 
                        return $instance->locale($locale);
9030 
        }
9031 
                    /**
9032 
         * Get a driver instance.
9033 
         *
9034 
         * @param string|null $driver
9035 
         * @return mixed
9036 
         * @throws \InvalidArgumentException
9037 
         * @static
9038 
         */
9039 
        public static function driver($driver = null)
9040 
        {            //Method inherited from \Illuminate\Support\Manager
9041 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
9042 
                        return $instance->driver($driver);
9043 
        }
9044 
                    /**
9045 
         * Register a custom driver creator Closure.
9046 
         *
9047 
         * @param string $driver
9048 
         * @param \Closure $callback
9049 
         * @return \Illuminate\Notifications\ChannelManager
9050 
         * @static
9051 
         */
9052 
        public static function extend($driver, $callback)
9053 
        {            //Method inherited from \Illuminate\Support\Manager
9054 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
9055 
                        return $instance->extend($driver, $callback);
9056 
        }
9057 
                    /**
9058 
         * Get all of the created "drivers".
9059 
         *
9060 
         * @return array
9061 
         * @static
9062 
         */
9063 
        public static function getDrivers()
9064 
        {            //Method inherited from \Illuminate\Support\Manager
9065 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
9066 
                        return $instance->getDrivers();
9067 
        }
9068 
                    /**
9069 
         * Get the container instance used by the manager.
9070 
         *
9071 
         * @return \Illuminate\Contracts\Container\Container
9072 
         * @static
9073 
         */
9074 
        public static function getContainer()
9075 
        {            //Method inherited from \Illuminate\Support\Manager
9076 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
9077 
                        return $instance->getContainer();
9078 
        }
9079 
                    /**
9080 
         * Set the container instance used by the manager.
9081 
         *
9082 
         * @param \Illuminate\Contracts\Container\Container $container
9083 
         * @return \Illuminate\Notifications\ChannelManager
9084 
         * @static
9085 
         */
9086 
        public static function setContainer($container)
9087 
        {            //Method inherited from \Illuminate\Support\Manager
9088 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
9089 
                        return $instance->setContainer($container);
9090 
        }
9091 
                    /**
9092 
         * Forget all of the resolved driver instances.
9093 
         *
9094 
         * @return \Illuminate\Notifications\ChannelManager
9095 
         * @static
9096 
         */
9097 
        public static function forgetDrivers()
9098 
        {            //Method inherited from \Illuminate\Support\Manager
9099 
                        /** @var \Illuminate\Notifications\ChannelManager $instance */
9100 
                        return $instance->forgetDrivers();
9101 
        }
9102 
                    /**
9103 
         * Assert if a notification was sent on-demand based on a truth-test callback.
9104 
         *
9105 
         * @param string|\Closure $notification
9106 
         * @param callable|null $callback
9107 
         * @return void
9108 
         * @throws \Exception
9109 
         * @static
9110 
         */
9111 
        public static function assertSentOnDemand($notification, $callback = null)
9112 
        {
9113 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9114 
                        $instance->assertSentOnDemand($notification, $callback);
9115 
        }
9116 
                    /**
9117 
         * Assert if a notification was sent based on a truth-test callback.
9118 
         *
9119 
         * @param mixed $notifiable
9120 
         * @param string|\Closure $notification
9121 
         * @param callable|null $callback
9122 
         * @return void
9123 
         * @throws \Exception
9124 
         * @static
9125 
         */
9126 
        public static function assertSentTo($notifiable, $notification, $callback = null)
9127 
        {
9128 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9129 
                        $instance->assertSentTo($notifiable, $notification, $callback);
9130 
        }
9131 
                    /**
9132 
         * Assert if a notification was sent on-demand a number of times.
9133 
         *
9134 
         * @param string $notification
9135 
         * @param int $times
9136 
         * @return void
9137 
         * @static
9138 
         */
9139 
        public static function assertSentOnDemandTimes($notification, $times = 1)
9140 
        {
9141 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9142 
                        $instance->assertSentOnDemandTimes($notification, $times);
9143 
        }
9144 
                    /**
9145 
         * Assert if a notification was sent a number of times.
9146 
         *
9147 
         * @param mixed $notifiable
9148 
         * @param string $notification
9149 
         * @param int $times
9150 
         * @return void
9151 
         * @static
9152 
         */
9153 
        public static function assertSentToTimes($notifiable, $notification, $times = 1)
9154 
        {
9155 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9156 
                        $instance->assertSentToTimes($notifiable, $notification, $times);
9157 
        }
9158 
                    /**
9159 
         * Determine if a notification was sent based on a truth-test callback.
9160 
         *
9161 
         * @param mixed $notifiable
9162 
         * @param string|\Closure $notification
9163 
         * @param callable|null $callback
9164 
         * @return void
9165 
         * @throws \Exception
9166 
         * @static
9167 
         */
9168 
        public static function assertNotSentTo($notifiable, $notification, $callback = null)
9169 
        {
9170 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9171 
                        $instance->assertNotSentTo($notifiable, $notification, $callback);
9172 
        }
9173 
                    /**
9174 
         * Assert that no notifications were sent.
9175 
         *
9176 
         * @return void
9177 
         * @static
9178 
         */
9179 
        public static function assertNothingSent()
9180 
        {
9181 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9182 
                        $instance->assertNothingSent();
9183 
        }
9184 
                    /**
9185 
         * Assert that no notifications were sent to the given notifiable.
9186 
         *
9187 
         * @param mixed $notifiable
9188 
         * @return void
9189 
         * @throws \Exception
9190 
         * @static
9191 
         */
9192 
        public static function assertNothingSentTo($notifiable)
9193 
        {
9194 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9195 
                        $instance->assertNothingSentTo($notifiable);
9196 
        }
9197 
                    /**
9198 
         * Assert the total amount of times a notification was sent.
9199 
         *
9200 
         * @param string $notification
9201 
         * @param int $expectedCount
9202 
         * @return void
9203 
         * @static
9204 
         */
9205 
        public static function assertSentTimes($notification, $expectedCount)
9206 
        {
9207 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9208 
                        $instance->assertSentTimes($notification, $expectedCount);
9209 
        }
9210 
                    /**
9211 
         * Assert the total count of notification that were sent.
9212 
         *
9213 
         * @param int $expectedCount
9214 
         * @return void
9215 
         * @static
9216 
         */
9217 
        public static function assertCount($expectedCount)
9218 
        {
9219 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9220 
                        $instance->assertCount($expectedCount);
9221 
        }
9222 
                    /**
9223 
         * Assert the total amount of times a notification was sent.
9224 
         *
9225 
         * @param int $expectedCount
9226 
         * @param string $notification
9227 
         * @return void
9228 
         * @deprecated Use the assertSentTimes method instead
9229 
         * @static
9230 
         */
9231 
        public static function assertTimesSent($expectedCount, $notification)
9232 
        {
9233 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9234 
                        $instance->assertTimesSent($expectedCount, $notification);
9235 
        }
9236 
                    /**
9237 
         * Get all of the notifications matching a truth-test callback.
9238 
         *
9239 
         * @param mixed $notifiable
9240 
         * @param string $notification
9241 
         * @param callable|null $callback
9242 
         * @return \Illuminate\Support\Collection
9243 
         * @static
9244 
         */
9245 
        public static function sent($notifiable, $notification, $callback = null)
9246 
        {
9247 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9248 
                        return $instance->sent($notifiable, $notification, $callback);
9249 
        }
9250 
                    /**
9251 
         * Determine if there are more notifications left to inspect.
9252 
         *
9253 
         * @param mixed $notifiable
9254 
         * @param string $notification
9255 
         * @return bool
9256 
         * @static
9257 
         */
9258 
        public static function hasSent($notifiable, $notification)
9259 
        {
9260 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9261 
                        return $instance->hasSent($notifiable, $notification);
9262 
        }
9263 
                    /**
9264 
         * Get the notifications that have been sent.
9265 
         *
9266 
         * @return array
9267 
         * @static
9268 
         */
9269 
        public static function sentNotifications()
9270 
        {
9271 
                        /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
9272 
                        return $instance->sentNotifications();
9273 
        }
9274 
                    /**
9275 
         * Register a custom macro.
9276 
         *
9277 
         * @param string $name
9278 
         * @param object|callable $macro
9279 
         * @return void
9280 
         * @static
9281 
         */
9282 
        public static function macro($name, $macro)
9283 
        {
9284 
                        \Illuminate\Support\Testing\Fakes\NotificationFake::macro($name, $macro);
9285 
        }
9286 
                    /**
9287 
         * Mix another object into the class.
9288 
         *
9289 
         * @param object $mixin
9290 
         * @param bool $replace
9291 
         * @return void
9292 
         * @throws \ReflectionException
9293 
         * @static
9294 
         */
9295 
        public static function mixin($mixin, $replace = true)
9296 
        {
9297 
                        \Illuminate\Support\Testing\Fakes\NotificationFake::mixin($mixin, $replace);
9298 
        }
9299 
                    /**
9300 
         * Checks if macro is registered.
9301 
         *
9302 
         * @param string $name
9303 
         * @return bool
9304 
         * @static
9305 
         */
9306 
        public static function hasMacro($name)
9307 
        {
9308 
                        return \Illuminate\Support\Testing\Fakes\NotificationFake::hasMacro($name);
9309 
        }
9310 
                    /**
9311 
         * Flush the existing macros.
9312 
         *
9313 
         * @return void
9314 
         * @static
9315 
         */
9316 
        public static function flushMacros()
9317 
        {
9318 
                        \Illuminate\Support\Testing\Fakes\NotificationFake::flushMacros();
9319 
        }
9320 
 
9321 
    }
9322 
            /**
9323 
     *
9324 
     *
9325 
     * @method static string sendResetLink(array $credentials, \Closure|null $callback = null)
9326 
     * @method static mixed reset(array $credentials, \Closure $callback)
9327 
     * @method static \Illuminate\Contracts\Auth\CanResetPassword|null getUser(array $credentials)
9328 
     * @method static string createToken(\Illuminate\Contracts\Auth\CanResetPassword $user)
9329 
     * @method static void deleteToken(\Illuminate\Contracts\Auth\CanResetPassword $user)
9330 
     * @method static bool tokenExists(\Illuminate\Contracts\Auth\CanResetPassword $user, string $token)
9331 
     * @method static \Illuminate\Auth\Passwords\TokenRepositoryInterface getRepository()
9332 
     * @see \Illuminate\Auth\Passwords\PasswordBrokerManager
9333 
     * @see \Illuminate\Auth\Passwords\PasswordBroker
9334 
     */
9335 
        class Password {
9336 
                    /**
9337 
         * Attempt to get the broker from the local cache.
9338 
         *
9339 
         * @param string|null $name
9340 
         * @return \Illuminate\Contracts\Auth\PasswordBroker
9341 
         * @static
9342 
         */
9343 
        public static function broker($name = null)
9344 
        {
9345 
                        /** @var \Illuminate\Auth\Passwords\PasswordBrokerManager $instance */
9346 
                        return $instance->broker($name);
9347 
        }
9348 
                    /**
9349 
         * Get the default password broker name.
9350 
         *
9351 
         * @return string
9352 
         * @static
9353 
         */
9354 
        public static function getDefaultDriver()
9355 
        {
9356 
                        /** @var \Illuminate\Auth\Passwords\PasswordBrokerManager $instance */
9357 
                        return $instance->getDefaultDriver();
9358 
        }
9359 
                    /**
9360 
         * Set the default password broker name.
9361 
         *
9362 
         * @param string $name
9363 
         * @return void
9364 
         * @static
9365 
         */
9366 
        public static function setDefaultDriver($name)
9367 
        {
9368 
                        /** @var \Illuminate\Auth\Passwords\PasswordBrokerManager $instance */
9369 
                        $instance->setDefaultDriver($name);
9370 
        }
9371 
 
9372 
    }
9373 
            /**
9374 
     *
9375 
     *
9376 
     * @see \Illuminate\Queue\QueueManager
9377 
     * @see \Illuminate\Queue\Queue
9378 
     * @see \Illuminate\Support\Testing\Fakes\QueueFake
9379 
     */
9380 
        class Queue {
9381 
                    /**
9382 
         * Register an event listener for the before job event.
9383 
         *
9384 
         * @param mixed $callback
9385 
         * @return void
9386 
         * @static
9387 
         */
9388 
        public static function before($callback)
9389 
        {
9390 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9391 
                        $instance->before($callback);
9392 
        }
9393 
                    /**
9394 
         * Register an event listener for the after job event.
9395 
         *
9396 
         * @param mixed $callback
9397 
         * @return void
9398 
         * @static
9399 
         */
9400 
        public static function after($callback)
9401 
        {
9402 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9403 
                        $instance->after($callback);
9404 
        }
9405 
                    /**
9406 
         * Register an event listener for the exception occurred job event.
9407 
         *
9408 
         * @param mixed $callback
9409 
         * @return void
9410 
         * @static
9411 
         */
9412 
        public static function exceptionOccurred($callback)
9413 
        {
9414 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9415 
                        $instance->exceptionOccurred($callback);
9416 
        }
9417 
                    /**
9418 
         * Register an event listener for the daemon queue loop.
9419 
         *
9420 
         * @param mixed $callback
9421 
         * @return void
9422 
         * @static
9423 
         */
9424 
        public static function looping($callback)
9425 
        {
9426 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9427 
                        $instance->looping($callback);
9428 
        }
9429 
                    /**
9430 
         * Register an event listener for the failed job event.
9431 
         *
9432 
         * @param mixed $callback
9433 
         * @return void
9434 
         * @static
9435 
         */
9436 
        public static function failing($callback)
9437 
        {
9438 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9439 
                        $instance->failing($callback);
9440 
        }
9441 
                    /**
9442 
         * Register an event listener for the daemon queue stopping.
9443 
         *
9444 
         * @param mixed $callback
9445 
         * @return void
9446 
         * @static
9447 
         */
9448 
        public static function stopping($callback)
9449 
        {
9450 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9451 
                        $instance->stopping($callback);
9452 
        }
9453 
                    /**
9454 
         * Determine if the driver is connected.
9455 
         *
9456 
         * @param string|null $name
9457 
         * @return bool
9458 
         * @static
9459 
         */
9460 
        public static function connected($name = null)
9461 
        {
9462 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9463 
                        return $instance->connected($name);
9464 
        }
9465 
                    /**
9466 
         * Resolve a queue connection instance.
9467 
         *
9468 
         * @param string|null $name
9469 
         * @return \Illuminate\Contracts\Queue\Queue
9470 
         * @static
9471 
         */
9472 
        public static function connection($name = null)
9473 
        {
9474 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9475 
                        return $instance->connection($name);
9476 
        }
9477 
                    /**
9478 
         * Add a queue connection resolver.
9479 
         *
9480 
         * @param string $driver
9481 
         * @param \Closure $resolver
9482 
         * @return void
9483 
         * @static
9484 
         */
9485 
        public static function extend($driver, $resolver)
9486 
        {
9487 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9488 
                        $instance->extend($driver, $resolver);
9489 
        }
9490 
                    /**
9491 
         * Add a queue connection resolver.
9492 
         *
9493 
         * @param string $driver
9494 
         * @param \Closure $resolver
9495 
         * @return void
9496 
         * @static
9497 
         */
9498 
        public static function addConnector($driver, $resolver)
9499 
        {
9500 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9501 
                        $instance->addConnector($driver, $resolver);
9502 
        }
9503 
                    /**
9504 
         * Get the name of the default queue connection.
9505 
         *
9506 
         * @return string
9507 
         * @static
9508 
         */
9509 
        public static function getDefaultDriver()
9510 
        {
9511 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9512 
                        return $instance->getDefaultDriver();
9513 
        }
9514 
                    /**
9515 
         * Set the name of the default queue connection.
9516 
         *
9517 
         * @param string $name
9518 
         * @return void
9519 
         * @static
9520 
         */
9521 
        public static function setDefaultDriver($name)
9522 
        {
9523 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9524 
                        $instance->setDefaultDriver($name);
9525 
        }
9526 
                    /**
9527 
         * Get the full name for the given connection.
9528 
         *
9529 
         * @param string|null $connection
9530 
         * @return string
9531 
         * @static
9532 
         */
9533 
        public static function getName($connection = null)
9534 
        {
9535 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9536 
                        return $instance->getName($connection);
9537 
        }
9538 
                    /**
9539 
         * Get the application instance used by the manager.
9540 
         *
9541 
         * @return \Illuminate\Contracts\Foundation\Application
9542 
         * @static
9543 
         */
9544 
        public static function getApplication()
9545 
        {
9546 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9547 
                        return $instance->getApplication();
9548 
        }
9549 
                    /**
9550 
         * Set the application instance used by the manager.
9551 
         *
9552 
         * @param \Illuminate\Contracts\Foundation\Application $app
9553 
         * @return \Illuminate\Queue\QueueManager
9554 
         * @static
9555 
         */
9556 
        public static function setApplication($app)
9557 
        {
9558 
                        /** @var \Illuminate\Queue\QueueManager $instance */
9559 
                        return $instance->setApplication($app);
9560 
        }
9561 
                    /**
9562 
         * Specify the jobs that should be queued instead of faked.
9563 
         *
9564 
         * @param array|string $jobsToBeQueued
9565 
         * @return \Illuminate\Support\Testing\Fakes\QueueFake
9566 
         * @static
9567 
         */
9568 
        public static function except($jobsToBeQueued)
9569 
        {
9570 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9571 
                        return $instance->except($jobsToBeQueued);
9572 
        }
9573 
                    /**
9574 
         * Assert if a job was pushed based on a truth-test callback.
9575 
         *
9576 
         * @param string|\Closure $job
9577 
         * @param callable|int|null $callback
9578 
         * @return void
9579 
         * @static
9580 
         */
9581 
        public static function assertPushed($job, $callback = null)
9582 
        {
9583 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9584 
                        $instance->assertPushed($job, $callback);
9585 
        }
9586 
                    /**
9587 
         * Assert if a job was pushed based on a truth-test callback.
9588 
         *
9589 
         * @param string $queue
9590 
         * @param string|\Closure $job
9591 
         * @param callable|null $callback
9592 
         * @return void
9593 
         * @static
9594 
         */
9595 
        public static function assertPushedOn($queue, $job, $callback = null)
9596 
        {
9597 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9598 
                        $instance->assertPushedOn($queue, $job, $callback);
9599 
        }
9600 
                    /**
9601 
         * Assert if a job was pushed with chained jobs based on a truth-test callback.
9602 
         *
9603 
         * @param string $job
9604 
         * @param array $expectedChain
9605 
         * @param callable|null $callback
9606 
         * @return void
9607 
         * @static
9608 
         */
9609 
        public static function assertPushedWithChain($job, $expectedChain = [], $callback = null)
9610 
        {
9611 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9612 
                        $instance->assertPushedWithChain($job, $expectedChain, $callback);
9613 
        }
9614 
                    /**
9615 
         * Assert if a job was pushed with an empty chain based on a truth-test callback.
9616 
         *
9617 
         * @param string $job
9618 
         * @param callable|null $callback
9619 
         * @return void
9620 
         * @static
9621 
         */
9622 
        public static function assertPushedWithoutChain($job, $callback = null)
9623 
        {
9624 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9625 
                        $instance->assertPushedWithoutChain($job, $callback);
9626 
        }
9627 
                    /**
9628 
         * Determine if a job was pushed based on a truth-test callback.
9629 
         *
9630 
         * @param string|\Closure $job
9631 
         * @param callable|null $callback
9632 
         * @return void
9633 
         * @static
9634 
         */
9635 
        public static function assertNotPushed($job, $callback = null)
9636 
        {
9637 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9638 
                        $instance->assertNotPushed($job, $callback);
9639 
        }
9640 
                    /**
9641 
         * Assert that no jobs were pushed.
9642 
         *
9643 
         * @return void
9644 
         * @static
9645 
         */
9646 
        public static function assertNothingPushed()
9647 
        {
9648 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9649 
                        $instance->assertNothingPushed();
9650 
        }
9651 
                    /**
9652 
         * Get all of the jobs matching a truth-test callback.
9653 
         *
9654 
         * @param string $job
9655 
         * @param callable|null $callback
9656 
         * @return \Illuminate\Support\Collection
9657 
         * @static
9658 
         */
9659 
        public static function pushed($job, $callback = null)
9660 
        {
9661 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9662 
                        return $instance->pushed($job, $callback);
9663 
        }
9664 
                    /**
9665 
         * Determine if there are any stored jobs for a given class.
9666 
         *
9667 
         * @param string $job
9668 
         * @return bool
9669 
         * @static
9670 
         */
9671 
        public static function hasPushed($job)
9672 
        {
9673 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9674 
                        return $instance->hasPushed($job);
9675 
        }
9676 
                    /**
9677 
         * Get the size of the queue.
9678 
         *
9679 
         * @param string|null $queue
9680 
         * @return int
9681 
         * @static
9682 
         */
9683 
        public static function size($queue = null)
9684 
        {
9685 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9686 
                        return $instance->size($queue);
9687 
        }
9688 
                    /**
9689 
         * Push a new job onto the queue.
9690 
         *
9691 
         * @param string|object $job
9692 
         * @param mixed $data
9693 
         * @param string|null $queue
9694 
         * @return mixed
9695 
         * @static
9696 
         */
9697 
        public static function push($job, $data = '', $queue = null)
9698 
        {
9699 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9700 
                        return $instance->push($job, $data, $queue);
9701 
        }
9702 
                    /**
9703 
         * Determine if a job should be faked or actually dispatched.
9704 
         *
9705 
         * @param object $job
9706 
         * @return bool
9707 
         * @static
9708 
         */
9709 
        public static function shouldFakeJob($job)
9710 
        {
9711 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9712 
                        return $instance->shouldFakeJob($job);
9713 
        }
9714 
                    /**
9715 
         * Push a raw payload onto the queue.
9716 
         *
9717 
         * @param string $payload
9718 
         * @param string|null $queue
9719 
         * @param array $options
9720 
         * @return mixed
9721 
         * @static
9722 
         */
9723 
        public static function pushRaw($payload, $queue = null, $options = [])
9724 
        {
9725 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9726 
                        return $instance->pushRaw($payload, $queue, $options);
9727 
        }
9728 
                    /**
9729 
         * Push a new job onto the queue after (n) seconds.
9730 
         *
9731 
         * @param \DateTimeInterface|\DateInterval|int $delay
9732 
         * @param string|object $job
9733 
         * @param mixed $data
9734 
         * @param string|null $queue
9735 
         * @return mixed
9736 
         * @static
9737 
         */
9738 
        public static function later($delay, $job, $data = '', $queue = null)
9739 
        {
9740 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9741 
                        return $instance->later($delay, $job, $data, $queue);
9742 
        }
9743 
                    /**
9744 
         * Push a new job onto the queue.
9745 
         *
9746 
         * @param string $queue
9747 
         * @param string|object $job
9748 
         * @param mixed $data
9749 
         * @return mixed
9750 
         * @static
9751 
         */
9752 
        public static function pushOn($queue, $job, $data = '')
9753 
        {
9754 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9755 
                        return $instance->pushOn($queue, $job, $data);
9756 
        }
9757 
                    /**
9758 
         * Push a new job onto a specific queue after (n) seconds.
9759 
         *
9760 
         * @param string $queue
9761 
         * @param \DateTimeInterface|\DateInterval|int $delay
9762 
         * @param string|object $job
9763 
         * @param mixed $data
9764 
         * @return mixed
9765 
         * @static
9766 
         */
9767 
        public static function laterOn($queue, $delay, $job, $data = '')
9768 
        {
9769 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9770 
                        return $instance->laterOn($queue, $delay, $job, $data);
9771 
        }
9772 
                    /**
9773 
         * Pop the next job off of the queue.
9774 
         *
9775 
         * @param string|null $queue
9776 
         * @return \Illuminate\Contracts\Queue\Job|null
9777 
         * @static
9778 
         */
9779 
        public static function pop($queue = null)
9780 
        {
9781 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9782 
                        return $instance->pop($queue);
9783 
        }
9784 
                    /**
9785 
         * Push an array of jobs onto the queue.
9786 
         *
9787 
         * @param array $jobs
9788 
         * @param mixed $data
9789 
         * @param string|null $queue
9790 
         * @return mixed
9791 
         * @static
9792 
         */
9793 
        public static function bulk($jobs, $data = '', $queue = null)
9794 
        {
9795 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9796 
                        return $instance->bulk($jobs, $data, $queue);
9797 
        }
9798 
                    /**
9799 
         * Get the jobs that have been pushed.
9800 
         *
9801 
         * @return array
9802 
         * @static
9803 
         */
9804 
        public static function pushedJobs()
9805 
        {
9806 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9807 
                        return $instance->pushedJobs();
9808 
        }
9809 
                    /**
9810 
         * Get the connection name for the queue.
9811 
         *
9812 
         * @return string
9813 
         * @static
9814 
         */
9815 
        public static function getConnectionName()
9816 
        {
9817 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9818 
                        return $instance->getConnectionName();
9819 
        }
9820 
                    /**
9821 
         * Set the connection name for the queue.
9822 
         *
9823 
         * @param string $name
9824 
         * @return \Illuminate\Support\Testing\Fakes\QueueFake
9825 
         * @static
9826 
         */
9827 
        public static function setConnectionName($name)
9828 
        {
9829 
                        /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9830 
                        return $instance->setConnectionName($name);
9831 
        }
9832 
                    /**
9833 
         * Get the backoff for an object-based queue handler.
9834 
         *
9835 
         * @param mixed $job
9836 
         * @return mixed
9837 
         * @static
9838 
         */
9839 
        public static function getJobBackoff($job)
9840 
        {            //Method inherited from \Illuminate\Queue\Queue
9841 
                        /** @var \Illuminate\Queue\SyncQueue $instance */
9842 
                        return $instance->getJobBackoff($job);
9843 
        }
9844 
                    /**
9845 
         * Get the expiration timestamp for an object-based queue handler.
9846 
         *
9847 
         * @param mixed $job
9848 
         * @return mixed
9849 
         * @static
9850 
         */
9851 
        public static function getJobExpiration($job)
9852 
        {            //Method inherited from \Illuminate\Queue\Queue
9853 
                        /** @var \Illuminate\Queue\SyncQueue $instance */
9854 
                        return $instance->getJobExpiration($job);
9855 
        }
9856 
                    /**
9857 
         * Register a callback to be executed when creating job payloads.
9858 
         *
9859 
         * @param callable|null $callback
9860 
         * @return void
9861 
         * @static
9862 
         */
9863 
        public static function createPayloadUsing($callback)
9864 
        {            //Method inherited from \Illuminate\Queue\Queue
9865 
                        \Illuminate\Queue\SyncQueue::createPayloadUsing($callback);
9866 
        }
9867 
                    /**
9868 
         * Get the container instance being used by the connection.
9869 
         *
9870 
         * @return \Illuminate\Container\Container
9871 
         * @static
9872 
         */
9873 
        public static function getContainer()
9874 
        {            //Method inherited from \Illuminate\Queue\Queue
9875 
                        /** @var \Illuminate\Queue\SyncQueue $instance */
9876 
                        return $instance->getContainer();
9877 
        }
9878 
                    /**
9879 
         * Set the IoC container instance.
9880 
         *
9881 
         * @param \Illuminate\Container\Container $container
9882 
         * @return void
9883 
         * @static
9884 
         */
9885 
        public static function setContainer($container)
9886 
        {            //Method inherited from \Illuminate\Queue\Queue
9887 
                        /** @var \Illuminate\Queue\SyncQueue $instance */
9888 
                        $instance->setContainer($container);
9889 
        }
9890 
 
9891 
    }
9892 
            /**
9893 
     *
9894 
     *
9895 
     * @see \Illuminate\Cache\RateLimiter
9896 
     */
9897 
        class RateLimiter {
9898 
                    /**
9899 
         * Register a named limiter configuration.
9900 
         *
9901 
         * @param string $name
9902 
         * @param \Closure $callback
9903 
         * @return \Illuminate\Cache\RateLimiter
9904 
         * @static
9905 
         */
9906 
        public static function for($name, $callback)
9907 
        {
9908 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
9909 
                        return $instance->for($name, $callback);
9910 
        }
9911 
                    /**
9912 
         * Get the given named rate limiter.
9913 
         *
9914 
         * @param string $name
9915 
         * @return \Closure
9916 
         * @static
9917 
         */
9918 
        public static function limiter($name)
9919 
        {
9920 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
9921 
                        return $instance->limiter($name);
9922 
        }
9923 
                    /**
9924 
         * Attempts to execute a callback if it's not limited.
9925 
         *
9926 
         * @param string $key
9927 
         * @param int $maxAttempts
9928 
         * @param \Closure $callback
9929 
         * @param int $decaySeconds
9930 
         * @return mixed
9931 
         * @static
9932 
         */
9933 
        public static function attempt($key, $maxAttempts, $callback, $decaySeconds = 60)
9934 
        {
9935 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
9936 
                        return $instance->attempt($key, $maxAttempts, $callback, $decaySeconds);
9937 
        }
9938 
                    /**
9939 
         * Determine if the given key has been "accessed" too many times.
9940 
         *
9941 
         * @param string $key
9942 
         * @param int $maxAttempts
9943 
         * @return bool
9944 
         * @static
9945 
         */
9946 
        public static function tooManyAttempts($key, $maxAttempts)
9947 
        {
9948 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
9949 
                        return $instance->tooManyAttempts($key, $maxAttempts);
9950 
        }
9951 
                    /**
9952 
         * Increment the counter for a given key for a given decay time.
9953 
         *
9954 
         * @param string $key
9955 
         * @param int $decaySeconds
9956 
         * @return int
9957 
         * @static
9958 
         */
9959 
        public static function hit($key, $decaySeconds = 60)
9960 
        {
9961 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
9962 
                        return $instance->hit($key, $decaySeconds);
9963 
        }
9964 
                    /**
9965 
         * Get the number of attempts for the given key.
9966 
         *
9967 
         * @param string $key
9968 
         * @return mixed
9969 
         * @static
9970 
         */
9971 
        public static function attempts($key)
9972 
        {
9973 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
9974 
                        return $instance->attempts($key);
9975 
        }
9976 
                    /**
9977 
         * Reset the number of attempts for the given key.
9978 
         *
9979 
         * @param string $key
9980 
         * @return mixed
9981 
         * @static
9982 
         */
9983 
        public static function resetAttempts($key)
9984 
        {
9985 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
9986 
                        return $instance->resetAttempts($key);
9987 
        }
9988 
                    /**
9989 
         * Get the number of retries left for the given key.
9990 
         *
9991 
         * @param string $key
9992 
         * @param int $maxAttempts
9993 
         * @return int
9994 
         * @static
9995 
         */
9996 
        public static function remaining($key, $maxAttempts)
9997 
        {
9998 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
9999 
                        return $instance->remaining($key, $maxAttempts);
10000 
        }
10001 
                    /**
10002 
         * Get the number of retries left for the given key.
10003 
         *
10004 
         * @param string $key
10005 
         * @param int $maxAttempts
10006 
         * @return int
10007 
         * @static
10008 
         */
10009 
        public static function retriesLeft($key, $maxAttempts)
10010 
        {
10011 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
10012 
                        return $instance->retriesLeft($key, $maxAttempts);
10013 
        }
10014 
                    /**
10015 
         * Clear the hits and lockout timer for the given key.
10016 
         *
10017 
         * @param string $key
10018 
         * @return void
10019 
         * @static
10020 
         */
10021 
        public static function clear($key)
10022 
        {
10023 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
10024 
                        $instance->clear($key);
10025 
        }
10026 
                    /**
10027 
         * Get the number of seconds until the "key" is accessible again.
10028 
         *
10029 
         * @param string $key
10030 
         * @return int
10031 
         * @static
10032 
         */
10033 
        public static function availableIn($key)
10034 
        {
10035 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
10036 
                        return $instance->availableIn($key);
10037 
        }
10038 
                    /**
10039 
         * Clean the rate limiter key from unicode characters.
10040 
         *
10041 
         * @param string $key
10042 
         * @return string
10043 
         * @static
10044 
         */
10045 
        public static function cleanRateLimiterKey($key)
10046 
        {
10047 
                        /** @var \Illuminate\Cache\RateLimiter $instance */
10048 
                        return $instance->cleanRateLimiterKey($key);
10049 
        }
10050 
 
10051 
    }
10052 
            /**
10053 
     *
10054 
     *
10055 
     * @see \Illuminate\Routing\Redirector
10056 
     */
10057 
        class Redirect {
10058 
                    /**
10059 
         * Create a new redirect response to the "home" route.
10060 
         *
10061 
         * @param int $status
10062 
         * @return \Illuminate\Http\RedirectResponse
10063 
         * @deprecated Will be removed in a future Laravel version.
10064 
         * @static
10065 
         */
10066 
        public static function home($status = 302)
10067 
        {
10068 
                        /** @var \Illuminate\Routing\Redirector $instance */
10069 
                        return $instance->home($status);
10070 
        }
10071 
                    /**
10072 
         * Create a new redirect response to the previous location.
10073 
         *
10074 
         * @param int $status
10075 
         * @param array $headers
10076 
         * @param mixed $fallback
10077 
         * @return \Illuminate\Http\RedirectResponse
10078 
         * @static
10079 
         */
10080 
        public static function back($status = 302, $headers = [], $fallback = false)
10081 
        {
10082 
                        /** @var \Illuminate\Routing\Redirector $instance */
10083 
                        return $instance->back($status, $headers, $fallback);
10084 
        }
10085 
                    /**
10086 
         * Create a new redirect response to the current URI.
10087 
         *
10088 
         * @param int $status
10089 
         * @param array $headers
10090 
         * @return \Illuminate\Http\RedirectResponse
10091 
         * @static
10092 
         */
10093 
        public static function refresh($status = 302, $headers = [])
10094 
        {
10095 
                        /** @var \Illuminate\Routing\Redirector $instance */
10096 
                        return $instance->refresh($status, $headers);
10097 
        }
10098 
                    /**
10099 
         * Create a new redirect response, while putting the current URL in the session.
10100 
         *
10101 
         * @param string $path
10102 
         * @param int $status
10103 
         * @param array $headers
10104 
         * @param bool|null $secure
10105 
         * @return \Illuminate\Http\RedirectResponse
10106 
         * @static
10107 
         */
10108 
        public static function guest($path, $status = 302, $headers = [], $secure = null)
10109 
        {
10110 
                        /** @var \Illuminate\Routing\Redirector $instance */
10111 
                        return $instance->guest($path, $status, $headers, $secure);
10112 
        }
10113 
                    /**
10114 
         * Create a new redirect response to the previously intended location.
10115 
         *
10116 
         * @param mixed $default
10117 
         * @param int $status
10118 
         * @param array $headers
10119 
         * @param bool|null $secure
10120 
         * @return \Illuminate\Http\RedirectResponse
10121 
         * @static
10122 
         */
10123 
        public static function intended($default = '/', $status = 302, $headers = [], $secure = null)
10124 
        {
10125 
                        /** @var \Illuminate\Routing\Redirector $instance */
10126 
                        return $instance->intended($default, $status, $headers, $secure);
10127 
        }
10128 
                    /**
10129 
         * Create a new redirect response to the given path.
10130 
         *
10131 
         * @param string $path
10132 
         * @param int $status
10133 
         * @param array $headers
10134 
         * @param bool|null $secure
10135 
         * @return \Illuminate\Http\RedirectResponse
10136 
         * @static
10137 
         */
10138 
        public static function to($path, $status = 302, $headers = [], $secure = null)
10139 
        {
10140 
                        /** @var \Illuminate\Routing\Redirector $instance */
10141 
                        return $instance->to($path, $status, $headers, $secure);
10142 
        }
10143 
                    /**
10144 
         * Create a new redirect response to an external URL (no validation).
10145 
         *
10146 
         * @param string $path
10147 
         * @param int $status
10148 
         * @param array $headers
10149 
         * @return \Illuminate\Http\RedirectResponse
10150 
         * @static
10151 
         */
10152 
        public static function away($path, $status = 302, $headers = [])
10153 
        {
10154 
                        /** @var \Illuminate\Routing\Redirector $instance */
10155 
                        return $instance->away($path, $status, $headers);
10156 
        }
10157 
                    /**
10158 
         * Create a new redirect response to the given HTTPS path.
10159 
         *
10160 
         * @param string $path
10161 
         * @param int $status
10162 
         * @param array $headers
10163 
         * @return \Illuminate\Http\RedirectResponse
10164 
         * @static
10165 
         */
10166 
        public static function secure($path, $status = 302, $headers = [])
10167 
        {
10168 
                        /** @var \Illuminate\Routing\Redirector $instance */
10169 
                        return $instance->secure($path, $status, $headers);
10170 
        }
10171 
                    /**
10172 
         * Create a new redirect response to a named route.
10173 
         *
10174 
         * @param string $route
10175 
         * @param mixed $parameters
10176 
         * @param int $status
10177 
         * @param array $headers
10178 
         * @return \Illuminate\Http\RedirectResponse
10179 
         * @static
10180 
         */
10181 
        public static function route($route, $parameters = [], $status = 302, $headers = [])
10182 
        {
10183 
                        /** @var \Illuminate\Routing\Redirector $instance */
10184 
                        return $instance->route($route, $parameters, $status, $headers);
10185 
        }
10186 
                    /**
10187 
         * Create a new redirect response to a signed named route.
10188 
         *
10189 
         * @param string $route
10190 
         * @param mixed $parameters
10191 
         * @param \DateTimeInterface|\DateInterval|int|null $expiration
10192 
         * @param int $status
10193 
         * @param array $headers
10194 
         * @return \Illuminate\Http\RedirectResponse
10195 
         * @static
10196 
         */
10197 
        public static function signedRoute($route, $parameters = [], $expiration = null, $status = 302, $headers = [])
10198 
        {
10199 
                        /** @var \Illuminate\Routing\Redirector $instance */
10200 
                        return $instance->signedRoute($route, $parameters, $expiration, $status, $headers);
10201 
        }
10202 
                    /**
10203 
         * Create a new redirect response to a signed named route.
10204 
         *
10205 
         * @param string $route
10206 
         * @param \DateTimeInterface|\DateInterval|int|null $expiration
10207 
         * @param mixed $parameters
10208 
         * @param int $status
10209 
         * @param array $headers
10210 
         * @return \Illuminate\Http\RedirectResponse
10211 
         * @static
10212 
         */
10213 
        public static function temporarySignedRoute($route, $expiration, $parameters = [], $status = 302, $headers = [])
10214 
        {
10215 
                        /** @var \Illuminate\Routing\Redirector $instance */
10216 
                        return $instance->temporarySignedRoute($route, $expiration, $parameters, $status, $headers);
10217 
        }
10218 
                    /**
10219 
         * Create a new redirect response to a controller action.
10220 
         *
10221 
         * @param string|array $action
10222 
         * @param mixed $parameters
10223 
         * @param int $status
10224 
         * @param array $headers
10225 
         * @return \Illuminate\Http\RedirectResponse
10226 
         * @static
10227 
         */
10228 
        public static function action($action, $parameters = [], $status = 302, $headers = [])
10229 
        {
10230 
                        /** @var \Illuminate\Routing\Redirector $instance */
10231 
                        return $instance->action($action, $parameters, $status, $headers);
10232 
        }
10233 
                    /**
10234 
         * Get the URL generator instance.
10235 
         *
10236 
         * @return \Illuminate\Routing\UrlGenerator
10237 
         * @static
10238 
         */
10239 
        public static function getUrlGenerator()
10240 
        {
10241 
                        /** @var \Illuminate\Routing\Redirector $instance */
10242 
                        return $instance->getUrlGenerator();
10243 
        }
10244 
                    /**
10245 
         * Set the active session store.
10246 
         *
10247 
         * @param \Illuminate\Session\Store $session
10248 
         * @return void
10249 
         * @static
10250 
         */
10251 
        public static function setSession($session)
10252 
        {
10253 
                        /** @var \Illuminate\Routing\Redirector $instance */
10254 
                        $instance->setSession($session);
10255 
        }
10256 
                    /**
10257 
         * Get the "intended" URL from the session.
10258 
         *
10259 
         * @return string|null
10260 
         * @static
10261 
         */
10262 
        public static function getIntendedUrl()
10263 
        {
10264 
                        /** @var \Illuminate\Routing\Redirector $instance */
10265 
                        return $instance->getIntendedUrl();
10266 
        }
10267 
                    /**
10268 
         * Set the "intended" URL in the session.
10269 
         *
10270 
         * @param string $url
10271 
         * @return \Illuminate\Routing\Redirector
10272 
         * @static
10273 
         */
10274 
        public static function setIntendedUrl($url)
10275 
        {
10276 
                        /** @var \Illuminate\Routing\Redirector $instance */
10277 
                        return $instance->setIntendedUrl($url);
10278 
        }
10279 
                    /**
10280 
         * Register a custom macro.
10281 
         *
10282 
         * @param string $name
10283 
         * @param object|callable $macro
10284 
         * @return void
10285 
         * @static
10286 
         */
10287 
        public static function macro($name, $macro)
10288 
        {
10289 
                        \Illuminate\Routing\Redirector::macro($name, $macro);
10290 
        }
10291 
                    /**
10292 
         * Mix another object into the class.
10293 
         *
10294 
         * @param object $mixin
10295 
         * @param bool $replace
10296 
         * @return void
10297 
         * @throws \ReflectionException
10298 
         * @static
10299 
         */
10300 
        public static function mixin($mixin, $replace = true)
10301 
        {
10302 
                        \Illuminate\Routing\Redirector::mixin($mixin, $replace);
10303 
        }
10304 
                    /**
10305 
         * Checks if macro is registered.
10306 
         *
10307 
         * @param string $name
10308 
         * @return bool
10309 
         * @static
10310 
         */
10311 
        public static function hasMacro($name)
10312 
        {
10313 
                        return \Illuminate\Routing\Redirector::hasMacro($name);
10314 
        }
10315 
                    /**
10316 
         * Flush the existing macros.
10317 
         *
10318 
         * @return void
10319 
         * @static
10320 
         */
10321 
        public static function flushMacros()
10322 
        {
10323 
                        \Illuminate\Routing\Redirector::flushMacros();
10324 
        }
10325 
 
10326 
    }
10327 
            /**
10328 
     *
10329 
     *
10330 
     * @see \Illuminate\Http\Request
10331 
     */
10332 
        class Request {
10333 
                    /**
10334 
         * Create a new Illuminate HTTP request from server variables.
10335 
         *
10336 
         * @return static
10337 
         * @static
10338 
         */
10339 
        public static function capture()
10340 
        {
10341 
                        return \Illuminate\Http\Request::capture();
10342 
        }
10343 
                    /**
10344 
         * Return the Request instance.
10345 
         *
10346 
         * @return \Illuminate\Http\Request
10347 
         * @static
10348 
         */
10349 
        public static function instance()
10350 
        {
10351 
                        /** @var \Illuminate\Http\Request $instance */
10352 
                        return $instance->instance();
10353 
        }
10354 
                    /**
10355 
         * Get the request method.
10356 
         *
10357 
         * @return string
10358 
         * @static
10359 
         */
10360 
        public static function method()
10361 
        {
10362 
                        /** @var \Illuminate\Http\Request $instance */
10363 
                        return $instance->method();
10364 
        }
10365 
                    /**
10366 
         * Get the root URL for the application.
10367 
         *
10368 
         * @return string
10369 
         * @static
10370 
         */
10371 
        public static function root()
10372 
        {
10373 
                        /** @var \Illuminate\Http\Request $instance */
10374 
                        return $instance->root();
10375 
        }
10376 
                    /**
10377 
         * Get the URL (no query string) for the request.
10378 
         *
10379 
         * @return string
10380 
         * @static
10381 
         */
10382 
        public static function url()
10383 
        {
10384 
                        /** @var \Illuminate\Http\Request $instance */
10385 
                        return $instance->url();
10386 
        }
10387 
                    /**
10388 
         * Get the full URL for the request.
10389 
         *
10390 
         * @return string
10391 
         * @static
10392 
         */
10393 
        public static function fullUrl()
10394 
        {
10395 
                        /** @var \Illuminate\Http\Request $instance */
10396 
                        return $instance->fullUrl();
10397 
        }
10398 
                    /**
10399 
         * Get the full URL for the request with the added query string parameters.
10400 
         *
10401 
         * @param array $query
10402 
         * @return string
10403 
         * @static
10404 
         */
10405 
        public static function fullUrlWithQuery($query)
10406 
        {
10407 
                        /** @var \Illuminate\Http\Request $instance */
10408 
                        return $instance->fullUrlWithQuery($query);
10409 
        }
10410 
                    /**
10411 
         * Get the full URL for the request without the given query string parameters.
10412 
         *
10413 
         * @param array|string $keys
10414 
         * @return string
10415 
         * @static
10416 
         */
10417 
        public static function fullUrlWithoutQuery($keys)
10418 
        {
10419 
                        /** @var \Illuminate\Http\Request $instance */
10420 
                        return $instance->fullUrlWithoutQuery($keys);
10421 
        }
10422 
                    /**
10423 
         * Get the current path info for the request.
10424 
         *
10425 
         * @return string
10426 
         * @static
10427 
         */
10428 
        public static function path()
10429 
        {
10430 
                        /** @var \Illuminate\Http\Request $instance */
10431 
                        return $instance->path();
10432 
        }
10433 
                    /**
10434 
         * Get the current decoded path info for the request.
10435 
         *
10436 
         * @return string
10437 
         * @static
10438 
         */
10439 
        public static function decodedPath()
10440 
        {
10441 
                        /** @var \Illuminate\Http\Request $instance */
10442 
                        return $instance->decodedPath();
10443 
        }
10444 
                    /**
10445 
         * Get a segment from the URI (1 based index).
10446 
         *
10447 
         * @param int $index
10448 
         * @param string|null $default
10449 
         * @return string|null
10450 
         * @static
10451 
         */
10452 
        public static function segment($index, $default = null)
10453 
        {
10454 
                        /** @var \Illuminate\Http\Request $instance */
10455 
                        return $instance->segment($index, $default);
10456 
        }
10457 
                    /**
10458 
         * Get all of the segments for the request path.
10459 
         *
10460 
         * @return array
10461 
         * @static
10462 
         */
10463 
        public static function segments()
10464 
        {
10465 
                        /** @var \Illuminate\Http\Request $instance */
10466 
                        return $instance->segments();
10467 
        }
10468 
                    /**
10469 
         * Determine if the current request URI matches a pattern.
10470 
         *
10471 
         * @param mixed $patterns
10472 
         * @return bool
10473 
         * @static
10474 
         */
10475 
        public static function is(...$patterns)
10476 
        {
10477 
                        /** @var \Illuminate\Http\Request $instance */
10478 
                        return $instance->is(...$patterns);
10479 
        }
10480 
                    /**
10481 
         * Determine if the route name matches a given pattern.
10482 
         *
10483 
         * @param mixed $patterns
10484 
         * @return bool
10485 
         * @static
10486 
         */
10487 
        public static function routeIs(...$patterns)
10488 
        {
10489 
                        /** @var \Illuminate\Http\Request $instance */
10490 
                        return $instance->routeIs(...$patterns);
10491 
        }
10492 
                    /**
10493 
         * Determine if the current request URL and query string match a pattern.
10494 
         *
10495 
         * @param mixed $patterns
10496 
         * @return bool
10497 
         * @static
10498 
         */
10499 
        public static function fullUrlIs(...$patterns)
10500 
        {
10501 
                        /** @var \Illuminate\Http\Request $instance */
10502 
                        return $instance->fullUrlIs(...$patterns);
10503 
        }
10504 
                    /**
10505 
         * Get the host name.
10506 
         *
10507 
         * @return string
10508 
         * @static
10509 
         */
10510 
        public static function host()
10511 
        {
10512 
                        /** @var \Illuminate\Http\Request $instance */
10513 
                        return $instance->host();
10514 
        }
10515 
                    /**
10516 
         * Get the HTTP host being requested.
10517 
         *
10518 
         * @return string
10519 
         * @static
10520 
         */
10521 
        public static function httpHost()
10522 
        {
10523 
                        /** @var \Illuminate\Http\Request $instance */
10524 
                        return $instance->httpHost();
10525 
        }
10526 
                    /**
10527 
         * Get the scheme and HTTP host.
10528 
         *
10529 
         * @return string
10530 
         * @static
10531 
         */
10532 
        public static function schemeAndHttpHost()
10533 
        {
10534 
                        /** @var \Illuminate\Http\Request $instance */
10535 
                        return $instance->schemeAndHttpHost();
10536 
        }
10537 
                    /**
10538 
         * Determine if the request is the result of an AJAX call.
10539 
         *
10540 
         * @return bool
10541 
         * @static
10542 
         */
10543 
        public static function ajax()
10544 
        {
10545 
                        /** @var \Illuminate\Http\Request $instance */
10546 
                        return $instance->ajax();
10547 
        }
10548 
                    /**
10549 
         * Determine if the request is the result of a PJAX call.
10550 
         *
10551 
         * @return bool
10552 
         * @static
10553 
         */
10554 
        public static function pjax()
10555 
        {
10556 
                        /** @var \Illuminate\Http\Request $instance */
10557 
                        return $instance->pjax();
10558 
        }
10559 
                    /**
10560 
         * Determine if the request is the result of a prefetch call.
10561 
         *
10562 
         * @return bool
10563 
         * @static
10564 
         */
10565 
        public static function prefetch()
10566 
        {
10567 
                        /** @var \Illuminate\Http\Request $instance */
10568 
                        return $instance->prefetch();
10569 
        }
10570 
                    /**
10571 
         * Determine if the request is over HTTPS.
10572 
         *
10573 
         * @return bool
10574 
         * @static
10575 
         */
10576 
        public static function secure()
10577 
        {
10578 
                        /** @var \Illuminate\Http\Request $instance */
10579 
                        return $instance->secure();
10580 
        }
10581 
                    /**
10582 
         * Get the client IP address.
10583 
         *
10584 
         * @return string|null
10585 
         * @static
10586 
         */
10587 
        public static function ip()
10588 
        {
10589 
                        /** @var \Illuminate\Http\Request $instance */
10590 
                        return $instance->ip();
10591 
        }
10592 
                    /**
10593 
         * Get the client IP addresses.
10594 
         *
10595 
         * @return array
10596 
         * @static
10597 
         */
10598 
        public static function ips()
10599 
        {
10600 
                        /** @var \Illuminate\Http\Request $instance */
10601 
                        return $instance->ips();
10602 
        }
10603 
                    /**
10604 
         * Get the client user agent.
10605 
         *
10606 
         * @return string|null
10607 
         * @static
10608 
         */
10609 
        public static function userAgent()
10610 
        {
10611 
                        /** @var \Illuminate\Http\Request $instance */
10612 
                        return $instance->userAgent();
10613 
        }
10614 
                    /**
10615 
         * Merge new input into the current request's input array.
10616 
         *
10617 
         * @param array $input
10618 
         * @return \Illuminate\Http\Request
10619 
         * @static
10620 
         */
10621 
        public static function merge($input)
10622 
        {
10623 
                        /** @var \Illuminate\Http\Request $instance */
10624 
                        return $instance->merge($input);
10625 
        }
10626 
                    /**
10627 
         * Merge new input into the request's input, but only when that key is missing from the request.
10628 
         *
10629 
         * @param array $input
10630 
         * @return \Illuminate\Http\Request
10631 
         * @static
10632 
         */
10633 
        public static function mergeIfMissing($input)
10634 
        {
10635 
                        /** @var \Illuminate\Http\Request $instance */
10636 
                        return $instance->mergeIfMissing($input);
10637 
        }
10638 
                    /**
10639 
         * Replace the input for the current request.
10640 
         *
10641 
         * @param array $input
10642 
         * @return \Illuminate\Http\Request
10643 
         * @static
10644 
         */
10645 
        public static function replace($input)
10646 
        {
10647 
                        /** @var \Illuminate\Http\Request $instance */
10648 
                        return $instance->replace($input);
10649 
        }
10650 
                    /**
10651 
         * This method belongs to Symfony HttpFoundation and is not usually needed when using Laravel.
10652 
         *
10653 
         * Instead, you may use the "input" method.
10654 
         *
10655 
         * @param string $key
10656 
         * @param mixed $default
10657 
         * @return mixed
10658 
         * @static
10659 
         */
10660 
        public static function get($key, $default = null)
10661 
        {
10662 
                        /** @var \Illuminate\Http\Request $instance */
10663 
                        return $instance->get($key, $default);
10664 
        }
10665 
                    /**
10666 
         * Get the JSON payload for the request.
10667 
         *
10668 
         * @param string|null $key
10669 
         * @param mixed $default
10670 
         * @return \Symfony\Component\HttpFoundation\ParameterBag|mixed
10671 
         * @static
10672 
         */
10673 
        public static function json($key = null, $default = null)
10674 
        {
10675 
                        /** @var \Illuminate\Http\Request $instance */
10676 
                        return $instance->json($key, $default);
10677 
        }
10678 
                    /**
10679 
         * Create a new request instance from the given Laravel request.
10680 
         *
10681 
         * @param \Illuminate\Http\Request $from
10682 
         * @param \Illuminate\Http\Request|null $to
10683 
         * @return static
10684 
         * @static
10685 
         */
10686 
        public static function createFrom($from, $to = null)
10687 
        {
10688 
                        return \Illuminate\Http\Request::createFrom($from, $to);
10689 
        }
10690 
                    /**
10691 
         * Create an Illuminate request from a Symfony instance.
10692 
         *
10693 
         * @param \Symfony\Component\HttpFoundation\Request $request
10694 
         * @return static
10695 
         * @static
10696 
         */
10697 
        public static function createFromBase($request)
10698 
        {
10699 
                        return \Illuminate\Http\Request::createFromBase($request);
10700 
        }
10701 
                    /**
10702 
         * Clones a request and overrides some of its parameters.
10703 
         *
10704 
         * @return static
10705 
         * @param array|null $query The GET parameters
10706 
         * @param array|null $request The POST parameters
10707 
         * @param array|null $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
10708 
         * @param array|null $cookies The COOKIE parameters
10709 
         * @param array|null $files The FILES parameters
10710 
         * @param array|null $server The SERVER parameters
10711 
         * @static
10712 
         */
10713 
        public static function duplicate($query = null, $request = null, $attributes = null, $cookies = null, $files = null, $server = null)
10714 
        {
10715 
                        /** @var \Illuminate\Http\Request $instance */
10716 
                        return $instance->duplicate($query, $request, $attributes, $cookies, $files, $server);
10717 
        }
10718 
                    /**
10719 
         * Whether the request contains a Session object.
10720 
         *
10721 
         * This method does not give any information about the state of the session object,
10722 
         * like whether the session is started or not. It is just a way to check if this Request
10723 
         * is associated with a Session instance.
10724 
         *
10725 
         * @param bool $skipIfUninitialized When true, ignores factories injected by `setSessionFactory`
10726 
         * @static
10727 
         */
10728 
        public static function hasSession($skipIfUninitialized = false)
10729 
        {
10730 
                        /** @var \Illuminate\Http\Request $instance */
10731 
                        return $instance->hasSession($skipIfUninitialized);
10732 
        }
10733 
                    /**
10734 
         * Gets the Session.
10735 
         *
10736 
         * @throws SessionNotFoundException When session is not set properly
10737 
         * @static
10738 
         */
10739 
        public static function getSession()
10740 
        {
10741 
                        /** @var \Illuminate\Http\Request $instance */
10742 
                        return $instance->getSession();
10743 
        }
10744 
                    /**
10745 
         * Get the session associated with the request.
10746 
         *
10747 
         * @return \Illuminate\Contracts\Session\Session
10748 
         * @throws \RuntimeException
10749 
         * @static
10750 
         */
10751 
        public static function session()
10752 
        {
10753 
                        /** @var \Illuminate\Http\Request $instance */
10754 
                        return $instance->session();
10755 
        }
10756 
                    /**
10757 
         * Set the session instance on the request.
10758 
         *
10759 
         * @param \Illuminate\Contracts\Session\Session $session
10760 
         * @return void
10761 
         * @static
10762 
         */
10763 
        public static function setLaravelSession($session)
10764 
        {
10765 
                        /** @var \Illuminate\Http\Request $instance */
10766 
                        $instance->setLaravelSession($session);
10767 
        }
10768 
                    /**
10769 
         * Set the locale for the request instance.
10770 
         *
10771 
         * @param string $locale
10772 
         * @return void
10773 
         * @static
10774 
         */
10775 
        public static function setRequestLocale($locale)
10776 
        {
10777 
                        /** @var \Illuminate\Http\Request $instance */
10778 
                        $instance->setRequestLocale($locale);
10779 
        }
10780 
                    /**
10781 
         * Set the default locale for the request instance.
10782 
         *
10783 
         * @param string $locale
10784 
         * @return void
10785 
         * @static
10786 
         */
10787 
        public static function setDefaultRequestLocale($locale)
10788 
        {
10789 
                        /** @var \Illuminate\Http\Request $instance */
10790 
                        $instance->setDefaultRequestLocale($locale);
10791 
        }
10792 
                    /**
10793 
         * Get the user making the request.
10794 
         *
10795 
         * @param string|null $guard
10796 
         * @return mixed
10797 
         * @static
10798 
         */
10799 
        public static function user($guard = null)
10800 
        {
10801 
                        /** @var \Illuminate\Http\Request $instance */
10802 
                        return $instance->user($guard);
10803 
        }
10804 
                    /**
10805 
         * Get the route handling the request.
10806 
         *
10807 
         * @param string|null $param
10808 
         * @param mixed $default
10809 
         * @return \Illuminate\Routing\Route|object|string|null
10810 
         * @static
10811 
         */
10812 
        public static function route($param = null, $default = null)
10813 
        {
10814 
                        /** @var \Illuminate\Http\Request $instance */
10815 
                        return $instance->route($param, $default);
10816 
        }
10817 
                    /**
10818 
         * Get a unique fingerprint for the request / route / IP address.
10819 
         *
10820 
         * @return string
10821 
         * @throws \RuntimeException
10822 
         * @static
10823 
         */
10824 
        public static function fingerprint()
10825 
        {
10826 
                        /** @var \Illuminate\Http\Request $instance */
10827 
                        return $instance->fingerprint();
10828 
        }
10829 
                    /**
10830 
         * Set the JSON payload for the request.
10831 
         *
10832 
         * @param \Symfony\Component\HttpFoundation\ParameterBag $json
10833 
         * @return \Illuminate\Http\Request
10834 
         * @static
10835 
         */
10836 
        public static function setJson($json)
10837 
        {
10838 
                        /** @var \Illuminate\Http\Request $instance */
10839 
                        return $instance->setJson($json);
10840 
        }
10841 
                    /**
10842 
         * Get the user resolver callback.
10843 
         *
10844 
         * @return \Closure
10845 
         * @static
10846 
         */
10847 
        public static function getUserResolver()
10848 
        {
10849 
                        /** @var \Illuminate\Http\Request $instance */
10850 
                        return $instance->getUserResolver();
10851 
        }
10852 
                    /**
10853 
         * Set the user resolver callback.
10854 
         *
10855 
         * @param \Closure $callback
10856 
         * @return \Illuminate\Http\Request
10857 
         * @static
10858 
         */
10859 
        public static function setUserResolver($callback)
10860 
        {
10861 
                        /** @var \Illuminate\Http\Request $instance */
10862 
                        return $instance->setUserResolver($callback);
10863 
        }
10864 
                    /**
10865 
         * Get the route resolver callback.
10866 
         *
10867 
         * @return \Closure
10868 
         * @static
10869 
         */
10870 
        public static function getRouteResolver()
10871 
        {
10872 
                        /** @var \Illuminate\Http\Request $instance */
10873 
                        return $instance->getRouteResolver();
10874 
        }
10875 
                    /**
10876 
         * Set the route resolver callback.
10877 
         *
10878 
         * @param \Closure $callback
10879 
         * @return \Illuminate\Http\Request
10880 
         * @static
10881 
         */
10882 
        public static function setRouteResolver($callback)
10883 
        {
10884 
                        /** @var \Illuminate\Http\Request $instance */
10885 
                        return $instance->setRouteResolver($callback);
10886 
        }
10887 
                    /**
10888 
         * Get all of the input and files for the request.
10889 
         *
10890 
         * @return array
10891 
         * @static
10892 
         */
10893 
        public static function toArray()
10894 
        {
10895 
                        /** @var \Illuminate\Http\Request $instance */
10896 
                        return $instance->toArray();
10897 
        }
10898 
                    /**
10899 
         * Determine if the given offset exists.
10900 
         *
10901 
         * @param string $offset
10902 
         * @return bool
10903 
         * @static
10904 
         */
10905 
        public static function offsetExists($offset)
10906 
        {
10907 
                        /** @var \Illuminate\Http\Request $instance */
10908 
                        return $instance->offsetExists($offset);
10909 
        }
10910 
                    /**
10911 
         * Get the value at the given offset.
10912 
         *
10913 
         * @param string $offset
10914 
         * @return mixed
10915 
         * @static
10916 
         */
10917 
        public static function offsetGet($offset)
10918 
        {
10919 
                        /** @var \Illuminate\Http\Request $instance */
10920 
                        return $instance->offsetGet($offset);
10921 
        }
10922 
                    /**
10923 
         * Set the value at the given offset.
10924 
         *
10925 
         * @param string $offset
10926 
         * @param mixed $value
10927 
         * @return void
10928 
         * @static
10929 
         */
10930 
        public static function offsetSet($offset, $value)
10931 
        {
10932 
                        /** @var \Illuminate\Http\Request $instance */
10933 
                        $instance->offsetSet($offset, $value);
10934 
        }
10935 
                    /**
10936 
         * Remove the value at the given offset.
10937 
         *
10938 
         * @param string $offset
10939 
         * @return void
10940 
         * @static
10941 
         */
10942 
        public static function offsetUnset($offset)
10943 
        {
10944 
                        /** @var \Illuminate\Http\Request $instance */
10945 
                        $instance->offsetUnset($offset);
10946 
        }
10947 
                    /**
10948 
         * Sets the parameters for this request.
10949 
         *
10950 
         * This method also re-initializes all properties.
10951 
         *
10952 
         * @param array $query The GET parameters
10953 
         * @param array $request The POST parameters
10954 
         * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
10955 
         * @param array $cookies The COOKIE parameters
10956 
         * @param array $files The FILES parameters
10957 
         * @param array $server The SERVER parameters
10958 
         * @param string|resource|null $content The raw body data
10959 
         * @static
10960 
         */
10961 
        public static function initialize($query = [], $request = [], $attributes = [], $cookies = [], $files = [], $server = [], $content = null)
10962 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
10963 
                        /** @var \Illuminate\Http\Request $instance */
10964 
                        return $instance->initialize($query, $request, $attributes, $cookies, $files, $server, $content);
10965 
        }
10966 
                    /**
10967 
         * Creates a new request with values from PHP's super globals.
10968 
         *
10969 
         * @static
10970 
         */
10971 
        public static function createFromGlobals()
10972 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
10973 
                        return \Illuminate\Http\Request::createFromGlobals();
10974 
        }
10975 
                    /**
10976 
         * Creates a Request based on a given URI and configuration.
10977 
         *
10978 
         * The information contained in the URI always take precedence
10979 
         * over the other information (server and parameters).
10980 
         *
10981 
         * @param string $uri The URI
10982 
         * @param string $method The HTTP method
10983 
         * @param array $parameters The query (GET) or request (POST) parameters
10984 
         * @param array $cookies The request cookies ($_COOKIE)
10985 
         * @param array $files The request files ($_FILES)
10986 
         * @param array $server The server parameters ($_SERVER)
10987 
         * @param string|resource|null $content The raw body data
10988 
         * @static
10989 
         */
10990 
        public static function create($uri, $method = 'GET', $parameters = [], $cookies = [], $files = [], $server = [], $content = null)
10991 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
10992 
                        return \Illuminate\Http\Request::create($uri, $method, $parameters, $cookies, $files, $server, $content);
10993 
        }
10994 
                    /**
10995 
         * Sets a callable able to create a Request instance.
10996 
         *
10997 
         * This is mainly useful when you need to override the Request class
10998 
         * to keep BC with an existing system. It should not be used for any
10999 
         * other purpose.
11000 
         *
11001 
         * @static
11002 
         */
11003 
        public static function setFactory($callable)
11004 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11005 
                        return \Illuminate\Http\Request::setFactory($callable);
11006 
        }
11007 
                    /**
11008 
         * Overrides the PHP global variables according to this request instance.
11009 
         *
11010 
         * It overrides $_GET, $_POST, $_REQUEST, $_SERVER, $_COOKIE.
11011 
         * $_FILES is never overridden, see rfc1867
11012 
         *
11013 
         * @static
11014 
         */
11015 
        public static function overrideGlobals()
11016 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11017 
                        /** @var \Illuminate\Http\Request $instance */
11018 
                        return $instance->overrideGlobals();
11019 
        }
11020 
                    /**
11021 
         * Sets a list of trusted proxies.
11022 
         *
11023 
         * You should only list the reverse proxies that you manage directly.
11024 
         *
11025 
         * @param array $proxies A list of trusted proxies, the string 'REMOTE_ADDR' will be replaced with $_SERVER['REMOTE_ADDR']
11026 
         * @param int $trustedHeaderSet A bit field of Request::HEADER_*, to set which headers to trust from your proxies
11027 
         * @static
11028 
         */
11029 
        public static function setTrustedProxies($proxies, $trustedHeaderSet)
11030 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11031 
                        return \Illuminate\Http\Request::setTrustedProxies($proxies, $trustedHeaderSet);
11032 
        }
11033 
                    /**
11034 
         * Gets the list of trusted proxies.
11035 
         *
11036 
         * @return string[]
11037 
         * @static
11038 
         */
11039 
        public static function getTrustedProxies()
11040 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11041 
                        return \Illuminate\Http\Request::getTrustedProxies();
11042 
        }
11043 
                    /**
11044 
         * Gets the set of trusted headers from trusted proxies.
11045 
         *
11046 
         * @return int A bit field of Request::HEADER_* that defines which headers are trusted from your proxies
11047 
         * @static
11048 
         */
11049 
        public static function getTrustedHeaderSet()
11050 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11051 
                        return \Illuminate\Http\Request::getTrustedHeaderSet();
11052 
        }
11053 
                    /**
11054 
         * Sets a list of trusted host patterns.
11055 
         *
11056 
         * You should only list the hosts you manage using regexs.
11057 
         *
11058 
         * @param array $hostPatterns A list of trusted host patterns
11059 
         * @static
11060 
         */
11061 
        public static function setTrustedHosts($hostPatterns)
11062 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11063 
                        return \Illuminate\Http\Request::setTrustedHosts($hostPatterns);
11064 
        }
11065 
                    /**
11066 
         * Gets the list of trusted host patterns.
11067 
         *
11068 
         * @return string[]
11069 
         * @static
11070 
         */
11071 
        public static function getTrustedHosts()
11072 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11073 
                        return \Illuminate\Http\Request::getTrustedHosts();
11074 
        }
11075 
                    /**
11076 
         * Normalizes a query string.
11077 
         *
11078 
         * It builds a normalized query string, where keys/value pairs are alphabetized,
11079 
         * have consistent escaping and unneeded delimiters are removed.
11080 
         *
11081 
         * @static
11082 
         */
11083 
        public static function normalizeQueryString($qs)
11084 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11085 
                        return \Illuminate\Http\Request::normalizeQueryString($qs);
11086 
        }
11087 
                    /**
11088 
         * Enables support for the _method request parameter to determine the intended HTTP method.
11089 
         *
11090 
         * Be warned that enabling this feature might lead to CSRF issues in your code.
11091 
         * Check that you are using CSRF tokens when required.
11092 
         * If the HTTP method parameter override is enabled, an html-form with method "POST" can be altered
11093 
         * and used to send a "PUT" or "DELETE" request via the _method request parameter.
11094 
         * If these methods are not protected against CSRF, this presents a possible vulnerability.
11095 
         *
11096 
         * The HTTP method can only be overridden when the real HTTP method is POST.
11097 
         *
11098 
         * @static
11099 
         */
11100 
        public static function enableHttpMethodParameterOverride()
11101 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11102 
                        return \Illuminate\Http\Request::enableHttpMethodParameterOverride();
11103 
        }
11104 
                    /**
11105 
         * Checks whether support for the _method request parameter is enabled.
11106 
         *
11107 
         * @static
11108 
         */
11109 
        public static function getHttpMethodParameterOverride()
11110 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11111 
                        return \Illuminate\Http\Request::getHttpMethodParameterOverride();
11112 
        }
11113 
                    /**
11114 
         * Whether the request contains a Session which was started in one of the
11115 
         * previous requests.
11116 
         *
11117 
         * @static
11118 
         */
11119 
        public static function hasPreviousSession()
11120 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11121 
                        /** @var \Illuminate\Http\Request $instance */
11122 
                        return $instance->hasPreviousSession();
11123 
        }
11124 
                    /**
11125 
         *
11126 
         *
11127 
         * @static
11128 
         */
11129 
        public static function setSession($session)
11130 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11131 
                        /** @var \Illuminate\Http\Request $instance */
11132 
                        return $instance->setSession($session);
11133 
        }
11134 
                    /**
11135 
         *
11136 
         *
11137 
         * @internal
11138 
         * @param \Symfony\Component\HttpFoundation\callable():  SessionInterface $factory
11139 
         * @static
11140 
         */
11141 
        public static function setSessionFactory($factory)
11142 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11143 
                        /** @var \Illuminate\Http\Request $instance */
11144 
                        return $instance->setSessionFactory($factory);
11145 
        }
11146 
                    /**
11147 
         * Returns the client IP addresses.
11148 
         *
11149 
         * In the returned array the most trusted IP address is first, and the
11150 
         * least trusted one last. The "real" client IP address is the last one,
11151 
         * but this is also the least trusted one. Trusted proxies are stripped.
11152 
         *
11153 
         * Use this method carefully; you should use getClientIp() instead.
11154 
         *
11155 
         * @see getClientIp()
11156 
         * @static
11157 
         */
11158 
        public static function getClientIps()
11159 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11160 
                        /** @var \Illuminate\Http\Request $instance */
11161 
                        return $instance->getClientIps();
11162 
        }
11163 
                    /**
11164 
         * Returns the client IP address.
11165 
         *
11166 
         * This method can read the client IP address from the "X-Forwarded-For" header
11167 
         * when trusted proxies were set via "setTrustedProxies()". The "X-Forwarded-For"
11168 
         * header value is a comma+space separated list of IP addresses, the left-most
11169 
         * being the original client, and each successive proxy that passed the request
11170 
         * adding the IP address where it received the request from.
11171 
         *
11172 
         * If your reverse proxy uses a different header name than "X-Forwarded-For",
11173 
         * ("Client-Ip" for instance), configure it via the $trustedHeaderSet
11174 
         * argument of the Request::setTrustedProxies() method instead.
11175 
         *
11176 
         * @see getClientIps()
11177 
         * @see https://wikipedia.org/wiki/X-Forwarded-For
11178 
         * @static
11179 
         */
11180 
        public static function getClientIp()
11181 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11182 
                        /** @var \Illuminate\Http\Request $instance */
11183 
                        return $instance->getClientIp();
11184 
        }
11185 
                    /**
11186 
         * Returns current script name.
11187 
         *
11188 
         * @static
11189 
         */
11190 
        public static function getScriptName()
11191 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11192 
                        /** @var \Illuminate\Http\Request $instance */
11193 
                        return $instance->getScriptName();
11194 
        }
11195 
                    /**
11196 
         * Returns the path being requested relative to the executed script.
11197 
         *
11198 
         * The path info always starts with a /.
11199 
         *
11200 
         * Suppose this request is instantiated from /mysite on localhost:
11201 
         *
11202 
         *  * http://localhost/mysite              returns an empty string
11203 
         *  * http://localhost/mysite/about        returns '/about'
11204 
         *  * http://localhost/mysite/enco%20ded   returns '/enco%20ded'
11205 
         *  * http://localhost/mysite/about?var=1  returns '/about'
11206 
         *
11207 
         * @return string The raw path (i.e. not urldecoded)
11208 
         * @static
11209 
         */
11210 
        public static function getPathInfo()
11211 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11212 
                        /** @var \Illuminate\Http\Request $instance */
11213 
                        return $instance->getPathInfo();
11214 
        }
11215 
                    /**
11216 
         * Returns the root path from which this request is executed.
11217 
         *
11218 
         * Suppose that an index.php file instantiates this request object:
11219 
         *
11220 
         *  * http://localhost/index.php         returns an empty string
11221 
         *  * http://localhost/index.php/page    returns an empty string
11222 
         *  * http://localhost/web/index.php     returns '/web'
11223 
         *  * http://localhost/we%20b/index.php  returns '/we%20b'
11224 
         *
11225 
         * @return string The raw path (i.e. not urldecoded)
11226 
         * @static
11227 
         */
11228 
        public static function getBasePath()
11229 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11230 
                        /** @var \Illuminate\Http\Request $instance */
11231 
                        return $instance->getBasePath();
11232 
        }
11233 
                    /**
11234 
         * Returns the root URL from which this request is executed.
11235 
         *
11236 
         * The base URL never ends with a /.
11237 
         *
11238 
         * This is similar to getBasePath(), except that it also includes the
11239 
         * script filename (e.g. index.php) if one exists.
11240 
         *
11241 
         * @return string The raw URL (i.e. not urldecoded)
11242 
         * @static
11243 
         */
11244 
        public static function getBaseUrl()
11245 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11246 
                        /** @var \Illuminate\Http\Request $instance */
11247 
                        return $instance->getBaseUrl();
11248 
        }
11249 
                    /**
11250 
         * Gets the request's scheme.
11251 
         *
11252 
         * @static
11253 
         */
11254 
        public static function getScheme()
11255 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11256 
                        /** @var \Illuminate\Http\Request $instance */
11257 
                        return $instance->getScheme();
11258 
        }
11259 
                    /**
11260 
         * Returns the port on which the request is made.
11261 
         *
11262 
         * This method can read the client port from the "X-Forwarded-Port" header
11263 
         * when trusted proxies were set via "setTrustedProxies()".
11264 
         *
11265 
         * The "X-Forwarded-Port" header must contain the client port.
11266 
         *
11267 
         * @return int|string|null Can be a string if fetched from the server bag
11268 
         * @static
11269 
         */
11270 
        public static function getPort()
11271 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11272 
                        /** @var \Illuminate\Http\Request $instance */
11273 
                        return $instance->getPort();
11274 
        }
11275 
                    /**
11276 
         * Returns the user.
11277 
         *
11278 
         * @static
11279 
         */
11280 
        public static function getUser()
11281 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11282 
                        /** @var \Illuminate\Http\Request $instance */
11283 
                        return $instance->getUser();
11284 
        }
11285 
                    /**
11286 
         * Returns the password.
11287 
         *
11288 
         * @static
11289 
         */
11290 
        public static function getPassword()
11291 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11292 
                        /** @var \Illuminate\Http\Request $instance */
11293 
                        return $instance->getPassword();
11294 
        }
11295 
                    /**
11296 
         * Gets the user info.
11297 
         *
11298 
         * @return string|null A user name if any and, optionally, scheme-specific information about how to gain authorization to access the server
11299 
         * @static
11300 
         */
11301 
        public static function getUserInfo()
11302 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11303 
                        /** @var \Illuminate\Http\Request $instance */
11304 
                        return $instance->getUserInfo();
11305 
        }
11306 
                    /**
11307 
         * Returns the HTTP host being requested.
11308 
         *
11309 
         * The port name will be appended to the host if it's non-standard.
11310 
         *
11311 
         * @static
11312 
         */
11313 
        public static function getHttpHost()
11314 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11315 
                        /** @var \Illuminate\Http\Request $instance */
11316 
                        return $instance->getHttpHost();
11317 
        }
11318 
                    /**
11319 
         * Returns the requested URI (path and query string).
11320 
         *
11321 
         * @return string The raw URI (i.e. not URI decoded)
11322 
         * @static
11323 
         */
11324 
        public static function getRequestUri()
11325 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11326 
                        /** @var \Illuminate\Http\Request $instance */
11327 
                        return $instance->getRequestUri();
11328 
        }
11329 
                    /**
11330 
         * Gets the scheme and HTTP host.
11331 
         *
11332 
         * If the URL was called with basic authentication, the user
11333 
         * and the password are not added to the generated string.
11334 
         *
11335 
         * @static
11336 
         */
11337 
        public static function getSchemeAndHttpHost()
11338 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11339 
                        /** @var \Illuminate\Http\Request $instance */
11340 
                        return $instance->getSchemeAndHttpHost();
11341 
        }
11342 
                    /**
11343 
         * Generates a normalized URI (URL) for the Request.
11344 
         *
11345 
         * @see getQueryString()
11346 
         * @static
11347 
         */
11348 
        public static function getUri()
11349 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11350 
                        /** @var \Illuminate\Http\Request $instance */
11351 
                        return $instance->getUri();
11352 
        }
11353 
                    /**
11354 
         * Generates a normalized URI for the given path.
11355 
         *
11356 
         * @param string $path A path to use instead of the current one
11357 
         * @static
11358 
         */
11359 
        public static function getUriForPath($path)
11360 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11361 
                        /** @var \Illuminate\Http\Request $instance */
11362 
                        return $instance->getUriForPath($path);
11363 
        }
11364 
                    /**
11365 
         * Returns the path as relative reference from the current Request path.
11366 
         *
11367 
         * Only the URIs path component (no schema, host etc.) is relevant and must be given.
11368 
         * Both paths must be absolute and not contain relative parts.
11369 
         * Relative URLs from one resource to another are useful when generating self-contained downloadable document archives.
11370 
         * Furthermore, they can be used to reduce the link size in documents.
11371 
         *
11372 
         * Example target paths, given a base path of "/a/b/c/d":
11373 
         * - "/a/b/c/d"     -> ""
11374 
         * - "/a/b/c/"      -> "./"
11375 
         * - "/a/b/"        -> "../"
11376 
         * - "/a/b/c/other" -> "other"
11377 
         * - "/a/x/y"       -> "../../x/y"
11378 
         *
11379 
         * @static
11380 
         */
11381 
        public static function getRelativeUriForPath($path)
11382 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11383 
                        /** @var \Illuminate\Http\Request $instance */
11384 
                        return $instance->getRelativeUriForPath($path);
11385 
        }
11386 
                    /**
11387 
         * Generates the normalized query string for the Request.
11388 
         *
11389 
         * It builds a normalized query string, where keys/value pairs are alphabetized
11390 
         * and have consistent escaping.
11391 
         *
11392 
         * @static
11393 
         */
11394 
        public static function getQueryString()
11395 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11396 
                        /** @var \Illuminate\Http\Request $instance */
11397 
                        return $instance->getQueryString();
11398 
        }
11399 
                    /**
11400 
         * Checks whether the request is secure or not.
11401 
         *
11402 
         * This method can read the client protocol from the "X-Forwarded-Proto" header
11403 
         * when trusted proxies were set via "setTrustedProxies()".
11404 
         *
11405 
         * The "X-Forwarded-Proto" header must contain the protocol: "https" or "http".
11406 
         *
11407 
         * @static
11408 
         */
11409 
        public static function isSecure()
11410 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11411 
                        /** @var \Illuminate\Http\Request $instance */
11412 
                        return $instance->isSecure();
11413 
        }
11414 
                    /**
11415 
         * Returns the host name.
11416 
         *
11417 
         * This method can read the client host name from the "X-Forwarded-Host" header
11418 
         * when trusted proxies were set via "setTrustedProxies()".
11419 
         *
11420 
         * The "X-Forwarded-Host" header must contain the client host name.
11421 
         *
11422 
         * @throws SuspiciousOperationException when the host name is invalid or not trusted
11423 
         * @static
11424 
         */
11425 
        public static function getHost()
11426 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11427 
                        /** @var \Illuminate\Http\Request $instance */
11428 
                        return $instance->getHost();
11429 
        }
11430 
                    /**
11431 
         * Sets the request method.
11432 
         *
11433 
         * @static
11434 
         */
11435 
        public static function setMethod($method)
11436 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11437 
                        /** @var \Illuminate\Http\Request $instance */
11438 
                        return $instance->setMethod($method);
11439 
        }
11440 
                    /**
11441 
         * Gets the request "intended" method.
11442 
         *
11443 
         * If the X-HTTP-Method-Override header is set, and if the method is a POST,
11444 
         * then it is used to determine the "real" intended HTTP method.
11445 
         *
11446 
         * The _method request parameter can also be used to determine the HTTP method,
11447 
         * but only if enableHttpMethodParameterOverride() has been called.
11448 
         *
11449 
         * The method is always an uppercased string.
11450 
         *
11451 
         * @see getRealMethod()
11452 
         * @static
11453 
         */
11454 
        public static function getMethod()
11455 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11456 
                        /** @var \Illuminate\Http\Request $instance */
11457 
                        return $instance->getMethod();
11458 
        }
11459 
                    /**
11460 
         * Gets the "real" request method.
11461 
         *
11462 
         * @see getMethod()
11463 
         * @static
11464 
         */
11465 
        public static function getRealMethod()
11466 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11467 
                        /** @var \Illuminate\Http\Request $instance */
11468 
                        return $instance->getRealMethod();
11469 
        }
11470 
                    /**
11471 
         * Gets the mime type associated with the format.
11472 
         *
11473 
         * @static
11474 
         */
11475 
        public static function getMimeType($format)
11476 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11477 
                        /** @var \Illuminate\Http\Request $instance */
11478 
                        return $instance->getMimeType($format);
11479 
        }
11480 
                    /**
11481 
         * Gets the mime types associated with the format.
11482 
         *
11483 
         * @return string[]
11484 
         * @static
11485 
         */
11486 
        public static function getMimeTypes($format)
11487 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11488 
                        return \Illuminate\Http\Request::getMimeTypes($format);
11489 
        }
11490 
                    /**
11491 
         * Gets the format associated with the mime type.
11492 
         *
11493 
         * @static
11494 
         */
11495 
        public static function getFormat($mimeType)
11496 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11497 
                        /** @var \Illuminate\Http\Request $instance */
11498 
                        return $instance->getFormat($mimeType);
11499 
        }
11500 
                    /**
11501 
         * Associates a format with mime types.
11502 
         *
11503 
         * @param string|string[] $mimeTypes The associated mime types (the preferred one must be the first as it will be used as the content type)
11504 
         * @static
11505 
         */
11506 
        public static function setFormat($format, $mimeTypes)
11507 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11508 
                        /** @var \Illuminate\Http\Request $instance */
11509 
                        return $instance->setFormat($format, $mimeTypes);
11510 
        }
11511 
                    /**
11512 
         * Gets the request format.
11513 
         *
11514 
         * Here is the process to determine the format:
11515 
         *
11516 
         *  * format defined by the user (with setRequestFormat())
11517 
         *  * _format request attribute
11518 
         *  * $default
11519 
         *
11520 
         * @see getPreferredFormat
11521 
         * @static
11522 
         */
11523 
        public static function getRequestFormat($default = 'html')
11524 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11525 
                        /** @var \Illuminate\Http\Request $instance */
11526 
                        return $instance->getRequestFormat($default);
11527 
        }
11528 
                    /**
11529 
         * Sets the request format.
11530 
         *
11531 
         * @static
11532 
         */
11533 
        public static function setRequestFormat($format)
11534 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11535 
                        /** @var \Illuminate\Http\Request $instance */
11536 
                        return $instance->setRequestFormat($format);
11537 
        }
11538 
                    /**
11539 
         * Gets the usual name of the format associated with the request's media type (provided in the Content-Type header).
11540 
         *
11541 
         * @deprecated since Symfony 6.2, use getContentTypeFormat() instead
11542 
         * @static
11543 
         */
11544 
        public static function getContentType()
11545 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11546 
                        /** @var \Illuminate\Http\Request $instance */
11547 
                        return $instance->getContentType();
11548 
        }
11549 
                    /**
11550 
         * Gets the usual name of the format associated with the request's media type (provided in the Content-Type header).
11551 
         *
11552 
         * @see Request::$formats
11553 
         * @static
11554 
         */
11555 
        public static function getContentTypeFormat()
11556 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11557 
                        /** @var \Illuminate\Http\Request $instance */
11558 
                        return $instance->getContentTypeFormat();
11559 
        }
11560 
                    /**
11561 
         * Sets the default locale.
11562 
         *
11563 
         * @static
11564 
         */
11565 
        public static function setDefaultLocale($locale)
11566 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11567 
                        /** @var \Illuminate\Http\Request $instance */
11568 
                        return $instance->setDefaultLocale($locale);
11569 
        }
11570 
                    /**
11571 
         * Get the default locale.
11572 
         *
11573 
         * @static
11574 
         */
11575 
        public static function getDefaultLocale()
11576 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11577 
                        /** @var \Illuminate\Http\Request $instance */
11578 
                        return $instance->getDefaultLocale();
11579 
        }
11580 
                    /**
11581 
         * Sets the locale.
11582 
         *
11583 
         * @static
11584 
         */
11585 
        public static function setLocale($locale)
11586 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11587 
                        /** @var \Illuminate\Http\Request $instance */
11588 
                        return $instance->setLocale($locale);
11589 
        }
11590 
                    /**
11591 
         * Get the locale.
11592 
         *
11593 
         * @static
11594 
         */
11595 
        public static function getLocale()
11596 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11597 
                        /** @var \Illuminate\Http\Request $instance */
11598 
                        return $instance->getLocale();
11599 
        }
11600 
                    /**
11601 
         * Checks if the request method is of specified type.
11602 
         *
11603 
         * @param string $method Uppercase request method (GET, POST etc)
11604 
         * @static
11605 
         */
11606 
        public static function isMethod($method)
11607 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11608 
                        /** @var \Illuminate\Http\Request $instance */
11609 
                        return $instance->isMethod($method);
11610 
        }
11611 
                    /**
11612 
         * Checks whether or not the method is safe.
11613 
         *
11614 
         * @see https://tools.ietf.org/html/rfc7231#section-4.2.1
11615 
         * @static
11616 
         */
11617 
        public static function isMethodSafe()
11618 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11619 
                        /** @var \Illuminate\Http\Request $instance */
11620 
                        return $instance->isMethodSafe();
11621 
        }
11622 
                    /**
11623 
         * Checks whether or not the method is idempotent.
11624 
         *
11625 
         * @static
11626 
         */
11627 
        public static function isMethodIdempotent()
11628 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11629 
                        /** @var \Illuminate\Http\Request $instance */
11630 
                        return $instance->isMethodIdempotent();
11631 
        }
11632 
                    /**
11633 
         * Checks whether the method is cacheable or not.
11634 
         *
11635 
         * @see https://tools.ietf.org/html/rfc7231#section-4.2.3
11636 
         * @static
11637 
         */
11638 
        public static function isMethodCacheable()
11639 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11640 
                        /** @var \Illuminate\Http\Request $instance */
11641 
                        return $instance->isMethodCacheable();
11642 
        }
11643 
                    /**
11644 
         * Returns the protocol version.
11645 
         *
11646 
         * If the application is behind a proxy, the protocol version used in the
11647 
         * requests between the client and the proxy and between the proxy and the
11648 
         * server might be different. This returns the former (from the "Via" header)
11649 
         * if the proxy is trusted (see "setTrustedProxies()"), otherwise it returns
11650 
         * the latter (from the "SERVER_PROTOCOL" server parameter).
11651 
         *
11652 
         * @static
11653 
         */
11654 
        public static function getProtocolVersion()
11655 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11656 
                        /** @var \Illuminate\Http\Request $instance */
11657 
                        return $instance->getProtocolVersion();
11658 
        }
11659 
                    /**
11660 
         * Returns the request body content.
11661 
         *
11662 
         * @param bool $asResource If true, a resource will be returned
11663 
         * @return string|resource
11664 
         * @psalm-return ($asResource is true ? resource : string)
11665 
         * @static
11666 
         */
11667 
        public static function getContent($asResource = false)
11668 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11669 
                        /** @var \Illuminate\Http\Request $instance */
11670 
                        return $instance->getContent($asResource);
11671 
        }
11672 
                    /**
11673 
         * Gets the Etags.
11674 
         *
11675 
         * @static
11676 
         */
11677 
        public static function getETags()
11678 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11679 
                        /** @var \Illuminate\Http\Request $instance */
11680 
                        return $instance->getETags();
11681 
        }
11682 
                    /**
11683 
         *
11684 
         *
11685 
         * @static
11686 
         */
11687 
        public static function isNoCache()
11688 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11689 
                        /** @var \Illuminate\Http\Request $instance */
11690 
                        return $instance->isNoCache();
11691 
        }
11692 
                    /**
11693 
         * Gets the preferred format for the response by inspecting, in the following order:
11694 
         *   * the request format set using setRequestFormat;
11695 
         *   * the values of the Accept HTTP header.
11696 
         *
11697 
         * Note that if you use this method, you should send the "Vary: Accept" header
11698 
         * in the response to prevent any issues with intermediary HTTP caches.
11699 
         *
11700 
         * @static
11701 
         */
11702 
        public static function getPreferredFormat($default = 'html')
11703 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11704 
                        /** @var \Illuminate\Http\Request $instance */
11705 
                        return $instance->getPreferredFormat($default);
11706 
        }
11707 
                    /**
11708 
         * Returns the preferred language.
11709 
         *
11710 
         * @param string[] $locales An array of ordered available locales
11711 
         * @static
11712 
         */
11713 
        public static function getPreferredLanguage($locales = null)
11714 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11715 
                        /** @var \Illuminate\Http\Request $instance */
11716 
                        return $instance->getPreferredLanguage($locales);
11717 
        }
11718 
                    /**
11719 
         * Gets a list of languages acceptable by the client browser ordered in the user browser preferences.
11720 
         *
11721 
         * @return string[]
11722 
         * @static
11723 
         */
11724 
        public static function getLanguages()
11725 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11726 
                        /** @var \Illuminate\Http\Request $instance */
11727 
                        return $instance->getLanguages();
11728 
        }
11729 
                    /**
11730 
         * Gets a list of charsets acceptable by the client browser in preferable order.
11731 
         *
11732 
         * @return string[]
11733 
         * @static
11734 
         */
11735 
        public static function getCharsets()
11736 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11737 
                        /** @var \Illuminate\Http\Request $instance */
11738 
                        return $instance->getCharsets();
11739 
        }
11740 
                    /**
11741 
         * Gets a list of encodings acceptable by the client browser in preferable order.
11742 
         *
11743 
         * @return string[]
11744 
         * @static
11745 
         */
11746 
        public static function getEncodings()
11747 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11748 
                        /** @var \Illuminate\Http\Request $instance */
11749 
                        return $instance->getEncodings();
11750 
        }
11751 
                    /**
11752 
         * Gets a list of content types acceptable by the client browser in preferable order.
11753 
         *
11754 
         * @return string[]
11755 
         * @static
11756 
         */
11757 
        public static function getAcceptableContentTypes()
11758 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11759 
                        /** @var \Illuminate\Http\Request $instance */
11760 
                        return $instance->getAcceptableContentTypes();
11761 
        }
11762 
                    /**
11763 
         * Returns true if the request is an XMLHttpRequest.
11764 
         *
11765 
         * It works if your JavaScript library sets an X-Requested-With HTTP header.
11766 
         * It is known to work with common JavaScript frameworks:
11767 
         *
11768 
         * @see https://wikipedia.org/wiki/List_of_Ajax_frameworks#JavaScript
11769 
         * @static
11770 
         */
11771 
        public static function isXmlHttpRequest()
11772 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11773 
                        /** @var \Illuminate\Http\Request $instance */
11774 
                        return $instance->isXmlHttpRequest();
11775 
        }
11776 
                    /**
11777 
         * Checks whether the client browser prefers safe content or not according to RFC8674.
11778 
         *
11779 
         * @see https://tools.ietf.org/html/rfc8674
11780 
         * @static
11781 
         */
11782 
        public static function preferSafeContent()
11783 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11784 
                        /** @var \Illuminate\Http\Request $instance */
11785 
                        return $instance->preferSafeContent();
11786 
        }
11787 
                    /**
11788 
         * Indicates whether this request originated from a trusted proxy.
11789 
         *
11790 
         * This can be useful to determine whether or not to trust the
11791 
         * contents of a proxy-specific header.
11792 
         *
11793 
         * @static
11794 
         */
11795 
        public static function isFromTrustedProxy()
11796 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11797 
                        /** @var \Illuminate\Http\Request $instance */
11798 
                        return $instance->isFromTrustedProxy();
11799 
        }
11800 
                    /**
11801 
         * Filter the given array of rules into an array of rules that are included in precognitive headers.
11802 
         *
11803 
         * @param array $rules
11804 
         * @return array
11805 
         * @static
11806 
         */
11807 
        public static function filterPrecognitiveRules($rules)
11808 
        {
11809 
                        /** @var \Illuminate\Http\Request $instance */
11810 
                        return $instance->filterPrecognitiveRules($rules);
11811 
        }
11812 
                    /**
11813 
         * Determine if the request is attempting to be precognitive.
11814 
         *
11815 
         * @return bool
11816 
         * @static
11817 
         */
11818 
        public static function isAttemptingPrecognition()
11819 
        {
11820 
                        /** @var \Illuminate\Http\Request $instance */
11821 
                        return $instance->isAttemptingPrecognition();
11822 
        }
11823 
                    /**
11824 
         * Determine if the request is precognitive.
11825 
         *
11826 
         * @return bool
11827 
         * @static
11828 
         */
11829 
        public static function isPrecognitive()
11830 
        {
11831 
                        /** @var \Illuminate\Http\Request $instance */
11832 
                        return $instance->isPrecognitive();
11833 
        }
11834 
                    /**
11835 
         * Determine if the request is sending JSON.
11836 
         *
11837 
         * @return bool
11838 
         * @static
11839 
         */
11840 
        public static function isJson()
11841 
        {
11842 
                        /** @var \Illuminate\Http\Request $instance */
11843 
                        return $instance->isJson();
11844 
        }
11845 
                    /**
11846 
         * Determine if the current request probably expects a JSON response.
11847 
         *
11848 
         * @return bool
11849 
         * @static
11850 
         */
11851 
        public static function expectsJson()
11852 
        {
11853 
                        /** @var \Illuminate\Http\Request $instance */
11854 
                        return $instance->expectsJson();
11855 
        }
11856 
                    /**
11857 
         * Determine if the current request is asking for JSON.
11858 
         *
11859 
         * @return bool
11860 
         * @static
11861 
         */
11862 
        public static function wantsJson()
11863 
        {
11864 
                        /** @var \Illuminate\Http\Request $instance */
11865 
                        return $instance->wantsJson();
11866 
        }
11867 
                    /**
11868 
         * Determines whether the current requests accepts a given content type.
11869 
         *
11870 
         * @param string|array $contentTypes
11871 
         * @return bool
11872 
         * @static
11873 
         */
11874 
        public static function accepts($contentTypes)
11875 
        {
11876 
                        /** @var \Illuminate\Http\Request $instance */
11877 
                        return $instance->accepts($contentTypes);
11878 
        }
11879 
                    /**
11880 
         * Return the most suitable content type from the given array based on content negotiation.
11881 
         *
11882 
         * @param string|array $contentTypes
11883 
         * @return string|null
11884 
         * @static
11885 
         */
11886 
        public static function prefers($contentTypes)
11887 
        {
11888 
                        /** @var \Illuminate\Http\Request $instance */
11889 
                        return $instance->prefers($contentTypes);
11890 
        }
11891 
                    /**
11892 
         * Determine if the current request accepts any content type.
11893 
         *
11894 
         * @return bool
11895 
         * @static
11896 
         */
11897 
        public static function acceptsAnyContentType()
11898 
        {
11899 
                        /** @var \Illuminate\Http\Request $instance */
11900 
                        return $instance->acceptsAnyContentType();
11901 
        }
11902 
                    /**
11903 
         * Determines whether a request accepts JSON.
11904 
         *
11905 
         * @return bool
11906 
         * @static
11907 
         */
11908 
        public static function acceptsJson()
11909 
        {
11910 
                        /** @var \Illuminate\Http\Request $instance */
11911 
                        return $instance->acceptsJson();
11912 
        }
11913 
                    /**
11914 
         * Determines whether a request accepts HTML.
11915 
         *
11916 
         * @return bool
11917 
         * @static
11918 
         */
11919 
        public static function acceptsHtml()
11920 
        {
11921 
                        /** @var \Illuminate\Http\Request $instance */
11922 
                        return $instance->acceptsHtml();
11923 
        }
11924 
                    /**
11925 
         * Determine if the given content types match.
11926 
         *
11927 
         * @param string $actual
11928 
         * @param string $type
11929 
         * @return bool
11930 
         * @static
11931 
         */
11932 
        public static function matchesType($actual, $type)
11933 
        {
11934 
                        return \Illuminate\Http\Request::matchesType($actual, $type);
11935 
        }
11936 
                    /**
11937 
         * Get the data format expected in the response.
11938 
         *
11939 
         * @param string $default
11940 
         * @return string
11941 
         * @static
11942 
         */
11943 
        public static function format($default = 'html')
11944 
        {
11945 
                        /** @var \Illuminate\Http\Request $instance */
11946 
                        return $instance->format($default);
11947 
        }
11948 
                    /**
11949 
         * Retrieve an old input item.
11950 
         *
11951 
         * @param string|null $key
11952 
         * @param \Illuminate\Database\Eloquent\Model|string|array|null $default
11953 
         * @return string|array|null
11954 
         * @static
11955 
         */
11956 
        public static function old($key = null, $default = null)
11957 
        {
11958 
                        /** @var \Illuminate\Http\Request $instance */
11959 
                        return $instance->old($key, $default);
11960 
        }
11961 
                    /**
11962 
         * Flash the input for the current request to the session.
11963 
         *
11964 
         * @return void
11965 
         * @static
11966 
         */
11967 
        public static function flash()
11968 
        {
11969 
                        /** @var \Illuminate\Http\Request $instance */
11970 
                        $instance->flash();
11971 
        }
11972 
                    /**
11973 
         * Flash only some of the input to the session.
11974 
         *
11975 
         * @param array|mixed $keys
11976 
         * @return void
11977 
         * @static
11978 
         */
11979 
        public static function flashOnly($keys)
11980 
        {
11981 
                        /** @var \Illuminate\Http\Request $instance */
11982 
                        $instance->flashOnly($keys);
11983 
        }
11984 
                    /**
11985 
         * Flash only some of the input to the session.
11986 
         *
11987 
         * @param array|mixed $keys
11988 
         * @return void
11989 
         * @static
11990 
         */
11991 
        public static function flashExcept($keys)
11992 
        {
11993 
                        /** @var \Illuminate\Http\Request $instance */
11994 
                        $instance->flashExcept($keys);
11995 
        }
11996 
                    /**
11997 
         * Flush all of the old input from the session.
11998 
         *
11999 
         * @return void
12000 
         * @static
12001 
         */
12002 
        public static function flush()
12003 
        {
12004 
                        /** @var \Illuminate\Http\Request $instance */
12005 
                        $instance->flush();
12006 
        }
12007 
                    /**
12008 
         * Retrieve a server variable from the request.
12009 
         *
12010 
         * @param string|null $key
12011 
         * @param string|array|null $default
12012 
         * @return string|array|null
12013 
         * @static
12014 
         */
12015 
        public static function server($key = null, $default = null)
12016 
        {
12017 
                        /** @var \Illuminate\Http\Request $instance */
12018 
                        return $instance->server($key, $default);
12019 
        }
12020 
                    /**
12021 
         * Determine if a header is set on the request.
12022 
         *
12023 
         * @param string $key
12024 
         * @return bool
12025 
         * @static
12026 
         */
12027 
        public static function hasHeader($key)
12028 
        {
12029 
                        /** @var \Illuminate\Http\Request $instance */
12030 
                        return $instance->hasHeader($key);
12031 
        }
12032 
                    /**
12033 
         * Retrieve a header from the request.
12034 
         *
12035 
         * @param string|null $key
12036 
         * @param string|array|null $default
12037 
         * @return string|array|null
12038 
         * @static
12039 
         */
12040 
        public static function header($key = null, $default = null)
12041 
        {
12042 
                        /** @var \Illuminate\Http\Request $instance */
12043 
                        return $instance->header($key, $default);
12044 
        }
12045 
                    /**
12046 
         * Get the bearer token from the request headers.
12047 
         *
12048 
         * @return string|null
12049 
         * @static
12050 
         */
12051 
        public static function bearerToken()
12052 
        {
12053 
                        /** @var \Illuminate\Http\Request $instance */
12054 
                        return $instance->bearerToken();
12055 
        }
12056 
                    /**
12057 
         * Determine if the request contains a given input item key.
12058 
         *
12059 
         * @param string|array $key
12060 
         * @return bool
12061 
         * @static
12062 
         */
12063 
        public static function exists($key)
12064 
        {
12065 
                        /** @var \Illuminate\Http\Request $instance */
12066 
                        return $instance->exists($key);
12067 
        }
12068 
                    /**
12069 
         * Determine if the request contains a given input item key.
12070 
         *
12071 
         * @param string|array $key
12072 
         * @return bool
12073 
         * @static
12074 
         */
12075 
        public static function has($key)
12076 
        {
12077 
                        /** @var \Illuminate\Http\Request $instance */
12078 
                        return $instance->has($key);
12079 
        }
12080 
                    /**
12081 
         * Determine if the request contains any of the given inputs.
12082 
         *
12083 
         * @param string|array $keys
12084 
         * @return bool
12085 
         * @static
12086 
         */
12087 
        public static function hasAny($keys)
12088 
        {
12089 
                        /** @var \Illuminate\Http\Request $instance */
12090 
                        return $instance->hasAny($keys);
12091 
        }
12092 
                    /**
12093 
         * Apply the callback if the request contains the given input item key.
12094 
         *
12095 
         * @param string $key
12096 
         * @param callable $callback
12097 
         * @param callable|null $default
12098 
         * @return $this|mixed
12099 
         * @static
12100 
         */
12101 
        public static function whenHas($key, $callback, $default = null)
12102 
        {
12103 
                        /** @var \Illuminate\Http\Request $instance */
12104 
                        return $instance->whenHas($key, $callback, $default);
12105 
        }
12106 
                    /**
12107 
         * Determine if the request contains a non-empty value for an input item.
12108 
         *
12109 
         * @param string|array $key
12110 
         * @return bool
12111 
         * @static
12112 
         */
12113 
        public static function filled($key)
12114 
        {
12115 
                        /** @var \Illuminate\Http\Request $instance */
12116 
                        return $instance->filled($key);
12117 
        }
12118 
                    /**
12119 
         * Determine if the request contains an empty value for an input item.
12120 
         *
12121 
         * @param string|array $key
12122 
         * @return bool
12123 
         * @static
12124 
         */
12125 
        public static function isNotFilled($key)
12126 
        {
12127 
                        /** @var \Illuminate\Http\Request $instance */
12128 
                        return $instance->isNotFilled($key);
12129 
        }
12130 
                    /**
12131 
         * Determine if the request contains a non-empty value for any of the given inputs.
12132 
         *
12133 
         * @param string|array $keys
12134 
         * @return bool
12135 
         * @static
12136 
         */
12137 
        public static function anyFilled($keys)
12138 
        {
12139 
                        /** @var \Illuminate\Http\Request $instance */
12140 
                        return $instance->anyFilled($keys);
12141 
        }
12142 
                    /**
12143 
         * Apply the callback if the request contains a non-empty value for the given input item key.
12144 
         *
12145 
         * @param string $key
12146 
         * @param callable $callback
12147 
         * @param callable|null $default
12148 
         * @return $this|mixed
12149 
         * @static
12150 
         */
12151 
        public static function whenFilled($key, $callback, $default = null)
12152 
        {
12153 
                        /** @var \Illuminate\Http\Request $instance */
12154 
                        return $instance->whenFilled($key, $callback, $default);
12155 
        }
12156 
                    /**
12157 
         * Determine if the request is missing a given input item key.
12158 
         *
12159 
         * @param string|array $key
12160 
         * @return bool
12161 
         * @static
12162 
         */
12163 
        public static function missing($key)
12164 
        {
12165 
                        /** @var \Illuminate\Http\Request $instance */
12166 
                        return $instance->missing($key);
12167 
        }
12168 
                    /**
12169 
         * Apply the callback if the request is missing the given input item key.
12170 
         *
12171 
         * @param string $key
12172 
         * @param callable $callback
12173 
         * @param callable|null $default
12174 
         * @return $this|mixed
12175 
         * @static
12176 
         */
12177 
        public static function whenMissing($key, $callback, $default = null)
12178 
        {
12179 
                        /** @var \Illuminate\Http\Request $instance */
12180 
                        return $instance->whenMissing($key, $callback, $default);
12181 
        }
12182 
                    /**
12183 
         * Get the keys for all of the input and files.
12184 
         *
12185 
         * @return array
12186 
         * @static
12187 
         */
12188 
        public static function keys()
12189 
        {
12190 
                        /** @var \Illuminate\Http\Request $instance */
12191 
                        return $instance->keys();
12192 
        }
12193 
                    /**
12194 
         * Get all of the input and files for the request.
12195 
         *
12196 
         * @param array|mixed|null $keys
12197 
         * @return array
12198 
         * @static
12199 
         */
12200 
        public static function all($keys = null)
12201 
        {
12202 
                        /** @var \Illuminate\Http\Request $instance */
12203 
                        return $instance->all($keys);
12204 
        }
12205 
                    /**
12206 
         * Retrieve an input item from the request.
12207 
         *
12208 
         * @param string|null $key
12209 
         * @param mixed $default
12210 
         * @return mixed
12211 
         * @static
12212 
         */
12213 
        public static function input($key = null, $default = null)
12214 
        {
12215 
                        /** @var \Illuminate\Http\Request $instance */
12216 
                        return $instance->input($key, $default);
12217 
        }
12218 
                    /**
12219 
         * Retrieve input from the request as a Stringable instance.
12220 
         *
12221 
         * @param string $key
12222 
         * @param mixed $default
12223 
         * @return \Illuminate\Support\Stringable
12224 
         * @static
12225 
         */
12226 
        public static function str($key, $default = null)
12227 
        {
12228 
                        /** @var \Illuminate\Http\Request $instance */
12229 
                        return $instance->str($key, $default);
12230 
        }
12231 
                    /**
12232 
         * Retrieve input from the request as a Stringable instance.
12233 
         *
12234 
         * @param string $key
12235 
         * @param mixed $default
12236 
         * @return \Illuminate\Support\Stringable
12237 
         * @static
12238 
         */
12239 
        public static function string($key, $default = null)
12240 
        {
12241 
                        /** @var \Illuminate\Http\Request $instance */
12242 
                        return $instance->string($key, $default);
12243 
        }
12244 
                    /**
12245 
         * Retrieve input as a boolean value.
12246 
         *
12247 
         * Returns true when value is "1", "true", "on", and "yes". Otherwise, returns false.
12248 
         *
12249 
         * @param string|null $key
12250 
         * @param bool $default
12251 
         * @return bool
12252 
         * @static
12253 
         */
12254 
        public static function boolean($key = null, $default = false)
12255 
        {
12256 
                        /** @var \Illuminate\Http\Request $instance */
12257 
                        return $instance->boolean($key, $default);
12258 
        }
12259 
                    /**
12260 
         * Retrieve input as an integer value.
12261 
         *
12262 
         * @param string $key
12263 
         * @param int $default
12264 
         * @return int
12265 
         * @static
12266 
         */
12267 
        public static function integer($key, $default = 0)
12268 
        {
12269 
                        /** @var \Illuminate\Http\Request $instance */
12270 
                        return $instance->integer($key, $default);
12271 
        }
12272 
                    /**
12273 
         * Retrieve input as a float value.
12274 
         *
12275 
         * @param string $key
12276 
         * @param float $default
12277 
         * @return float
12278 
         * @static
12279 
         */
12280 
        public static function float($key, $default = 0.0)
12281 
        {
12282 
                        /** @var \Illuminate\Http\Request $instance */
12283 
                        return $instance->float($key, $default);
12284 
        }
12285 
                    /**
12286 
         * Retrieve input from the request as a Carbon instance.
12287 
         *
12288 
         * @param string $key
12289 
         * @param string|null $format
12290 
         * @param string|null $tz
12291 
         * @return \Illuminate\Support\Carbon|null
12292 
         * @throws \Carbon\Exceptions\InvalidFormatException
12293 
         * @static
12294 
         */
12295 
        public static function date($key, $format = null, $tz = null)
12296 
        {
12297 
                        /** @var \Illuminate\Http\Request $instance */
12298 
                        return $instance->date($key, $format, $tz);
12299 
        }
12300 
                    /**
12301 
         * Retrieve input from the request as an enum.
12302 
         *
12303 
         * @template TEnum
12304 
         * @param string $key
12305 
         * @param \Illuminate\Http\class-string<TEnum> $enumClass
12306 
         * @return \Illuminate\Http\TEnum|null
12307 
         * @static
12308 
         */
12309 
        public static function enum($key, $enumClass)
12310 
        {
12311 
                        /** @var \Illuminate\Http\Request $instance */
12312 
                        return $instance->enum($key, $enumClass);
12313 
        }
12314 
                    /**
12315 
         * Retrieve input from the request as a collection.
12316 
         *
12317 
         * @param array|string|null $key
12318 
         * @return \Illuminate\Support\Collection
12319 
         * @static
12320 
         */
12321 
        public static function collect($key = null)
12322 
        {
12323 
                        /** @var \Illuminate\Http\Request $instance */
12324 
                        return $instance->collect($key);
12325 
        }
12326 
                    /**
12327 
         * Get a subset containing the provided keys with values from the input data.
12328 
         *
12329 
         * @param array|mixed $keys
12330 
         * @return array
12331 
         * @static
12332 
         */
12333 
        public static function only($keys)
12334 
        {
12335 
                        /** @var \Illuminate\Http\Request $instance */
12336 
                        return $instance->only($keys);
12337 
        }
12338 
                    /**
12339 
         * Get all of the input except for a specified array of items.
12340 
         *
12341 
         * @param array|mixed $keys
12342 
         * @return array
12343 
         * @static
12344 
         */
12345 
        public static function except($keys)
12346 
        {
12347 
                        /** @var \Illuminate\Http\Request $instance */
12348 
                        return $instance->except($keys);
12349 
        }
12350 
                    /**
12351 
         * Retrieve a query string item from the request.
12352 
         *
12353 
         * @param string|null $key
12354 
         * @param string|array|null $default
12355 
         * @return string|array|null
12356 
         * @static
12357 
         */
12358 
        public static function query($key = null, $default = null)
12359 
        {
12360 
                        /** @var \Illuminate\Http\Request $instance */
12361 
                        return $instance->query($key, $default);
12362 
        }
12363 
                    /**
12364 
         * Retrieve a request payload item from the request.
12365 
         *
12366 
         * @param string|null $key
12367 
         * @param string|array|null $default
12368 
         * @return string|array|null
12369 
         * @static
12370 
         */
12371 
        public static function post($key = null, $default = null)
12372 
        {
12373 
                        /** @var \Illuminate\Http\Request $instance */
12374 
                        return $instance->post($key, $default);
12375 
        }
12376 
                    /**
12377 
         * Determine if a cookie is set on the request.
12378 
         *
12379 
         * @param string $key
12380 
         * @return bool
12381 
         * @static
12382 
         */
12383 
        public static function hasCookie($key)
12384 
        {
12385 
                        /** @var \Illuminate\Http\Request $instance */
12386 
                        return $instance->hasCookie($key);
12387 
        }
12388 
                    /**
12389 
         * Retrieve a cookie from the request.
12390 
         *
12391 
         * @param string|null $key
12392 
         * @param string|array|null $default
12393 
         * @return string|array|null
12394 
         * @static
12395 
         */
12396 
        public static function cookie($key = null, $default = null)
12397 
        {
12398 
                        /** @var \Illuminate\Http\Request $instance */
12399 
                        return $instance->cookie($key, $default);
12400 
        }
12401 
                    /**
12402 
         * Get an array of all of the files on the request.
12403 
         *
12404 
         * @return array
12405 
         * @static
12406 
         */
12407 
        public static function allFiles()
12408 
        {
12409 
                        /** @var \Illuminate\Http\Request $instance */
12410 
                        return $instance->allFiles();
12411 
        }
12412 
                    /**
12413 
         * Determine if the uploaded data contains a file.
12414 
         *
12415 
         * @param string $key
12416 
         * @return bool
12417 
         * @static
12418 
         */
12419 
        public static function hasFile($key)
12420 
        {
12421 
                        /** @var \Illuminate\Http\Request $instance */
12422 
                        return $instance->hasFile($key);
12423 
        }
12424 
                    /**
12425 
         * Retrieve a file from the request.
12426 
         *
12427 
         * @param string|null $key
12428 
         * @param mixed $default
12429 
         * @return \Illuminate\Http\UploadedFile|\Illuminate\Http\UploadedFile[]|array|null
12430 
         * @static
12431 
         */
12432 
        public static function file($key = null, $default = null)
12433 
        {
12434 
                        /** @var \Illuminate\Http\Request $instance */
12435 
                        return $instance->file($key, $default);
12436 
        }
12437 
                    /**
12438 
         * Dump the request items and end the script.
12439 
         *
12440 
         * @param mixed $keys
12441 
         * @return \Illuminate\Http\never
12442 
         * @static
12443 
         */
12444 
        public static function dd(...$keys)
12445 
        {
12446 
                        /** @var \Illuminate\Http\Request $instance */
12447 
                        return $instance->dd(...$keys);
12448 
        }
12449 
                    /**
12450 
         * Dump the items.
12451 
         *
12452 
         * @param mixed $keys
12453 
         * @return \Illuminate\Http\Request
12454 
         * @static
12455 
         */
12456 
        public static function dump($keys = [])
12457 
        {
12458 
                        /** @var \Illuminate\Http\Request $instance */
12459 
                        return $instance->dump($keys);
12460 
        }
12461 
                    /**
12462 
         * Register a custom macro.
12463 
         *
12464 
         * @param string $name
12465 
         * @param object|callable $macro
12466 
         * @return void
12467 
         * @static
12468 
         */
12469 
        public static function macro($name, $macro)
12470 
        {
12471 
                        \Illuminate\Http\Request::macro($name, $macro);
12472 
        }
12473 
                    /**
12474 
         * Mix another object into the class.
12475 
         *
12476 
         * @param object $mixin
12477 
         * @param bool $replace
12478 
         * @return void
12479 
         * @throws \ReflectionException
12480 
         * @static
12481 
         */
12482 
        public static function mixin($mixin, $replace = true)
12483 
        {
12484 
                        \Illuminate\Http\Request::mixin($mixin, $replace);
12485 
        }
12486 
                    /**
12487 
         * Checks if macro is registered.
12488 
         *
12489 
         * @param string $name
12490 
         * @return bool
12491 
         * @static
12492 
         */
12493 
        public static function hasMacro($name)
12494 
        {
12495 
                        return \Illuminate\Http\Request::hasMacro($name);
12496 
        }
12497 
                    /**
12498 
         * Flush the existing macros.
12499 
         *
12500 
         * @return void
12501 
         * @static
12502 
         */
12503 
        public static function flushMacros()
12504 
        {
12505 
                        \Illuminate\Http\Request::flushMacros();
12506 
        }
12507 
                    /**
12508 
         *
12509 
         *
12510 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
12511 
         * @param array $rules
12512 
         * @param mixed $params
12513 
         * @static
12514 
         */
12515 
        public static function validate($rules, ...$params)
12516 
        {
12517 
                        return \Illuminate\Http\Request::validate($rules, ...$params);
12518 
        }
12519 
                    /**
12520 
         *
12521 
         *
12522 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
12523 
         * @param string $errorBag
12524 
         * @param array $rules
12525 
         * @param mixed $params
12526 
         * @static
12527 
         */
12528 
        public static function validateWithBag($errorBag, $rules, ...$params)
12529 
        {
12530 
                        return \Illuminate\Http\Request::validateWithBag($errorBag, $rules, ...$params);
12531 
        }
12532 
                    /**
12533 
         *
12534 
         *
12535 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
12536 
         * @param mixed $absolute
12537 
         * @static
12538 
         */
12539 
        public static function hasValidSignature($absolute = true)
12540 
        {
12541 
                        return \Illuminate\Http\Request::hasValidSignature($absolute);
12542 
        }
12543 
                    /**
12544 
         *
12545 
         *
12546 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
12547 
         * @static
12548 
         */
12549 
        public static function hasValidRelativeSignature()
12550 
        {
12551 
                        return \Illuminate\Http\Request::hasValidRelativeSignature();
12552 
        }
12553 
                    /**
12554 
         *
12555 
         *
12556 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
12557 
         * @param mixed $ignoreQuery
12558 
         * @param mixed $absolute
12559 
         * @static
12560 
         */
12561 
        public static function hasValidSignatureWhileIgnoring($ignoreQuery = [], $absolute = true)
12562 
        {
12563 
                        return \Illuminate\Http\Request::hasValidSignatureWhileIgnoring($ignoreQuery, $absolute);
12564 
        }
12565 
 
12566 
    }
12567 
            /**
12568 
     *
12569 
     *
12570 
     * @see \Illuminate\Routing\ResponseFactory
12571 
     */
12572 
        class Response {
12573 
                    /**
12574 
         * Create a new response instance.
12575 
         *
12576 
         * @param mixed $content
12577 
         * @param int $status
12578 
         * @param array $headers
12579 
         * @return \Illuminate\Http\Response
12580 
         * @static
12581 
         */
12582 
        public static function make($content = '', $status = 200, $headers = [])
12583 
        {
12584 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12585 
                        return $instance->make($content, $status, $headers);
12586 
        }
12587 
                    /**
12588 
         * Create a new "no content" response.
12589 
         *
12590 
         * @param int $status
12591 
         * @param array $headers
12592 
         * @return \Illuminate\Http\Response
12593 
         * @static
12594 
         */
12595 
        public static function noContent($status = 204, $headers = [])
12596 
        {
12597 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12598 
                        return $instance->noContent($status, $headers);
12599 
        }
12600 
                    /**
12601 
         * Create a new response for a given view.
12602 
         *
12603 
         * @param string|array $view
12604 
         * @param array $data
12605 
         * @param int $status
12606 
         * @param array $headers
12607 
         * @return \Illuminate\Http\Response
12608 
         * @static
12609 
         */
12610 
        public static function view($view, $data = [], $status = 200, $headers = [])
12611 
        {
12612 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12613 
                        return $instance->view($view, $data, $status, $headers);
12614 
        }
12615 
                    /**
12616 
         * Create a new JSON response instance.
12617 
         *
12618 
         * @param mixed $data
12619 
         * @param int $status
12620 
         * @param array $headers
12621 
         * @param int $options
12622 
         * @return \Illuminate\Http\JsonResponse
12623 
         * @static
12624 
         */
12625 
        public static function json($data = [], $status = 200, $headers = [], $options = 0)
12626 
        {
12627 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12628 
                        return $instance->json($data, $status, $headers, $options);
12629 
        }
12630 
                    /**
12631 
         * Create a new JSONP response instance.
12632 
         *
12633 
         * @param string $callback
12634 
         * @param mixed $data
12635 
         * @param int $status
12636 
         * @param array $headers
12637 
         * @param int $options
12638 
         * @return \Illuminate\Http\JsonResponse
12639 
         * @static
12640 
         */
12641 
        public static function jsonp($callback, $data = [], $status = 200, $headers = [], $options = 0)
12642 
        {
12643 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12644 
                        return $instance->jsonp($callback, $data, $status, $headers, $options);
12645 
        }
12646 
                    /**
12647 
         * Create a new streamed response instance.
12648 
         *
12649 
         * @param callable $callback
12650 
         * @param int $status
12651 
         * @param array $headers
12652 
         * @return \Symfony\Component\HttpFoundation\StreamedResponse
12653 
         * @static
12654 
         */
12655 
        public static function stream($callback, $status = 200, $headers = [])
12656 
        {
12657 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12658 
                        return $instance->stream($callback, $status, $headers);
12659 
        }
12660 
                    /**
12661 
         * Create a new streamed response instance as a file download.
12662 
         *
12663 
         * @param callable $callback
12664 
         * @param string|null $name
12665 
         * @param array $headers
12666 
         * @param string|null $disposition
12667 
         * @return \Symfony\Component\HttpFoundation\StreamedResponse
12668 
         * @static
12669 
         */
12670 
        public static function streamDownload($callback, $name = null, $headers = [], $disposition = 'attachment')
12671 
        {
12672 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12673 
                        return $instance->streamDownload($callback, $name, $headers, $disposition);
12674 
        }
12675 
                    /**
12676 
         * Create a new file download response.
12677 
         *
12678 
         * @param \SplFileInfo|string $file
12679 
         * @param string|null $name
12680 
         * @param array $headers
12681 
         * @param string|null $disposition
12682 
         * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
12683 
         * @static
12684 
         */
12685 
        public static function download($file, $name = null, $headers = [], $disposition = 'attachment')
12686 
        {
12687 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12688 
                        return $instance->download($file, $name, $headers, $disposition);
12689 
        }
12690 
                    /**
12691 
         * Return the raw contents of a binary file.
12692 
         *
12693 
         * @param \SplFileInfo|string $file
12694 
         * @param array $headers
12695 
         * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
12696 
         * @static
12697 
         */
12698 
        public static function file($file, $headers = [])
12699 
        {
12700 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12701 
                        return $instance->file($file, $headers);
12702 
        }
12703 
                    /**
12704 
         * Create a new redirect response to the given path.
12705 
         *
12706 
         * @param string $path
12707 
         * @param int $status
12708 
         * @param array $headers
12709 
         * @param bool|null $secure
12710 
         * @return \Illuminate\Http\RedirectResponse
12711 
         * @static
12712 
         */
12713 
        public static function redirectTo($path, $status = 302, $headers = [], $secure = null)
12714 
        {
12715 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12716 
                        return $instance->redirectTo($path, $status, $headers, $secure);
12717 
        }
12718 
                    /**
12719 
         * Create a new redirect response to a named route.
12720 
         *
12721 
         * @param string $route
12722 
         * @param mixed $parameters
12723 
         * @param int $status
12724 
         * @param array $headers
12725 
         * @return \Illuminate\Http\RedirectResponse
12726 
         * @static
12727 
         */
12728 
        public static function redirectToRoute($route, $parameters = [], $status = 302, $headers = [])
12729 
        {
12730 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12731 
                        return $instance->redirectToRoute($route, $parameters, $status, $headers);
12732 
        }
12733 
                    /**
12734 
         * Create a new redirect response to a controller action.
12735 
         *
12736 
         * @param string $action
12737 
         * @param mixed $parameters
12738 
         * @param int $status
12739 
         * @param array $headers
12740 
         * @return \Illuminate\Http\RedirectResponse
12741 
         * @static
12742 
         */
12743 
        public static function redirectToAction($action, $parameters = [], $status = 302, $headers = [])
12744 
        {
12745 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12746 
                        return $instance->redirectToAction($action, $parameters, $status, $headers);
12747 
        }
12748 
                    /**
12749 
         * Create a new redirect response, while putting the current URL in the session.
12750 
         *
12751 
         * @param string $path
12752 
         * @param int $status
12753 
         * @param array $headers
12754 
         * @param bool|null $secure
12755 
         * @return \Illuminate\Http\RedirectResponse
12756 
         * @static
12757 
         */
12758 
        public static function redirectGuest($path, $status = 302, $headers = [], $secure = null)
12759 
        {
12760 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12761 
                        return $instance->redirectGuest($path, $status, $headers, $secure);
12762 
        }
12763 
                    /**
12764 
         * Create a new redirect response to the previously intended location.
12765 
         *
12766 
         * @param string $default
12767 
         * @param int $status
12768 
         * @param array $headers
12769 
         * @param bool|null $secure
12770 
         * @return \Illuminate\Http\RedirectResponse
12771 
         * @static
12772 
         */
12773 
        public static function redirectToIntended($default = '/', $status = 302, $headers = [], $secure = null)
12774 
        {
12775 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12776 
                        return $instance->redirectToIntended($default, $status, $headers, $secure);
12777 
        }
12778 
                    /**
12779 
         * Register a custom macro.
12780 
         *
12781 
         * @param string $name
12782 
         * @param object|callable $macro
12783 
         * @return void
12784 
         * @static
12785 
         */
12786 
        public static function macro($name, $macro)
12787 
        {
12788 
                        \Illuminate\Routing\ResponseFactory::macro($name, $macro);
12789 
        }
12790 
                    /**
12791 
         * Mix another object into the class.
12792 
         *
12793 
         * @param object $mixin
12794 
         * @param bool $replace
12795 
         * @return void
12796 
         * @throws \ReflectionException
12797 
         * @static
12798 
         */
12799 
        public static function mixin($mixin, $replace = true)
12800 
        {
12801 
                        \Illuminate\Routing\ResponseFactory::mixin($mixin, $replace);
12802 
        }
12803 
                    /**
12804 
         * Checks if macro is registered.
12805 
         *
12806 
         * @param string $name
12807 
         * @return bool
12808 
         * @static
12809 
         */
12810 
        public static function hasMacro($name)
12811 
        {
12812 
                        return \Illuminate\Routing\ResponseFactory::hasMacro($name);
12813 
        }
12814 
                    /**
12815 
         * Flush the existing macros.
12816 
         *
12817 
         * @return void
12818 
         * @static
12819 
         */
12820 
        public static function flushMacros()
12821 
        {
12822 
                        \Illuminate\Routing\ResponseFactory::flushMacros();
12823 
        }
12824 
 
12825 
    }
12826 
            /**
12827 
     *
12828 
     *
12829 
     * @method static \Illuminate\Routing\RouteRegistrar attribute(string $key, mixed $value)
12830 
     * @method static \Illuminate\Routing\RouteRegistrar whereAlpha(array|string $parameters)
12831 
     * @method static \Illuminate\Routing\RouteRegistrar whereAlphaNumeric(array|string $parameters)
12832 
     * @method static \Illuminate\Routing\RouteRegistrar whereNumber(array|string $parameters)
12833 
     * @method static \Illuminate\Routing\RouteRegistrar whereUlid(array|string $parameters)
12834 
     * @method static \Illuminate\Routing\RouteRegistrar whereUuid(array|string $parameters)
12835 
     * @method static \Illuminate\Routing\RouteRegistrar whereIn(array|string $parameters, array $values)
12836 
     * @method static \Illuminate\Routing\RouteRegistrar as(string $value)
12837 
     * @method static \Illuminate\Routing\RouteRegistrar controller(string $controller)
12838 
     * @method static \Illuminate\Routing\RouteRegistrar domain(string $value)
12839 
     * @method static \Illuminate\Routing\RouteRegistrar middleware(array|string|null $middleware)
12840 
     * @method static \Illuminate\Routing\RouteRegistrar name(string $value)
12841 
     * @method static \Illuminate\Routing\RouteRegistrar namespace(string|null $value)
12842 
     * @method static \Illuminate\Routing\RouteRegistrar prefix(string $prefix)
12843 
     * @method static \Illuminate\Routing\RouteRegistrar scopeBindings()
12844 
     * @method static \Illuminate\Routing\RouteRegistrar where(array $where)
12845 
     * @method static \Illuminate\Routing\RouteRegistrar withoutMiddleware(array|string $middleware)
12846 
     * @method static \Illuminate\Routing\RouteRegistrar withoutScopedBindings()
12847 
     * @see \Illuminate\Routing\Router
12848 
     */
12849 
        class Route {
12850 
                    /**
12851 
         * Register a new GET route with the router.
12852 
         *
12853 
         * @param string $uri
12854 
         * @param array|string|callable|null $action
12855 
         * @return \Illuminate\Routing\Route
12856 
         * @static
12857 
         */
12858 
        public static function get($uri, $action = null)
12859 
        {
12860 
                        /** @var \Illuminate\Routing\Router $instance */
12861 
                        return $instance->get($uri, $action);
12862 
        }
12863 
                    /**
12864 
         * Register a new POST route with the router.
12865 
         *
12866 
         * @param string $uri
12867 
         * @param array|string|callable|null $action
12868 
         * @return \Illuminate\Routing\Route
12869 
         * @static
12870 
         */
12871 
        public static function post($uri, $action = null)
12872 
        {
12873 
                        /** @var \Illuminate\Routing\Router $instance */
12874 
                        return $instance->post($uri, $action);
12875 
        }
12876 
                    /**
12877 
         * Register a new PUT route with the router.
12878 
         *
12879 
         * @param string $uri
12880 
         * @param array|string|callable|null $action
12881 
         * @return \Illuminate\Routing\Route
12882 
         * @static
12883 
         */
12884 
        public static function put($uri, $action = null)
12885 
        {
12886 
                        /** @var \Illuminate\Routing\Router $instance */
12887 
                        return $instance->put($uri, $action);
12888 
        }
12889 
                    /**
12890 
         * Register a new PATCH route with the router.
12891 
         *
12892 
         * @param string $uri
12893 
         * @param array|string|callable|null $action
12894 
         * @return \Illuminate\Routing\Route
12895 
         * @static
12896 
         */
12897 
        public static function patch($uri, $action = null)
12898 
        {
12899 
                        /** @var \Illuminate\Routing\Router $instance */
12900 
                        return $instance->patch($uri, $action);
12901 
        }
12902 
                    /**
12903 
         * Register a new DELETE route with the router.
12904 
         *
12905 
         * @param string $uri
12906 
         * @param array|string|callable|null $action
12907 
         * @return \Illuminate\Routing\Route
12908 
         * @static
12909 
         */
12910 
        public static function delete($uri, $action = null)
12911 
        {
12912 
                        /** @var \Illuminate\Routing\Router $instance */
12913 
                        return $instance->delete($uri, $action);
12914 
        }
12915 
                    /**
12916 
         * Register a new OPTIONS route with the router.
12917 
         *
12918 
         * @param string $uri
12919 
         * @param array|string|callable|null $action
12920 
         * @return \Illuminate\Routing\Route
12921 
         * @static
12922 
         */
12923 
        public static function options($uri, $action = null)
12924 
        {
12925 
                        /** @var \Illuminate\Routing\Router $instance */
12926 
                        return $instance->options($uri, $action);
12927 
        }
12928 
                    /**
12929 
         * Register a new route responding to all verbs.
12930 
         *
12931 
         * @param string $uri
12932 
         * @param array|string|callable|null $action
12933 
         * @return \Illuminate\Routing\Route
12934 
         * @static
12935 
         */
12936 
        public static function any($uri, $action = null)
12937 
        {
12938 
                        /** @var \Illuminate\Routing\Router $instance */
12939 
                        return $instance->any($uri, $action);
12940 
        }
12941 
                    /**
12942 
         * Register a new Fallback route with the router.
12943 
         *
12944 
         * @param array|string|callable|null $action
12945 
         * @return \Illuminate\Routing\Route
12946 
         * @static
12947 
         */
12948 
        public static function fallback($action)
12949 
        {
12950 
                        /** @var \Illuminate\Routing\Router $instance */
12951 
                        return $instance->fallback($action);
12952 
        }
12953 
                    /**
12954 
         * Create a redirect from one URI to another.
12955 
         *
12956 
         * @param string $uri
12957 
         * @param string $destination
12958 
         * @param int $status
12959 
         * @return \Illuminate\Routing\Route
12960 
         * @static
12961 
         */
12962 
        public static function redirect($uri, $destination, $status = 302)
12963 
        {
12964 
                        /** @var \Illuminate\Routing\Router $instance */
12965 
                        return $instance->redirect($uri, $destination, $status);
12966 
        }
12967 
                    /**
12968 
         * Create a permanent redirect from one URI to another.
12969 
         *
12970 
         * @param string $uri
12971 
         * @param string $destination
12972 
         * @return \Illuminate\Routing\Route
12973 
         * @static
12974 
         */
12975 
        public static function permanentRedirect($uri, $destination)
12976 
        {
12977 
                        /** @var \Illuminate\Routing\Router $instance */
12978 
                        return $instance->permanentRedirect($uri, $destination);
12979 
        }
12980 
                    /**
12981 
         * Register a new route that returns a view.
12982 
         *
12983 
         * @param string $uri
12984 
         * @param string $view
12985 
         * @param array $data
12986 
         * @param int|array $status
12987 
         * @param array $headers
12988 
         * @return \Illuminate\Routing\Route
12989 
         * @static
12990 
         */
12991 
        public static function view($uri, $view, $data = [], $status = 200, $headers = [])
12992 
        {
12993 
                        /** @var \Illuminate\Routing\Router $instance */
12994 
                        return $instance->view($uri, $view, $data, $status, $headers);
12995 
        }
12996 
                    /**
12997 
         * Register a new route with the given verbs.
12998 
         *
12999 
         * @param array|string $methods
13000 
         * @param string $uri
13001 
         * @param array|string|callable|null $action
13002 
         * @return \Illuminate\Routing\Route
13003 
         * @static
13004 
         */
13005 
        public static function match($methods, $uri, $action = null)
13006 
        {
13007 
                        /** @var \Illuminate\Routing\Router $instance */
13008 
                        return $instance->match($methods, $uri, $action);
13009 
        }
13010 
                    /**
13011 
         * Register an array of resource controllers.
13012 
         *
13013 
         * @param array $resources
13014 
         * @param array $options
13015 
         * @return void
13016 
         * @static
13017 
         */
13018 
        public static function resources($resources, $options = [])
13019 
        {
13020 
                        /** @var \Illuminate\Routing\Router $instance */
13021 
                        $instance->resources($resources, $options);
13022 
        }
13023 
                    /**
13024 
         * Route a resource to a controller.
13025 
         *
13026 
         * @param string $name
13027 
         * @param string $controller
13028 
         * @param array $options
13029 
         * @return \Illuminate\Routing\PendingResourceRegistration
13030 
         * @static
13031 
         */
13032 
        public static function resource($name, $controller, $options = [])
13033 
        {
13034 
                        /** @var \Illuminate\Routing\Router $instance */
13035 
                        return $instance->resource($name, $controller, $options);
13036 
        }
13037 
                    /**
13038 
         * Register an array of API resource controllers.
13039 
         *
13040 
         * @param array $resources
13041 
         * @param array $options
13042 
         * @return void
13043 
         * @static
13044 
         */
13045 
        public static function apiResources($resources, $options = [])
13046 
        {
13047 
                        /** @var \Illuminate\Routing\Router $instance */
13048 
                        $instance->apiResources($resources, $options);
13049 
        }
13050 
                    /**
13051 
         * Route an API resource to a controller.
13052 
         *
13053 
         * @param string $name
13054 
         * @param string $controller
13055 
         * @param array $options
13056 
         * @return \Illuminate\Routing\PendingResourceRegistration
13057 
         * @static
13058 
         */
13059 
        public static function apiResource($name, $controller, $options = [])
13060 
        {
13061 
                        /** @var \Illuminate\Routing\Router $instance */
13062 
                        return $instance->apiResource($name, $controller, $options);
13063 
        }
13064 
                    /**
13065 
         * Register an array of singleton resource controllers.
13066 
         *
13067 
         * @param array $singletons
13068 
         * @param array $options
13069 
         * @return void
13070 
         * @static
13071 
         */
13072 
        public static function singletons($singletons, $options = [])
13073 
        {
13074 
                        /** @var \Illuminate\Routing\Router $instance */
13075 
                        $instance->singletons($singletons, $options);
13076 
        }
13077 
                    /**
13078 
         * Route a singleton resource to a controller.
13079 
         *
13080 
         * @param string $name
13081 
         * @param string $controller
13082 
         * @param array $options
13083 
         * @return \Illuminate\Routing\PendingSingletonResourceRegistration
13084 
         * @static
13085 
         */
13086 
        public static function singleton($name, $controller, $options = [])
13087 
        {
13088 
                        /** @var \Illuminate\Routing\Router $instance */
13089 
                        return $instance->singleton($name, $controller, $options);
13090 
        }
13091 
                    /**
13092 
         * Register an array of API singleton resource controllers.
13093 
         *
13094 
         * @param array $singletons
13095 
         * @param array $options
13096 
         * @return void
13097 
         * @static
13098 
         */
13099 
        public static function apiSingletons($singletons, $options = [])
13100 
        {
13101 
                        /** @var \Illuminate\Routing\Router $instance */
13102 
                        $instance->apiSingletons($singletons, $options);
13103 
        }
13104 
                    /**
13105 
         * Route an API singleton resource to a controller.
13106 
         *
13107 
         * @param string $name
13108 
         * @param string $controller
13109 
         * @param array $options
13110 
         * @return \Illuminate\Routing\PendingSingletonResourceRegistration
13111 
         * @static
13112 
         */
13113 
        public static function apiSingleton($name, $controller, $options = [])
13114 
        {
13115 
                        /** @var \Illuminate\Routing\Router $instance */
13116 
                        return $instance->apiSingleton($name, $controller, $options);
13117 
        }
13118 
                    /**
13119 
         * Create a route group with shared attributes.
13120 
         *
13121 
         * @param array $attributes
13122 
         * @param \Closure|array|string $routes
13123 
         * @return \Illuminate\Routing\Router
13124 
         * @static
13125 
         */
13126 
        public static function group($attributes, $routes)
13127 
        {
13128 
                        /** @var \Illuminate\Routing\Router $instance */
13129 
                        return $instance->group($attributes, $routes);
13130 
        }
13131 
                    /**
13132 
         * Merge the given array with the last group stack.
13133 
         *
13134 
         * @param array $new
13135 
         * @param bool $prependExistingPrefix
13136 
         * @return array
13137 
         * @static
13138 
         */
13139 
        public static function mergeWithLastGroup($new, $prependExistingPrefix = true)
13140 
        {
13141 
                        /** @var \Illuminate\Routing\Router $instance */
13142 
                        return $instance->mergeWithLastGroup($new, $prependExistingPrefix);
13143 
        }
13144 
                    /**
13145 
         * Get the prefix from the last group on the stack.
13146 
         *
13147 
         * @return string
13148 
         * @static
13149 
         */
13150 
        public static function getLastGroupPrefix()
13151 
        {
13152 
                        /** @var \Illuminate\Routing\Router $instance */
13153 
                        return $instance->getLastGroupPrefix();
13154 
        }
13155 
                    /**
13156 
         * Add a route to the underlying route collection.
13157 
         *
13158 
         * @param array|string $methods
13159 
         * @param string $uri
13160 
         * @param array|string|callable|null $action
13161 
         * @return \Illuminate\Routing\Route
13162 
         * @static
13163 
         */
13164 
        public static function addRoute($methods, $uri, $action)
13165 
        {
13166 
                        /** @var \Illuminate\Routing\Router $instance */
13167 
                        return $instance->addRoute($methods, $uri, $action);
13168 
        }
13169 
                    /**
13170 
         * Create a new Route object.
13171 
         *
13172 
         * @param array|string $methods
13173 
         * @param string $uri
13174 
         * @param mixed $action
13175 
         * @return \Illuminate\Routing\Route
13176 
         * @static
13177 
         */
13178 
        public static function newRoute($methods, $uri, $action)
13179 
        {
13180 
                        /** @var \Illuminate\Routing\Router $instance */
13181 
                        return $instance->newRoute($methods, $uri, $action);
13182 
        }
13183 
                    /**
13184 
         * Return the response returned by the given route.
13185 
         *
13186 
         * @param string $name
13187 
         * @return \Symfony\Component\HttpFoundation\Response
13188 
         * @static
13189 
         */
13190 
        public static function respondWithRoute($name)
13191 
        {
13192 
                        /** @var \Illuminate\Routing\Router $instance */
13193 
                        return $instance->respondWithRoute($name);
13194 
        }
13195 
                    /**
13196 
         * Dispatch the request to the application.
13197 
         *
13198 
         * @param \Illuminate\Http\Request $request
13199 
         * @return \Symfony\Component\HttpFoundation\Response
13200 
         * @static
13201 
         */
13202 
        public static function dispatch($request)
13203 
        {
13204 
                        /** @var \Illuminate\Routing\Router $instance */
13205 
                        return $instance->dispatch($request);
13206 
        }
13207 
                    /**
13208 
         * Dispatch the request to a route and return the response.
13209 
         *
13210 
         * @param \Illuminate\Http\Request $request
13211 
         * @return \Symfony\Component\HttpFoundation\Response
13212 
         * @static
13213 
         */
13214 
        public static function dispatchToRoute($request)
13215 
        {
13216 
                        /** @var \Illuminate\Routing\Router $instance */
13217 
                        return $instance->dispatchToRoute($request);
13218 
        }
13219 
                    /**
13220 
         * Gather the middleware for the given route with resolved class names.
13221 
         *
13222 
         * @param \Illuminate\Routing\Route $route
13223 
         * @return array
13224 
         * @static
13225 
         */
13226 
        public static function gatherRouteMiddleware($route)
13227 
        {
13228 
                        /** @var \Illuminate\Routing\Router $instance */
13229 
                        return $instance->gatherRouteMiddleware($route);
13230 
        }
13231 
                    /**
13232 
         * Resolve a flat array of middleware classes from the provided array.
13233 
         *
13234 
         * @param array $middleware
13235 
         * @param array $excluded
13236 
         * @return array
13237 
         * @static
13238 
         */
13239 
        public static function resolveMiddleware($middleware, $excluded = [])
13240 
        {
13241 
                        /** @var \Illuminate\Routing\Router $instance */
13242 
                        return $instance->resolveMiddleware($middleware, $excluded);
13243 
        }
13244 
                    /**
13245 
         * Create a response instance from the given value.
13246 
         *
13247 
         * @param \Symfony\Component\HttpFoundation\Request $request
13248 
         * @param mixed $response
13249 
         * @return \Symfony\Component\HttpFoundation\Response
13250 
         * @static
13251 
         */
13252 
        public static function prepareResponse($request, $response)
13253 
        {
13254 
                        /** @var \Illuminate\Routing\Router $instance */
13255 
                        return $instance->prepareResponse($request, $response);
13256 
        }
13257 
                    /**
13258 
         * Static version of prepareResponse.
13259 
         *
13260 
         * @param \Symfony\Component\HttpFoundation\Request $request
13261 
         * @param mixed $response
13262 
         * @return \Symfony\Component\HttpFoundation\Response
13263 
         * @static
13264 
         */
13265 
        public static function toResponse($request, $response)
13266 
        {
13267 
                        return \Illuminate\Routing\Router::toResponse($request, $response);
13268 
        }
13269 
                    /**
13270 
         * Substitute the route bindings onto the route.
13271 
         *
13272 
         * @param \Illuminate\Routing\Route $route
13273 
         * @return \Illuminate\Routing\Route
13274 
         * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
13275 
         * @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException
13276 
         * @static
13277 
         */
13278 
        public static function substituteBindings($route)
13279 
        {
13280 
                        /** @var \Illuminate\Routing\Router $instance */
13281 
                        return $instance->substituteBindings($route);
13282 
        }
13283 
                    /**
13284 
         * Substitute the implicit route bindings for the given route.
13285 
         *
13286 
         * @param \Illuminate\Routing\Route $route
13287 
         * @return void
13288 
         * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
13289 
         * @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException
13290 
         * @static
13291 
         */
13292 
        public static function substituteImplicitBindings($route)
13293 
        {
13294 
                        /** @var \Illuminate\Routing\Router $instance */
13295 
                        $instance->substituteImplicitBindings($route);
13296 
        }
13297 
                    /**
13298 
         * Register a route matched event listener.
13299 
         *
13300 
         * @param string|callable $callback
13301 
         * @return void
13302 
         * @static
13303 
         */
13304 
        public static function matched($callback)
13305 
        {
13306 
                        /** @var \Illuminate\Routing\Router $instance */
13307 
                        $instance->matched($callback);
13308 
        }
13309 
                    /**
13310 
         * Get all of the defined middleware short-hand names.
13311 
         *
13312 
         * @return array
13313 
         * @static
13314 
         */
13315 
        public static function getMiddleware()
13316 
        {
13317 
                        /** @var \Illuminate\Routing\Router $instance */
13318 
                        return $instance->getMiddleware();
13319 
        }
13320 
                    /**
13321 
         * Register a short-hand name for a middleware.
13322 
         *
13323 
         * @param string $name
13324 
         * @param string $class
13325 
         * @return \Illuminate\Routing\Router
13326 
         * @static
13327 
         */
13328 
        public static function aliasMiddleware($name, $class)
13329 
        {
13330 
                        /** @var \Illuminate\Routing\Router $instance */
13331 
                        return $instance->aliasMiddleware($name, $class);
13332 
        }
13333 
                    /**
13334 
         * Check if a middlewareGroup with the given name exists.
13335 
         *
13336 
         * @param string $name
13337 
         * @return bool
13338 
         * @static
13339 
         */
13340 
        public static function hasMiddlewareGroup($name)
13341 
        {
13342 
                        /** @var \Illuminate\Routing\Router $instance */
13343 
                        return $instance->hasMiddlewareGroup($name);
13344 
        }
13345 
                    /**
13346 
         * Get all of the defined middleware groups.
13347 
         *
13348 
         * @return array
13349 
         * @static
13350 
         */
13351 
        public static function getMiddlewareGroups()
13352 
        {
13353 
                        /** @var \Illuminate\Routing\Router $instance */
13354 
                        return $instance->getMiddlewareGroups();
13355 
        }
13356 
                    /**
13357 
         * Register a group of middleware.
13358 
         *
13359 
         * @param string $name
13360 
         * @param array $middleware
13361 
         * @return \Illuminate\Routing\Router
13362 
         * @static
13363 
         */
13364 
        public static function middlewareGroup($name, $middleware)
13365 
        {
13366 
                        /** @var \Illuminate\Routing\Router $instance */
13367 
                        return $instance->middlewareGroup($name, $middleware);
13368 
        }
13369 
                    /**
13370 
         * Add a middleware to the beginning of a middleware group.
13371 
         *
13372 
         * If the middleware is already in the group, it will not be added again.
13373 
         *
13374 
         * @param string $group
13375 
         * @param string $middleware
13376 
         * @return \Illuminate\Routing\Router
13377 
         * @static
13378 
         */
13379 
        public static function prependMiddlewareToGroup($group, $middleware)
13380 
        {
13381 
                        /** @var \Illuminate\Routing\Router $instance */
13382 
                        return $instance->prependMiddlewareToGroup($group, $middleware);
13383 
        }
13384 
                    /**
13385 
         * Add a middleware to the end of a middleware group.
13386 
         *
13387 
         * If the middleware is already in the group, it will not be added again.
13388 
         *
13389 
         * @param string $group
13390 
         * @param string $middleware
13391 
         * @return \Illuminate\Routing\Router
13392 
         * @static
13393 
         */
13394 
        public static function pushMiddlewareToGroup($group, $middleware)
13395 
        {
13396 
                        /** @var \Illuminate\Routing\Router $instance */
13397 
                        return $instance->pushMiddlewareToGroup($group, $middleware);
13398 
        }
13399 
                    /**
13400 
         * Remove the given middleware from the specified group.
13401 
         *
13402 
         * @param string $group
13403 
         * @param string $middleware
13404 
         * @return \Illuminate\Routing\Router
13405 
         * @static
13406 
         */
13407 
        public static function removeMiddlewareFromGroup($group, $middleware)
13408 
        {
13409 
                        /** @var \Illuminate\Routing\Router $instance */
13410 
                        return $instance->removeMiddlewareFromGroup($group, $middleware);
13411 
        }
13412 
                    /**
13413 
         * Flush the router's middleware groups.
13414 
         *
13415 
         * @return \Illuminate\Routing\Router
13416 
         * @static
13417 
         */
13418 
        public static function flushMiddlewareGroups()
13419 
        {
13420 
                        /** @var \Illuminate\Routing\Router $instance */
13421 
                        return $instance->flushMiddlewareGroups();
13422 
        }
13423 
                    /**
13424 
         * Add a new route parameter binder.
13425 
         *
13426 
         * @param string $key
13427 
         * @param string|callable $binder
13428 
         * @return void
13429 
         * @static
13430 
         */
13431 
        public static function bind($key, $binder)
13432 
        {
13433 
                        /** @var \Illuminate\Routing\Router $instance */
13434 
                        $instance->bind($key, $binder);
13435 
        }
13436 
                    /**
13437 
         * Register a model binder for a wildcard.
13438 
         *
13439 
         * @param string $key
13440 
         * @param string $class
13441 
         * @param \Closure|null $callback
13442 
         * @return void
13443 
         * @static
13444 
         */
13445 
        public static function model($key, $class, $callback = null)
13446 
        {
13447 
                        /** @var \Illuminate\Routing\Router $instance */
13448 
                        $instance->model($key, $class, $callback);
13449 
        }
13450 
                    /**
13451 
         * Get the binding callback for a given binding.
13452 
         *
13453 
         * @param string $key
13454 
         * @return \Closure|null
13455 
         * @static
13456 
         */
13457 
        public static function getBindingCallback($key)
13458 
        {
13459 
                        /** @var \Illuminate\Routing\Router $instance */
13460 
                        return $instance->getBindingCallback($key);
13461 
        }
13462 
                    /**
13463 
         * Get the global "where" patterns.
13464 
         *
13465 
         * @return array
13466 
         * @static
13467 
         */
13468 
        public static function getPatterns()
13469 
        {
13470 
                        /** @var \Illuminate\Routing\Router $instance */
13471 
                        return $instance->getPatterns();
13472 
        }
13473 
                    /**
13474 
         * Set a global where pattern on all routes.
13475 
         *
13476 
         * @param string $key
13477 
         * @param string $pattern
13478 
         * @return void
13479 
         * @static
13480 
         */
13481 
        public static function pattern($key, $pattern)
13482 
        {
13483 
                        /** @var \Illuminate\Routing\Router $instance */
13484 
                        $instance->pattern($key, $pattern);
13485 
        }
13486 
                    /**
13487 
         * Set a group of global where patterns on all routes.
13488 
         *
13489 
         * @param array $patterns
13490 
         * @return void
13491 
         * @static
13492 
         */
13493 
        public static function patterns($patterns)
13494 
        {
13495 
                        /** @var \Illuminate\Routing\Router $instance */
13496 
                        $instance->patterns($patterns);
13497 
        }
13498 
                    /**
13499 
         * Determine if the router currently has a group stack.
13500 
         *
13501 
         * @return bool
13502 
         * @static
13503 
         */
13504 
        public static function hasGroupStack()
13505 
        {
13506 
                        /** @var \Illuminate\Routing\Router $instance */
13507 
                        return $instance->hasGroupStack();
13508 
        }
13509 
                    /**
13510 
         * Get the current group stack for the router.
13511 
         *
13512 
         * @return array
13513 
         * @static
13514 
         */
13515 
        public static function getGroupStack()
13516 
        {
13517 
                        /** @var \Illuminate\Routing\Router $instance */
13518 
                        return $instance->getGroupStack();
13519 
        }
13520 
                    /**
13521 
         * Get a route parameter for the current route.
13522 
         *
13523 
         * @param string $key
13524 
         * @param string|null $default
13525 
         * @return mixed
13526 
         * @static
13527 
         */
13528 
        public static function input($key, $default = null)
13529 
        {
13530 
                        /** @var \Illuminate\Routing\Router $instance */
13531 
                        return $instance->input($key, $default);
13532 
        }
13533 
                    /**
13534 
         * Get the request currently being dispatched.
13535 
         *
13536 
         * @return \Illuminate\Http\Request
13537 
         * @static
13538 
         */
13539 
        public static function getCurrentRequest()
13540 
        {
13541 
                        /** @var \Illuminate\Routing\Router $instance */
13542 
                        return $instance->getCurrentRequest();
13543 
        }
13544 
                    /**
13545 
         * Get the currently dispatched route instance.
13546 
         *
13547 
         * @return \Illuminate\Routing\Route|null
13548 
         * @static
13549 
         */
13550 
        public static function getCurrentRoute()
13551 
        {
13552 
                        /** @var \Illuminate\Routing\Router $instance */
13553 
                        return $instance->getCurrentRoute();
13554 
        }
13555 
                    /**
13556 
         * Get the currently dispatched route instance.
13557 
         *
13558 
         * @return \Illuminate\Routing\Route|null
13559 
         * @static
13560 
         */
13561 
        public static function current()
13562 
        {
13563 
                        /** @var \Illuminate\Routing\Router $instance */
13564 
                        return $instance->current();
13565 
        }
13566 
                    /**
13567 
         * Check if a route with the given name exists.
13568 
         *
13569 
         * @param string|array $name
13570 
         * @return bool
13571 
         * @static
13572 
         */
13573 
        public static function has($name)
13574 
        {
13575 
                        /** @var \Illuminate\Routing\Router $instance */
13576 
                        return $instance->has($name);
13577 
        }
13578 
                    /**
13579 
         * Get the current route name.
13580 
         *
13581 
         * @return string|null
13582 
         * @static
13583 
         */
13584 
        public static function currentRouteName()
13585 
        {
13586 
                        /** @var \Illuminate\Routing\Router $instance */
13587 
                        return $instance->currentRouteName();
13588 
        }
13589 
                    /**
13590 
         * Alias for the "currentRouteNamed" method.
13591 
         *
13592 
         * @param mixed $patterns
13593 
         * @return bool
13594 
         * @static
13595 
         */
13596 
        public static function is(...$patterns)
13597 
        {
13598 
                        /** @var \Illuminate\Routing\Router $instance */
13599 
                        return $instance->is(...$patterns);
13600 
        }
13601 
                    /**
13602 
         * Determine if the current route matches a pattern.
13603 
         *
13604 
         * @param mixed $patterns
13605 
         * @return bool
13606 
         * @static
13607 
         */
13608 
        public static function currentRouteNamed(...$patterns)
13609 
        {
13610 
                        /** @var \Illuminate\Routing\Router $instance */
13611 
                        return $instance->currentRouteNamed(...$patterns);
13612 
        }
13613 
                    /**
13614 
         * Get the current route action.
13615 
         *
13616 
         * @return string|null
13617 
         * @static
13618 
         */
13619 
        public static function currentRouteAction()
13620 
        {
13621 
                        /** @var \Illuminate\Routing\Router $instance */
13622 
                        return $instance->currentRouteAction();
13623 
        }
13624 
                    /**
13625 
         * Alias for the "currentRouteUses" method.
13626 
         *
13627 
         * @param array $patterns
13628 
         * @return bool
13629 
         * @static
13630 
         */
13631 
        public static function uses(...$patterns)
13632 
        {
13633 
                        /** @var \Illuminate\Routing\Router $instance */
13634 
                        return $instance->uses(...$patterns);
13635 
        }
13636 
                    /**
13637 
         * Determine if the current route action matches a given action.
13638 
         *
13639 
         * @param string $action
13640 
         * @return bool
13641 
         * @static
13642 
         */
13643 
        public static function currentRouteUses($action)
13644 
        {
13645 
                        /** @var \Illuminate\Routing\Router $instance */
13646 
                        return $instance->currentRouteUses($action);
13647 
        }
13648 
                    /**
13649 
         * Set the unmapped global resource parameters to singular.
13650 
         *
13651 
         * @param bool $singular
13652 
         * @return void
13653 
         * @static
13654 
         */
13655 
        public static function singularResourceParameters($singular = true)
13656 
        {
13657 
                        /** @var \Illuminate\Routing\Router $instance */
13658 
                        $instance->singularResourceParameters($singular);
13659 
        }
13660 
                    /**
13661 
         * Set the global resource parameter mapping.
13662 
         *
13663 
         * @param array $parameters
13664 
         * @return void
13665 
         * @static
13666 
         */
13667 
        public static function resourceParameters($parameters = [])
13668 
        {
13669 
                        /** @var \Illuminate\Routing\Router $instance */
13670 
                        $instance->resourceParameters($parameters);
13671 
        }
13672 
                    /**
13673 
         * Get or set the verbs used in the resource URIs.
13674 
         *
13675 
         * @param array $verbs
13676 
         * @return array|null
13677 
         * @static
13678 
         */
13679 
        public static function resourceVerbs($verbs = [])
13680 
        {
13681 
                        /** @var \Illuminate\Routing\Router $instance */
13682 
                        return $instance->resourceVerbs($verbs);
13683 
        }
13684 
                    /**
13685 
         * Get the underlying route collection.
13686 
         *
13687 
         * @return \Illuminate\Routing\RouteCollectionInterface
13688 
         * @static
13689 
         */
13690 
        public static function getRoutes()
13691 
        {
13692 
                        /** @var \Illuminate\Routing\Router $instance */
13693 
                        return $instance->getRoutes();
13694 
        }
13695 
                    /**
13696 
         * Set the route collection instance.
13697 
         *
13698 
         * @param \Illuminate\Routing\RouteCollection $routes
13699 
         * @return void
13700 
         * @static
13701 
         */
13702 
        public static function setRoutes($routes)
13703 
        {
13704 
                        /** @var \Illuminate\Routing\Router $instance */
13705 
                        $instance->setRoutes($routes);
13706 
        }
13707 
                    /**
13708 
         * Set the compiled route collection instance.
13709 
         *
13710 
         * @param array $routes
13711 
         * @return void
13712 
         * @static
13713 
         */
13714 
        public static function setCompiledRoutes($routes)
13715 
        {
13716 
                        /** @var \Illuminate\Routing\Router $instance */
13717 
                        $instance->setCompiledRoutes($routes);
13718 
        }
13719 
                    /**
13720 
         * Remove any duplicate middleware from the given array.
13721 
         *
13722 
         * @param array $middleware
13723 
         * @return array
13724 
         * @static
13725 
         */
13726 
        public static function uniqueMiddleware($middleware)
13727 
        {
13728 
                        return \Illuminate\Routing\Router::uniqueMiddleware($middleware);
13729 
        }
13730 
                    /**
13731 
         * Set the container instance used by the router.
13732 
         *
13733 
         * @param \Illuminate\Container\Container $container
13734 
         * @return \Illuminate\Routing\Router
13735 
         * @static
13736 
         */
13737 
        public static function setContainer($container)
13738 
        {
13739 
                        /** @var \Illuminate\Routing\Router $instance */
13740 
                        return $instance->setContainer($container);
13741 
        }
13742 
                    /**
13743 
         * Register a custom macro.
13744 
         *
13745 
         * @param string $name
13746 
         * @param object|callable $macro
13747 
         * @return void
13748 
         * @static
13749 
         */
13750 
        public static function macro($name, $macro)
13751 
        {
13752 
                        \Illuminate\Routing\Router::macro($name, $macro);
13753 
        }
13754 
                    /**
13755 
         * Mix another object into the class.
13756 
         *
13757 
         * @param object $mixin
13758 
         * @param bool $replace
13759 
         * @return void
13760 
         * @throws \ReflectionException
13761 
         * @static
13762 
         */
13763 
        public static function mixin($mixin, $replace = true)
13764 
        {
13765 
                        \Illuminate\Routing\Router::mixin($mixin, $replace);
13766 
        }
13767 
                    /**
13768 
         * Checks if macro is registered.
13769 
         *
13770 
         * @param string $name
13771 
         * @return bool
13772 
         * @static
13773 
         */
13774 
        public static function hasMacro($name)
13775 
        {
13776 
                        return \Illuminate\Routing\Router::hasMacro($name);
13777 
        }
13778 
                    /**
13779 
         * Flush the existing macros.
13780 
         *
13781 
         * @return void
13782 
         * @static
13783 
         */
13784 
        public static function flushMacros()
13785 
        {
13786 
                        \Illuminate\Routing\Router::flushMacros();
13787 
        }
13788 
                    /**
13789 
         * Dynamically handle calls to the class.
13790 
         *
13791 
         * @param string $method
13792 
         * @param array $parameters
13793 
         * @return mixed
13794 
         * @throws \BadMethodCallException
13795 
         * @static
13796 
         */
13797 
        public static function macroCall($method, $parameters)
13798 
        {
13799 
                        /** @var \Illuminate\Routing\Router $instance */
13800 
                        return $instance->macroCall($method, $parameters);
13801 
        }
13802 
 
13803 
    }
13804 
            /**
13805 
     *
13806 
     *
13807 
     * @see \Illuminate\Database\Schema\Builder
13808 
     */
13809 
        class Schema {
13810 
                    /**
13811 
         * Create a database in the schema.
13812 
         *
13813 
         * @param string $name
13814 
         * @return bool
13815 
         * @static
13816 
         */
13817 
        public static function createDatabase($name)
13818 
        {
13819 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13820 
                        return $instance->createDatabase($name);
13821 
        }
13822 
                    /**
13823 
         * Drop a database from the schema if the database exists.
13824 
         *
13825 
         * @param string $name
13826 
         * @return bool
13827 
         * @static
13828 
         */
13829 
        public static function dropDatabaseIfExists($name)
13830 
        {
13831 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13832 
                        return $instance->dropDatabaseIfExists($name);
13833 
        }
13834 
                    /**
13835 
         * Determine if the given table exists.
13836 
         *
13837 
         * @param string $table
13838 
         * @return bool
13839 
         * @static
13840 
         */
13841 
        public static function hasTable($table)
13842 
        {
13843 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13844 
                        return $instance->hasTable($table);
13845 
        }
13846 
                    /**
13847 
         * Get the column listing for a given table.
13848 
         *
13849 
         * @param string $table
13850 
         * @return array
13851 
         * @static
13852 
         */
13853 
        public static function getColumnListing($table)
13854 
        {
13855 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13856 
                        return $instance->getColumnListing($table);
13857 
        }
13858 
                    /**
13859 
         * Drop all tables from the database.
13860 
         *
13861 
         * @return void
13862 
         * @static
13863 
         */
13864 
        public static function dropAllTables()
13865 
        {
13866 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13867 
                        $instance->dropAllTables();
13868 
        }
13869 
                    /**
13870 
         * Drop all views from the database.
13871 
         *
13872 
         * @return void
13873 
         * @static
13874 
         */
13875 
        public static function dropAllViews()
13876 
        {
13877 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13878 
                        $instance->dropAllViews();
13879 
        }
13880 
                    /**
13881 
         * Get all of the table names for the database.
13882 
         *
13883 
         * @return array
13884 
         * @static
13885 
         */
13886 
        public static function getAllTables()
13887 
        {
13888 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13889 
                        return $instance->getAllTables();
13890 
        }
13891 
                    /**
13892 
         * Get all of the view names for the database.
13893 
         *
13894 
         * @return array
13895 
         * @static
13896 
         */
13897 
        public static function getAllViews()
13898 
        {
13899 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13900 
                        return $instance->getAllViews();
13901 
        }
13902 
                    /**
13903 
         * Set the default string length for migrations.
13904 
         *
13905 
         * @param int $length
13906 
         * @return void
13907 
         * @static
13908 
         */
13909 
        public static function defaultStringLength($length)
13910 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13911 
                        \Illuminate\Database\Schema\MySqlBuilder::defaultStringLength($length);
13912 
        }
13913 
                    /**
13914 
         * Set the default morph key type for migrations.
13915 
         *
13916 
         * @param string $type
13917 
         * @return void
13918 
         * @throws \InvalidArgumentException
13919 
         * @static
13920 
         */
13921 
        public static function defaultMorphKeyType($type)
13922 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13923 
                        \Illuminate\Database\Schema\MySqlBuilder::defaultMorphKeyType($type);
13924 
        }
13925 
                    /**
13926 
         * Set the default morph key type for migrations to UUIDs.
13927 
         *
13928 
         * @return void
13929 
         * @static
13930 
         */
13931 
        public static function morphUsingUuids()
13932 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13933 
                        \Illuminate\Database\Schema\MySqlBuilder::morphUsingUuids();
13934 
        }
13935 
                    /**
13936 
         * Set the default morph key type for migrations to ULIDs.
13937 
         *
13938 
         * @return void
13939 
         * @static
13940 
         */
13941 
        public static function morphUsingUlids()
13942 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13943 
                        \Illuminate\Database\Schema\MySqlBuilder::morphUsingUlids();
13944 
        }
13945 
                    /**
13946 
         * Attempt to use native schema operations for dropping and renaming columns, even if Doctrine DBAL is installed.
13947 
         *
13948 
         * @param bool $value
13949 
         * @return void
13950 
         * @static
13951 
         */
13952 
        public static function useNativeSchemaOperationsIfPossible($value = true)
13953 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13954 
                        \Illuminate\Database\Schema\MySqlBuilder::useNativeSchemaOperationsIfPossible($value);
13955 
        }
13956 
                    /**
13957 
         * Determine if the given table has a given column.
13958 
         *
13959 
         * @param string $table
13960 
         * @param string $column
13961 
         * @return bool
13962 
         * @static
13963 
         */
13964 
        public static function hasColumn($table, $column)
13965 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13966 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13967 
                        return $instance->hasColumn($table, $column);
13968 
        }
13969 
                    /**
13970 
         * Determine if the given table has given columns.
13971 
         *
13972 
         * @param string $table
13973 
         * @param array $columns
13974 
         * @return bool
13975 
         * @static
13976 
         */
13977 
        public static function hasColumns($table, $columns)
13978 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13979 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13980 
                        return $instance->hasColumns($table, $columns);
13981 
        }
13982 
                    /**
13983 
         * Execute a table builder callback if the given table has a given column.
13984 
         *
13985 
         * @param string $table
13986 
         * @param string $column
13987 
         * @param \Closure $callback
13988 
         * @return void
13989 
         * @static
13990 
         */
13991 
        public static function whenTableHasColumn($table, $column, $callback)
13992 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13993 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13994 
                        $instance->whenTableHasColumn($table, $column, $callback);
13995 
        }
13996 
                    /**
13997 
         * Execute a table builder callback if the given table doesn't have a given column.
13998 
         *
13999 
         * @param string $table
14000 
         * @param string $column
14001 
         * @param \Closure $callback
14002 
         * @return void
14003 
         * @static
14004 
         */
14005 
        public static function whenTableDoesntHaveColumn($table, $column, $callback)
14006 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14007 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14008 
                        $instance->whenTableDoesntHaveColumn($table, $column, $callback);
14009 
        }
14010 
                    /**
14011 
         * Get the data type for the given column name.
14012 
         *
14013 
         * @param string $table
14014 
         * @param string $column
14015 
         * @return string
14016 
         * @static
14017 
         */
14018 
        public static function getColumnType($table, $column)
14019 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14020 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14021 
                        return $instance->getColumnType($table, $column);
14022 
        }
14023 
                    /**
14024 
         * Modify a table on the schema.
14025 
         *
14026 
         * @param string $table
14027 
         * @param \Closure $callback
14028 
         * @return void
14029 
         * @static
14030 
         */
14031 
        public static function table($table, $callback)
14032 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14033 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14034 
                        $instance->table($table, $callback);
14035 
        }
14036 
                    /**
14037 
         * Create a new table on the schema.
14038 
         *
14039 
         * @param string $table
14040 
         * @param \Closure $callback
14041 
         * @return void
14042 
         * @static
14043 
         */
14044 
        public static function create($table, $callback)
14045 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14046 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14047 
                        $instance->create($table, $callback);
14048 
        }
14049 
                    /**
14050 
         * Drop a table from the schema.
14051 
         *
14052 
         * @param string $table
14053 
         * @return void
14054 
         * @static
14055 
         */
14056 
        public static function drop($table)
14057 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14058 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14059 
                        $instance->drop($table);
14060 
        }
14061 
                    /**
14062 
         * Drop a table from the schema if it exists.
14063 
         *
14064 
         * @param string $table
14065 
         * @return void
14066 
         * @static
14067 
         */
14068 
        public static function dropIfExists($table)
14069 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14070 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14071 
                        $instance->dropIfExists($table);
14072 
        }
14073 
                    /**
14074 
         * Drop columns from a table schema.
14075 
         *
14076 
         * @param string $table
14077 
         * @param string|array $columns
14078 
         * @return void
14079 
         * @static
14080 
         */
14081 
        public static function dropColumns($table, $columns)
14082 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14083 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14084 
                        $instance->dropColumns($table, $columns);
14085 
        }
14086 
                    /**
14087 
         * Drop all types from the database.
14088 
         *
14089 
         * @return void
14090 
         * @throws \LogicException
14091 
         * @static
14092 
         */
14093 
        public static function dropAllTypes()
14094 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14095 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14096 
                        $instance->dropAllTypes();
14097 
        }
14098 
                    /**
14099 
         * Rename a table on the schema.
14100 
         *
14101 
         * @param string $from
14102 
         * @param string $to
14103 
         * @return void
14104 
         * @static
14105 
         */
14106 
        public static function rename($from, $to)
14107 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14108 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14109 
                        $instance->rename($from, $to);
14110 
        }
14111 
                    /**
14112 
         * Enable foreign key constraints.
14113 
         *
14114 
         * @return bool
14115 
         * @static
14116 
         */
14117 
        public static function enableForeignKeyConstraints()
14118 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14119 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14120 
                        return $instance->enableForeignKeyConstraints();
14121 
        }
14122 
                    /**
14123 
         * Disable foreign key constraints.
14124 
         *
14125 
         * @return bool
14126 
         * @static
14127 
         */
14128 
        public static function disableForeignKeyConstraints()
14129 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14130 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14131 
                        return $instance->disableForeignKeyConstraints();
14132 
        }
14133 
                    /**
14134 
         * Disable foreign key constraints during the execution of a callback.
14135 
         *
14136 
         * @param \Closure $callback
14137 
         * @return mixed
14138 
         * @static
14139 
         */
14140 
        public static function withoutForeignKeyConstraints($callback)
14141 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14142 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14143 
                        return $instance->withoutForeignKeyConstraints($callback);
14144 
        }
14145 
                    /**
14146 
         * Get the database connection instance.
14147 
         *
14148 
         * @return \Illuminate\Database\Connection
14149 
         * @static
14150 
         */
14151 
        public static function getConnection()
14152 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14153 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14154 
                        return $instance->getConnection();
14155 
        }
14156 
                    /**
14157 
         * Set the database connection instance.
14158 
         *
14159 
         * @param \Illuminate\Database\Connection $connection
14160 
         * @return \Illuminate\Database\Schema\MySqlBuilder
14161 
         * @static
14162 
         */
14163 
        public static function setConnection($connection)
14164 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14165 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14166 
                        return $instance->setConnection($connection);
14167 
        }
14168 
                    /**
14169 
         * Set the Schema Blueprint resolver callback.
14170 
         *
14171 
         * @param \Closure $resolver
14172 
         * @return void
14173 
         * @static
14174 
         */
14175 
        public static function blueprintResolver($resolver)
14176 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14177 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14178 
                        $instance->blueprintResolver($resolver);
14179 
        }
14180 
 
14181 
    }
14182 
            /**
14183 
     *
14184 
     *
14185 
     * @see \Illuminate\Session\SessionManager
14186 
     */
14187 
        class Session {
14188 
                    /**
14189 
         * Determine if requests for the same session should wait for each to finish before executing.
14190 
         *
14191 
         * @return bool
14192 
         * @static
14193 
         */
14194 
        public static function shouldBlock()
14195 
        {
14196 
                        /** @var \Illuminate\Session\SessionManager $instance */
14197 
                        return $instance->shouldBlock();
14198 
        }
14199 
                    /**
14200 
         * Get the name of the cache store / driver that should be used to acquire session locks.
14201 
         *
14202 
         * @return string|null
14203 
         * @static
14204 
         */
14205 
        public static function blockDriver()
14206 
        {
14207 
                        /** @var \Illuminate\Session\SessionManager $instance */
14208 
                        return $instance->blockDriver();
14209 
        }
14210 
                    /**
14211 
         * Get the session configuration.
14212 
         *
14213 
         * @return array
14214 
         * @static
14215 
         */
14216 
        public static function getSessionConfig()
14217 
        {
14218 
                        /** @var \Illuminate\Session\SessionManager $instance */
14219 
                        return $instance->getSessionConfig();
14220 
        }
14221 
                    /**
14222 
         * Get the default session driver name.
14223 
         *
14224 
         * @return string
14225 
         * @static
14226 
         */
14227 
        public static function getDefaultDriver()
14228 
        {
14229 
                        /** @var \Illuminate\Session\SessionManager $instance */
14230 
                        return $instance->getDefaultDriver();
14231 
        }
14232 
                    /**
14233 
         * Set the default session driver name.
14234 
         *
14235 
         * @param string $name
14236 
         * @return void
14237 
         * @static
14238 
         */
14239 
        public static function setDefaultDriver($name)
14240 
        {
14241 
                        /** @var \Illuminate\Session\SessionManager $instance */
14242 
                        $instance->setDefaultDriver($name);
14243 
        }
14244 
                    /**
14245 
         * Get a driver instance.
14246 
         *
14247 
         * @param string|null $driver
14248 
         * @return mixed
14249 
         * @throws \InvalidArgumentException
14250 
         * @static
14251 
         */
14252 
        public static function driver($driver = null)
14253 
        {            //Method inherited from \Illuminate\Support\Manager
14254 
                        /** @var \Illuminate\Session\SessionManager $instance */
14255 
                        return $instance->driver($driver);
14256 
        }
14257 
                    /**
14258 
         * Register a custom driver creator Closure.
14259 
         *
14260 
         * @param string $driver
14261 
         * @param \Closure $callback
14262 
         * @return \Illuminate\Session\SessionManager
14263 
         * @static
14264 
         */
14265 
        public static function extend($driver, $callback)
14266 
        {            //Method inherited from \Illuminate\Support\Manager
14267 
                        /** @var \Illuminate\Session\SessionManager $instance */
14268 
                        return $instance->extend($driver, $callback);
14269 
        }
14270 
                    /**
14271 
         * Get all of the created "drivers".
14272 
         *
14273 
         * @return array
14274 
         * @static
14275 
         */
14276 
        public static function getDrivers()
14277 
        {            //Method inherited from \Illuminate\Support\Manager
14278 
                        /** @var \Illuminate\Session\SessionManager $instance */
14279 
                        return $instance->getDrivers();
14280 
        }
14281 
                    /**
14282 
         * Get the container instance used by the manager.
14283 
         *
14284 
         * @return \Illuminate\Contracts\Container\Container
14285 
         * @static
14286 
         */
14287 
        public static function getContainer()
14288 
        {            //Method inherited from \Illuminate\Support\Manager
14289 
                        /** @var \Illuminate\Session\SessionManager $instance */
14290 
                        return $instance->getContainer();
14291 
        }
14292 
                    /**
14293 
         * Set the container instance used by the manager.
14294 
         *
14295 
         * @param \Illuminate\Contracts\Container\Container $container
14296 
         * @return \Illuminate\Session\SessionManager
14297 
         * @static
14298 
         */
14299 
        public static function setContainer($container)
14300 
        {            //Method inherited from \Illuminate\Support\Manager
14301 
                        /** @var \Illuminate\Session\SessionManager $instance */
14302 
                        return $instance->setContainer($container);
14303 
        }
14304 
                    /**
14305 
         * Forget all of the resolved driver instances.
14306 
         *
14307 
         * @return \Illuminate\Session\SessionManager
14308 
         * @static
14309 
         */
14310 
        public static function forgetDrivers()
14311 
        {            //Method inherited from \Illuminate\Support\Manager
14312 
                        /** @var \Illuminate\Session\SessionManager $instance */
14313 
                        return $instance->forgetDrivers();
14314 
        }
14315 
                    /**
14316 
         * Start the session, reading the data from a handler.
14317 
         *
14318 
         * @return bool
14319 
         * @static
14320 
         */
14321 
        public static function start()
14322 
        {
14323 
                        /** @var \Illuminate\Session\Store $instance */
14324 
                        return $instance->start();
14325 
        }
14326 
                    /**
14327 
         * Save the session data to storage.
14328 
         *
14329 
         * @return void
14330 
         * @static
14331 
         */
14332 
        public static function save()
14333 
        {
14334 
                        /** @var \Illuminate\Session\Store $instance */
14335 
                        $instance->save();
14336 
        }
14337 
                    /**
14338 
         * Age the flash data for the session.
14339 
         *
14340 
         * @return void
14341 
         * @static
14342 
         */
14343 
        public static function ageFlashData()
14344 
        {
14345 
                        /** @var \Illuminate\Session\Store $instance */
14346 
                        $instance->ageFlashData();
14347 
        }
14348 
                    /**
14349 
         * Get all of the session data.
14350 
         *
14351 
         * @return array
14352 
         * @static
14353 
         */
14354 
        public static function all()
14355 
        {
14356 
                        /** @var \Illuminate\Session\Store $instance */
14357 
                        return $instance->all();
14358 
        }
14359 
                    /**
14360 
         * Get a subset of the session data.
14361 
         *
14362 
         * @param array $keys
14363 
         * @return array
14364 
         * @static
14365 
         */
14366 
        public static function only($keys)
14367 
        {
14368 
                        /** @var \Illuminate\Session\Store $instance */
14369 
                        return $instance->only($keys);
14370 
        }
14371 
                    /**
14372 
         * Checks if a key exists.
14373 
         *
14374 
         * @param string|array $key
14375 
         * @return bool
14376 
         * @static
14377 
         */
14378 
        public static function exists($key)
14379 
        {
14380 
                        /** @var \Illuminate\Session\Store $instance */
14381 
                        return $instance->exists($key);
14382 
        }
14383 
                    /**
14384 
         * Determine if the given key is missing from the session data.
14385 
         *
14386 
         * @param string|array $key
14387 
         * @return bool
14388 
         * @static
14389 
         */
14390 
        public static function missing($key)
14391 
        {
14392 
                        /** @var \Illuminate\Session\Store $instance */
14393 
                        return $instance->missing($key);
14394 
        }
14395 
                    /**
14396 
         * Checks if a key is present and not null.
14397 
         *
14398 
         * @param string|array $key
14399 
         * @return bool
14400 
         * @static
14401 
         */
14402 
        public static function has($key)
14403 
        {
14404 
                        /** @var \Illuminate\Session\Store $instance */
14405 
                        return $instance->has($key);
14406 
        }
14407 
                    /**
14408 
         * Get an item from the session.
14409 
         *
14410 
         * @param string $key
14411 
         * @param mixed $default
14412 
         * @return mixed
14413 
         * @static
14414 
         */
14415 
        public static function get($key, $default = null)
14416 
        {
14417 
                        /** @var \Illuminate\Session\Store $instance */
14418 
                        return $instance->get($key, $default);
14419 
        }
14420 
                    /**
14421 
         * Get the value of a given key and then forget it.
14422 
         *
14423 
         * @param string $key
14424 
         * @param mixed $default
14425 
         * @return mixed
14426 
         * @static
14427 
         */
14428 
        public static function pull($key, $default = null)
14429 
        {
14430 
                        /** @var \Illuminate\Session\Store $instance */
14431 
                        return $instance->pull($key, $default);
14432 
        }
14433 
                    /**
14434 
         * Determine if the session contains old input.
14435 
         *
14436 
         * @param string|null $key
14437 
         * @return bool
14438 
         * @static
14439 
         */
14440 
        public static function hasOldInput($key = null)
14441 
        {
14442 
                        /** @var \Illuminate\Session\Store $instance */
14443 
                        return $instance->hasOldInput($key);
14444 
        }
14445 
                    /**
14446 
         * Get the requested item from the flashed input array.
14447 
         *
14448 
         * @param string|null $key
14449 
         * @param mixed $default
14450 
         * @return mixed
14451 
         * @static
14452 
         */
14453 
        public static function getOldInput($key = null, $default = null)
14454 
        {
14455 
                        /** @var \Illuminate\Session\Store $instance */
14456 
                        return $instance->getOldInput($key, $default);
14457 
        }
14458 
                    /**
14459 
         * Replace the given session attributes entirely.
14460 
         *
14461 
         * @param array $attributes
14462 
         * @return void
14463 
         * @static
14464 
         */
14465 
        public static function replace($attributes)
14466 
        {
14467 
                        /** @var \Illuminate\Session\Store $instance */
14468 
                        $instance->replace($attributes);
14469 
        }
14470 
                    /**
14471 
         * Put a key / value pair or array of key / value pairs in the session.
14472 
         *
14473 
         * @param string|array $key
14474 
         * @param mixed $value
14475 
         * @return void
14476 
         * @static
14477 
         */
14478 
        public static function put($key, $value = null)
14479 
        {
14480 
                        /** @var \Illuminate\Session\Store $instance */
14481 
                        $instance->put($key, $value);
14482 
        }
14483 
                    /**
14484 
         * Get an item from the session, or store the default value.
14485 
         *
14486 
         * @param string $key
14487 
         * @param \Closure $callback
14488 
         * @return mixed
14489 
         * @static
14490 
         */
14491 
        public static function remember($key, $callback)
14492 
        {
14493 
                        /** @var \Illuminate\Session\Store $instance */
14494 
                        return $instance->remember($key, $callback);
14495 
        }
14496 
                    /**
14497 
         * Push a value onto a session array.
14498 
         *
14499 
         * @param string $key
14500 
         * @param mixed $value
14501 
         * @return void
14502 
         * @static
14503 
         */
14504 
        public static function push($key, $value)
14505 
        {
14506 
                        /** @var \Illuminate\Session\Store $instance */
14507 
                        $instance->push($key, $value);
14508 
        }
14509 
                    /**
14510 
         * Increment the value of an item in the session.
14511 
         *
14512 
         * @param string $key
14513 
         * @param int $amount
14514 
         * @return mixed
14515 
         * @static
14516 
         */
14517 
        public static function increment($key, $amount = 1)
14518 
        {
14519 
                        /** @var \Illuminate\Session\Store $instance */
14520 
                        return $instance->increment($key, $amount);
14521 
        }
14522 
                    /**
14523 
         * Decrement the value of an item in the session.
14524 
         *
14525 
         * @param string $key
14526 
         * @param int $amount
14527 
         * @return int
14528 
         * @static
14529 
         */
14530 
        public static function decrement($key, $amount = 1)
14531 
        {
14532 
                        /** @var \Illuminate\Session\Store $instance */
14533 
                        return $instance->decrement($key, $amount);
14534 
        }
14535 
                    /**
14536 
         * Flash a key / value pair to the session.
14537 
         *
14538 
         * @param string $key
14539 
         * @param mixed $value
14540 
         * @return void
14541 
         * @static
14542 
         */
14543 
        public static function flash($key, $value = true)
14544 
        {
14545 
                        /** @var \Illuminate\Session\Store $instance */
14546 
                        $instance->flash($key, $value);
14547 
        }
14548 
                    /**
14549 
         * Flash a key / value pair to the session for immediate use.
14550 
         *
14551 
         * @param string $key
14552 
         * @param mixed $value
14553 
         * @return void
14554 
         * @static
14555 
         */
14556 
        public static function now($key, $value)
14557 
        {
14558 
                        /** @var \Illuminate\Session\Store $instance */
14559 
                        $instance->now($key, $value);
14560 
        }
14561 
                    /**
14562 
         * Reflash all of the session flash data.
14563 
         *
14564 
         * @return void
14565 
         * @static
14566 
         */
14567 
        public static function reflash()
14568 
        {
14569 
                        /** @var \Illuminate\Session\Store $instance */
14570 
                        $instance->reflash();
14571 
        }
14572 
                    /**
14573 
         * Reflash a subset of the current flash data.
14574 
         *
14575 
         * @param array|mixed $keys
14576 
         * @return void
14577 
         * @static
14578 
         */
14579 
        public static function keep($keys = null)
14580 
        {
14581 
                        /** @var \Illuminate\Session\Store $instance */
14582 
                        $instance->keep($keys);
14583 
        }
14584 
                    /**
14585 
         * Flash an input array to the session.
14586 
         *
14587 
         * @param array $value
14588 
         * @return void
14589 
         * @static
14590 
         */
14591 
        public static function flashInput($value)
14592 
        {
14593 
                        /** @var \Illuminate\Session\Store $instance */
14594 
                        $instance->flashInput($value);
14595 
        }
14596 
                    /**
14597 
         * Remove an item from the session, returning its value.
14598 
         *
14599 
         * @param string $key
14600 
         * @return mixed
14601 
         * @static
14602 
         */
14603 
        public static function remove($key)
14604 
        {
14605 
                        /** @var \Illuminate\Session\Store $instance */
14606 
                        return $instance->remove($key);
14607 
        }
14608 
                    /**
14609 
         * Remove one or many items from the session.
14610 
         *
14611 
         * @param string|array $keys
14612 
         * @return void
14613 
         * @static
14614 
         */
14615 
        public static function forget($keys)
14616 
        {
14617 
                        /** @var \Illuminate\Session\Store $instance */
14618 
                        $instance->forget($keys);
14619 
        }
14620 
                    /**
14621 
         * Remove all of the items from the session.
14622 
         *
14623 
         * @return void
14624 
         * @static
14625 
         */
14626 
        public static function flush()
14627 
        {
14628 
                        /** @var \Illuminate\Session\Store $instance */
14629 
                        $instance->flush();
14630 
        }
14631 
                    /**
14632 
         * Flush the session data and regenerate the ID.
14633 
         *
14634 
         * @return bool
14635 
         * @static
14636 
         */
14637 
        public static function invalidate()
14638 
        {
14639 
                        /** @var \Illuminate\Session\Store $instance */
14640 
                        return $instance->invalidate();
14641 
        }
14642 
                    /**
14643 
         * Generate a new session identifier.
14644 
         *
14645 
         * @param bool $destroy
14646 
         * @return bool
14647 
         * @static
14648 
         */
14649 
        public static function regenerate($destroy = false)
14650 
        {
14651 
                        /** @var \Illuminate\Session\Store $instance */
14652 
                        return $instance->regenerate($destroy);
14653 
        }
14654 
                    /**
14655 
         * Generate a new session ID for the session.
14656 
         *
14657 
         * @param bool $destroy
14658 
         * @return bool
14659 
         * @static
14660 
         */
14661 
        public static function migrate($destroy = false)
14662 
        {
14663 
                        /** @var \Illuminate\Session\Store $instance */
14664 
                        return $instance->migrate($destroy);
14665 
        }
14666 
                    /**
14667 
         * Determine if the session has been started.
14668 
         *
14669 
         * @return bool
14670 
         * @static
14671 
         */
14672 
        public static function isStarted()
14673 
        {
14674 
                        /** @var \Illuminate\Session\Store $instance */
14675 
                        return $instance->isStarted();
14676 
        }
14677 
                    /**
14678 
         * Get the name of the session.
14679 
         *
14680 
         * @return string
14681 
         * @static
14682 
         */
14683 
        public static function getName()
14684 
        {
14685 
                        /** @var \Illuminate\Session\Store $instance */
14686 
                        return $instance->getName();
14687 
        }
14688 
                    /**
14689 
         * Set the name of the session.
14690 
         *
14691 
         * @param string $name
14692 
         * @return void
14693 
         * @static
14694 
         */
14695 
        public static function setName($name)
14696 
        {
14697 
                        /** @var \Illuminate\Session\Store $instance */
14698 
                        $instance->setName($name);
14699 
        }
14700 
                    /**
14701 
         * Get the current session ID.
14702 
         *
14703 
         * @return string
14704 
         * @static
14705 
         */
14706 
        public static function getId()
14707 
        {
14708 
                        /** @var \Illuminate\Session\Store $instance */
14709 
                        return $instance->getId();
14710 
        }
14711 
                    /**
14712 
         * Set the session ID.
14713 
         *
14714 
         * @param string|null $id
14715 
         * @return void
14716 
         * @static
14717 
         */
14718 
        public static function setId($id)
14719 
        {
14720 
                        /** @var \Illuminate\Session\Store $instance */
14721 
                        $instance->setId($id);
14722 
        }
14723 
                    /**
14724 
         * Determine if this is a valid session ID.
14725 
         *
14726 
         * @param string|null $id
14727 
         * @return bool
14728 
         * @static
14729 
         */
14730 
        public static function isValidId($id)
14731 
        {
14732 
                        /** @var \Illuminate\Session\Store $instance */
14733 
                        return $instance->isValidId($id);
14734 
        }
14735 
                    /**
14736 
         * Set the existence of the session on the handler if applicable.
14737 
         *
14738 
         * @param bool $value
14739 
         * @return void
14740 
         * @static
14741 
         */
14742 
        public static function setExists($value)
14743 
        {
14744 
                        /** @var \Illuminate\Session\Store $instance */
14745 
                        $instance->setExists($value);
14746 
        }
14747 
                    /**
14748 
         * Get the CSRF token value.
14749 
         *
14750 
         * @return string
14751 
         * @static
14752 
         */
14753 
        public static function token()
14754 
        {
14755 
                        /** @var \Illuminate\Session\Store $instance */
14756 
                        return $instance->token();
14757 
        }
14758 
                    /**
14759 
         * Regenerate the CSRF token value.
14760 
         *
14761 
         * @return void
14762 
         * @static
14763 
         */
14764 
        public static function regenerateToken()
14765 
        {
14766 
                        /** @var \Illuminate\Session\Store $instance */
14767 
                        $instance->regenerateToken();
14768 
        }
14769 
                    /**
14770 
         * Get the previous URL from the session.
14771 
         *
14772 
         * @return string|null
14773 
         * @static
14774 
         */
14775 
        public static function previousUrl()
14776 
        {
14777 
                        /** @var \Illuminate\Session\Store $instance */
14778 
                        return $instance->previousUrl();
14779 
        }
14780 
                    /**
14781 
         * Set the "previous" URL in the session.
14782 
         *
14783 
         * @param string $url
14784 
         * @return void
14785 
         * @static
14786 
         */
14787 
        public static function setPreviousUrl($url)
14788 
        {
14789 
                        /** @var \Illuminate\Session\Store $instance */
14790 
                        $instance->setPreviousUrl($url);
14791 
        }
14792 
                    /**
14793 
         * Specify that the user has confirmed their password.
14794 
         *
14795 
         * @return void
14796 
         * @static
14797 
         */
14798 
        public static function passwordConfirmed()
14799 
        {
14800 
                        /** @var \Illuminate\Session\Store $instance */
14801 
                        $instance->passwordConfirmed();
14802 
        }
14803 
                    /**
14804 
         * Get the underlying session handler implementation.
14805 
         *
14806 
         * @return \SessionHandlerInterface
14807 
         * @static
14808 
         */
14809 
        public static function getHandler()
14810 
        {
14811 
                        /** @var \Illuminate\Session\Store $instance */
14812 
                        return $instance->getHandler();
14813 
        }
14814 
                    /**
14815 
         * Set the underlying session handler implementation.
14816 
         *
14817 
         * @param \SessionHandlerInterface $handler
14818 
         * @return \SessionHandlerInterface
14819 
         * @static
14820 
         */
14821 
        public static function setHandler($handler)
14822 
        {
14823 
                        /** @var \Illuminate\Session\Store $instance */
14824 
                        return $instance->setHandler($handler);
14825 
        }
14826 
                    /**
14827 
         * Determine if the session handler needs a request.
14828 
         *
14829 
         * @return bool
14830 
         * @static
14831 
         */
14832 
        public static function handlerNeedsRequest()
14833 
        {
14834 
                        /** @var \Illuminate\Session\Store $instance */
14835 
                        return $instance->handlerNeedsRequest();
14836 
        }
14837 
                    /**
14838 
         * Set the request on the handler instance.
14839 
         *
14840 
         * @param \Illuminate\Http\Request $request
14841 
         * @return void
14842 
         * @static
14843 
         */
14844 
        public static function setRequestOnHandler($request)
14845 
        {
14846 
                        /** @var \Illuminate\Session\Store $instance */
14847 
                        $instance->setRequestOnHandler($request);
14848 
        }
14849 
                    /**
14850 
         * Register a custom macro.
14851 
         *
14852 
         * @param string $name
14853 
         * @param object|callable $macro
14854 
         * @return void
14855 
         * @static
14856 
         */
14857 
        public static function macro($name, $macro)
14858 
        {
14859 
                        \Illuminate\Session\Store::macro($name, $macro);
14860 
        }
14861 
                    /**
14862 
         * Mix another object into the class.
14863 
         *
14864 
         * @param object $mixin
14865 
         * @param bool $replace
14866 
         * @return void
14867 
         * @throws \ReflectionException
14868 
         * @static
14869 
         */
14870 
        public static function mixin($mixin, $replace = true)
14871 
        {
14872 
                        \Illuminate\Session\Store::mixin($mixin, $replace);
14873 
        }
14874 
                    /**
14875 
         * Checks if macro is registered.
14876 
         *
14877 
         * @param string $name
14878 
         * @return bool
14879 
         * @static
14880 
         */
14881 
        public static function hasMacro($name)
14882 
        {
14883 
                        return \Illuminate\Session\Store::hasMacro($name);
14884 
        }
14885 
                    /**
14886 
         * Flush the existing macros.
14887 
         *
14888 
         * @return void
14889 
         * @static
14890 
         */
14891 
        public static function flushMacros()
14892 
        {
14893 
                        \Illuminate\Session\Store::flushMacros();
14894 
        }
14895 
 
14896 
    }
14897 
            /**
14898 
     *
14899 
     *
14900 
     * @method static bool has(string $location)
14901 
     * @method static string read(string $location)
14902 
     * @method static \League\Flysystem\DirectoryListing listContents(string $location, bool $deep = false)
14903 
     * @method static int fileSize(string $path)
14904 
     * @method static string visibility(string $path)
14905 
     * @method static void write(string $location, string $contents, array $config = [])
14906 
     * @method static void createDirectory(string $location, array $config = [])
14907 
     * @see \Illuminate\Filesystem\FilesystemManager
14908 
     */
14909 
        class Storage {
14910 
                    /**
14911 
         * Get a filesystem instance.
14912 
         *
14913 
         * @param string|null $name
14914 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14915 
         * @static
14916 
         */
14917 
        public static function drive($name = null)
14918 
        {
14919 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14920 
                        return $instance->drive($name);
14921 
        }
14922 
                    /**
14923 
         * Get a filesystem instance.
14924 
         *
14925 
         * @param string|null $name
14926 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14927 
         * @static
14928 
         */
14929 
        public static function disk($name = null)
14930 
        {
14931 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14932 
                        return $instance->disk($name);
14933 
        }
14934 
                    /**
14935 
         * Get a default cloud filesystem instance.
14936 
         *
14937 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14938 
         * @static
14939 
         */
14940 
        public static function cloud()
14941 
        {
14942 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14943 
                        return $instance->cloud();
14944 
        }
14945 
                    /**
14946 
         * Build an on-demand disk.
14947 
         *
14948 
         * @param string|array $config
14949 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14950 
         * @static
14951 
         */
14952 
        public static function build($config)
14953 
        {
14954 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14955 
                        return $instance->build($config);
14956 
        }
14957 
                    /**
14958 
         * Create an instance of the local driver.
14959 
         *
14960 
         * @param array $config
14961 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14962 
         * @static
14963 
         */
14964 
        public static function createLocalDriver($config)
14965 
        {
14966 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14967 
                        return $instance->createLocalDriver($config);
14968 
        }
14969 
                    /**
14970 
         * Create an instance of the ftp driver.
14971 
         *
14972 
         * @param array $config
14973 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14974 
         * @static
14975 
         */
14976 
        public static function createFtpDriver($config)
14977 
        {
14978 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14979 
                        return $instance->createFtpDriver($config);
14980 
        }
14981 
                    /**
14982 
         * Create an instance of the sftp driver.
14983 
         *
14984 
         * @param array $config
14985 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14986 
         * @static
14987 
         */
14988 
        public static function createSftpDriver($config)
14989 
        {
14990 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14991 
                        return $instance->createSftpDriver($config);
14992 
        }
14993 
                    /**
14994 
         * Create an instance of the Amazon S3 driver.
14995 
         *
14996 
         * @param array $config
14997 
         * @return \Illuminate\Contracts\Filesystem\Cloud
14998 
         * @static
14999 
         */
15000 
        public static function createS3Driver($config)
15001 
        {
15002 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15003 
                        return $instance->createS3Driver($config);
15004 
        }
15005 
                    /**
15006 
         * Create a scoped driver.
15007 
         *
15008 
         * @param array $config
15009 
         * @return \Illuminate\Filesystem\FilesystemAdapter
15010 
         * @static
15011 
         */
15012 
        public static function createScopedDriver($config)
15013 
        {
15014 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15015 
                        return $instance->createScopedDriver($config);
15016 
        }
15017 
                    /**
15018 
         * Set the given disk instance.
15019 
         *
15020 
         * @param string $name
15021 
         * @param mixed $disk
15022 
         * @return \Illuminate\Filesystem\FilesystemManager
15023 
         * @static
15024 
         */
15025 
        public static function set($name, $disk)
15026 
        {
15027 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15028 
                        return $instance->set($name, $disk);
15029 
        }
15030 
                    /**
15031 
         * Get the default driver name.
15032 
         *
15033 
         * @return string
15034 
         * @static
15035 
         */
15036 
        public static function getDefaultDriver()
15037 
        {
15038 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15039 
                        return $instance->getDefaultDriver();
15040 
        }
15041 
                    /**
15042 
         * Get the default cloud driver name.
15043 
         *
15044 
         * @return string
15045 
         * @static
15046 
         */
15047 
        public static function getDefaultCloudDriver()
15048 
        {
15049 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15050 
                        return $instance->getDefaultCloudDriver();
15051 
        }
15052 
                    /**
15053 
         * Unset the given disk instances.
15054 
         *
15055 
         * @param array|string $disk
15056 
         * @return \Illuminate\Filesystem\FilesystemManager
15057 
         * @static
15058 
         */
15059 
        public static function forgetDisk($disk)
15060 
        {
15061 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15062 
                        return $instance->forgetDisk($disk);
15063 
        }
15064 
                    /**
15065 
         * Disconnect the given disk and remove from local cache.
15066 
         *
15067 
         * @param string|null $name
15068 
         * @return void
15069 
         * @static
15070 
         */
15071 
        public static function purge($name = null)
15072 
        {
15073 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15074 
                        $instance->purge($name);
15075 
        }
15076 
                    /**
15077 
         * Register a custom driver creator Closure.
15078 
         *
15079 
         * @param string $driver
15080 
         * @param \Closure $callback
15081 
         * @return \Illuminate\Filesystem\FilesystemManager
15082 
         * @static
15083 
         */
15084 
        public static function extend($driver, $callback)
15085 
        {
15086 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15087 
                        return $instance->extend($driver, $callback);
15088 
        }
15089 
                    /**
15090 
         * Set the application instance used by the manager.
15091 
         *
15092 
         * @param \Illuminate\Contracts\Foundation\Application $app
15093 
         * @return \Illuminate\Filesystem\FilesystemManager
15094 
         * @static
15095 
         */
15096 
        public static function setApplication($app)
15097 
        {
15098 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15099 
                        return $instance->setApplication($app);
15100 
        }
15101 
                    /**
15102 
         * Assert that the given file or directory exists.
15103 
         *
15104 
         * @param string|array $path
15105 
         * @param string|null $content
15106 
         * @return \Illuminate\Filesystem\FilesystemAdapter
15107 
         * @static
15108 
         */
15109 
        public static function assertExists($path, $content = null)
15110 
        {
15111 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15112 
                        return $instance->assertExists($path, $content);
15113 
        }
15114 
                    /**
15115 
         * Assert that the given file or directory does not exist.
15116 
         *
15117 
         * @param string|array $path
15118 
         * @return \Illuminate\Filesystem\FilesystemAdapter
15119 
         * @static
15120 
         */
15121 
        public static function assertMissing($path)
15122 
        {
15123 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15124 
                        return $instance->assertMissing($path);
15125 
        }
15126 
                    /**
15127 
         * Assert that the given directory is empty.
15128 
         *
15129 
         * @param string $path
15130 
         * @return \Illuminate\Filesystem\FilesystemAdapter
15131 
         * @static
15132 
         */
15133 
        public static function assertDirectoryEmpty($path)
15134 
        {
15135 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15136 
                        return $instance->assertDirectoryEmpty($path);
15137 
        }
15138 
                    /**
15139 
         * Determine if a file or directory exists.
15140 
         *
15141 
         * @param string $path
15142 
         * @return bool
15143 
         * @static
15144 
         */
15145 
        public static function exists($path)
15146 
        {
15147 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15148 
                        return $instance->exists($path);
15149 
        }
15150 
                    /**
15151 
         * Determine if a file or directory is missing.
15152 
         *
15153 
         * @param string $path
15154 
         * @return bool
15155 
         * @static
15156 
         */
15157 
        public static function missing($path)
15158 
        {
15159 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15160 
                        return $instance->missing($path);
15161 
        }
15162 
                    /**
15163 
         * Determine if a file exists.
15164 
         *
15165 
         * @param string $path
15166 
         * @return bool
15167 
         * @static
15168 
         */
15169 
        public static function fileExists($path)
15170 
        {
15171 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15172 
                        return $instance->fileExists($path);
15173 
        }
15174 
                    /**
15175 
         * Determine if a file is missing.
15176 
         *
15177 
         * @param string $path
15178 
         * @return bool
15179 
         * @static
15180 
         */
15181 
        public static function fileMissing($path)
15182 
        {
15183 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15184 
                        return $instance->fileMissing($path);
15185 
        }
15186 
                    /**
15187 
         * Determine if a directory exists.
15188 
         *
15189 
         * @param string $path
15190 
         * @return bool
15191 
         * @static
15192 
         */
15193 
        public static function directoryExists($path)
15194 
        {
15195 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15196 
                        return $instance->directoryExists($path);
15197 
        }
15198 
                    /**
15199 
         * Determine if a directory is missing.
15200 
         *
15201 
         * @param string $path
15202 
         * @return bool
15203 
         * @static
15204 
         */
15205 
        public static function directoryMissing($path)
15206 
        {
15207 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15208 
                        return $instance->directoryMissing($path);
15209 
        }
15210 
                    /**
15211 
         * Get the full path for the file at the given "short" path.
15212 
         *
15213 
         * @param string $path
15214 
         * @return string
15215 
         * @static
15216 
         */
15217 
        public static function path($path)
15218 
        {
15219 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15220 
                        return $instance->path($path);
15221 
        }
15222 
                    /**
15223 
         * Get the contents of a file.
15224 
         *
15225 
         * @param string $path
15226 
         * @return string|null
15227 
         * @static
15228 
         */
15229 
        public static function get($path)
15230 
        {
15231 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15232 
                        return $instance->get($path);
15233 
        }
15234 
                    /**
15235 
         * Create a streamed response for a given file.
15236 
         *
15237 
         * @param string $path
15238 
         * @param string|null $name
15239 
         * @param array $headers
15240 
         * @param string|null $disposition
15241 
         * @return \Symfony\Component\HttpFoundation\StreamedResponse
15242 
         * @static
15243 
         */
15244 
        public static function response($path, $name = null, $headers = [], $disposition = 'inline')
15245 
        {
15246 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15247 
                        return $instance->response($path, $name, $headers, $disposition);
15248 
        }
15249 
                    /**
15250 
         * Create a streamed download response for a given file.
15251 
         *
15252 
         * @param string $path
15253 
         * @param string|null $name
15254 
         * @return \Symfony\Component\HttpFoundation\StreamedResponse
15255 
         * @static
15256 
         */
15257 
        public static function download($path, $name = null, $headers = [])
15258 
        {
15259 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15260 
                        return $instance->download($path, $name, $headers);
15261 
        }
15262 
                    /**
15263 
         * Write the contents of a file.
15264 
         *
15265 
         * @param string $path
15266 
         * @param \Psr\Http\Message\StreamInterface|\Illuminate\Http\File|\Illuminate\Http\UploadedFile|string|resource $contents
15267 
         * @param mixed $options
15268 
         * @return string|bool
15269 
         * @static
15270 
         */
15271 
        public static function put($path, $contents, $options = [])
15272 
        {
15273 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15274 
                        return $instance->put($path, $contents, $options);
15275 
        }
15276 
                    /**
15277 
         * Store the uploaded file on the disk.
15278 
         *
15279 
         * @param string $path
15280 
         * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile|string $file
15281 
         * @param mixed $options
15282 
         * @return string|false
15283 
         * @static
15284 
         */
15285 
        public static function putFile($path, $file, $options = [])
15286 
        {
15287 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15288 
                        return $instance->putFile($path, $file, $options);
15289 
        }
15290 
                    /**
15291 
         * Store the uploaded file on the disk with a given name.
15292 
         *
15293 
         * @param string $path
15294 
         * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile|string $file
15295 
         * @param string $name
15296 
         * @param mixed $options
15297 
         * @return string|false
15298 
         * @static
15299 
         */
15300 
        public static function putFileAs($path, $file, $name, $options = [])
15301 
        {
15302 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15303 
                        return $instance->putFileAs($path, $file, $name, $options);
15304 
        }
15305 
                    /**
15306 
         * Get the visibility for the given path.
15307 
         *
15308 
         * @param string $path
15309 
         * @return string
15310 
         * @static
15311 
         */
15312 
        public static function getVisibility($path)
15313 
        {
15314 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15315 
                        return $instance->getVisibility($path);
15316 
        }
15317 
                    /**
15318 
         * Set the visibility for the given path.
15319 
         *
15320 
         * @param string $path
15321 
         * @param string $visibility
15322 
         * @return bool
15323 
         * @static
15324 
         */
15325 
        public static function setVisibility($path, $visibility)
15326 
        {
15327 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15328 
                        return $instance->setVisibility($path, $visibility);
15329 
        }
15330 
                    /**
15331 
         * Prepend to a file.
15332 
         *
15333 
         * @param string $path
15334 
         * @param string $data
15335 
         * @param string $separator
15336 
         * @return bool
15337 
         * @static
15338 
         */
15339 
        public static function prepend($path, $data, $separator = '
15340 
')
15341 
        {
15342 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15343 
                        return $instance->prepend($path, $data, $separator);
15344 
        }
15345 
                    /**
15346 
         * Append to a file.
15347 
         *
15348 
         * @param string $path
15349 
         * @param string $data
15350 
         * @param string $separator
15351 
         * @return bool
15352 
         * @static
15353 
         */
15354 
        public static function append($path, $data, $separator = '
15355 
')
15356 
        {
15357 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15358 
                        return $instance->append($path, $data, $separator);
15359 
        }
15360 
                    /**
15361 
         * Delete the file at a given path.
15362 
         *
15363 
         * @param string|array $paths
15364 
         * @return bool
15365 
         * @static
15366 
         */
15367 
        public static function delete($paths)
15368 
        {
15369 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15370 
                        return $instance->delete($paths);
15371 
        }
15372 
                    /**
15373 
         * Copy a file to a new location.
15374 
         *
15375 
         * @param string $from
15376 
         * @param string $to
15377 
         * @return bool
15378 
         * @static
15379 
         */
15380 
        public static function copy($from, $to)
15381 
        {
15382 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15383 
                        return $instance->copy($from, $to);
15384 
        }
15385 
                    /**
15386 
         * Move a file to a new location.
15387 
         *
15388 
         * @param string $from
15389 
         * @param string $to
15390 
         * @return bool
15391 
         * @static
15392 
         */
15393 
        public static function move($from, $to)
15394 
        {
15395 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15396 
                        return $instance->move($from, $to);
15397 
        }
15398 
                    /**
15399 
         * Get the file size of a given file.
15400 
         *
15401 
         * @param string $path
15402 
         * @return int
15403 
         * @static
15404 
         */
15405 
        public static function size($path)
15406 
        {
15407 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15408 
                        return $instance->size($path);
15409 
        }
15410 
                    /**
15411 
         * Get the checksum for a file.
15412 
         *
15413 
         * @return string|false
15414 
         * @throws UnableToProvideChecksum
15415 
         * @static
15416 
         */
15417 
        public static function checksum($path, $options = [])
15418 
        {
15419 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15420 
                        return $instance->checksum($path, $options);
15421 
        }
15422 
                    /**
15423 
         * Get the mime-type of a given file.
15424 
         *
15425 
         * @param string $path
15426 
         * @return string|false
15427 
         * @static
15428 
         */
15429 
        public static function mimeType($path)
15430 
        {
15431 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15432 
                        return $instance->mimeType($path);
15433 
        }
15434 
                    /**
15435 
         * Get the file's last modification time.
15436 
         *
15437 
         * @param string $path
15438 
         * @return int
15439 
         * @static
15440 
         */
15441 
        public static function lastModified($path)
15442 
        {
15443 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15444 
                        return $instance->lastModified($path);
15445 
        }
15446 
                    /**
15447 
         * Get a resource to read the file.
15448 
         *
15449 
         * @param string $path
15450 
         * @return resource|null The path resource or null on failure.
15451 
         * @static
15452 
         */
15453 
        public static function readStream($path)
15454 
        {
15455 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15456 
                        return $instance->readStream($path);
15457 
        }
15458 
                    /**
15459 
         * Write a new file using a stream.
15460 
         *
15461 
         * @param string $path
15462 
         * @param resource $resource
15463 
         * @param array $options
15464 
         * @return bool
15465 
         * @static
15466 
         */
15467 
        public static function writeStream($path, $resource, $options = [])
15468 
        {
15469 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15470 
                        return $instance->writeStream($path, $resource, $options);
15471 
        }
15472 
                    /**
15473 
         * Get the URL for the file at the given path.
15474 
         *
15475 
         * @param string $path
15476 
         * @return string
15477 
         * @throws \RuntimeException
15478 
         * @static
15479 
         */
15480 
        public static function url($path)
15481 
        {
15482 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15483 
                        return $instance->url($path);
15484 
        }
15485 
                    /**
15486 
         * Determine if temporary URLs can be generated.
15487 
         *
15488 
         * @return bool
15489 
         * @static
15490 
         */
15491 
        public static function providesTemporaryUrls()
15492 
        {
15493 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15494 
                        return $instance->providesTemporaryUrls();
15495 
        }
15496 
                    /**
15497 
         * Get a temporary URL for the file at the given path.
15498 
         *
15499 
         * @param string $path
15500 
         * @param \DateTimeInterface $expiration
15501 
         * @param array $options
15502 
         * @return string
15503 
         * @throws \RuntimeException
15504 
         * @static
15505 
         */
15506 
        public static function temporaryUrl($path, $expiration, $options = [])
15507 
        {
15508 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15509 
                        return $instance->temporaryUrl($path, $expiration, $options);
15510 
        }
15511 
                    /**
15512 
         * Get a temporary upload URL for the file at the given path.
15513 
         *
15514 
         * @param string $path
15515 
         * @param \DateTimeInterface $expiration
15516 
         * @param array $options
15517 
         * @return array
15518 
         * @throws \RuntimeException
15519 
         * @static
15520 
         */
15521 
        public static function temporaryUploadUrl($path, $expiration, $options = [])
15522 
        {
15523 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15524 
                        return $instance->temporaryUploadUrl($path, $expiration, $options);
15525 
        }
15526 
                    /**
15527 
         * Get an array of all files in a directory.
15528 
         *
15529 
         * @param string|null $directory
15530 
         * @param bool $recursive
15531 
         * @return array
15532 
         * @static
15533 
         */
15534 
        public static function files($directory = null, $recursive = false)
15535 
        {
15536 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15537 
                        return $instance->files($directory, $recursive);
15538 
        }
15539 
                    /**
15540 
         * Get all of the files from the given directory (recursive).
15541 
         *
15542 
         * @param string|null $directory
15543 
         * @return array
15544 
         * @static
15545 
         */
15546 
        public static function allFiles($directory = null)
15547 
        {
15548 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15549 
                        return $instance->allFiles($directory);
15550 
        }
15551 
                    /**
15552 
         * Get all of the directories within a given directory.
15553 
         *
15554 
         * @param string|null $directory
15555 
         * @param bool $recursive
15556 
         * @return array
15557 
         * @static
15558 
         */
15559 
        public static function directories($directory = null, $recursive = false)
15560 
        {
15561 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15562 
                        return $instance->directories($directory, $recursive);
15563 
        }
15564 
                    /**
15565 
         * Get all the directories within a given directory (recursive).
15566 
         *
15567 
         * @param string|null $directory
15568 
         * @return array
15569 
         * @static
15570 
         */
15571 
        public static function allDirectories($directory = null)
15572 
        {
15573 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15574 
                        return $instance->allDirectories($directory);
15575 
        }
15576 
                    /**
15577 
         * Create a directory.
15578 
         *
15579 
         * @param string $path
15580 
         * @return bool
15581 
         * @static
15582 
         */
15583 
        public static function makeDirectory($path)
15584 
        {
15585 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15586 
                        return $instance->makeDirectory($path);
15587 
        }
15588 
                    /**
15589 
         * Recursively delete a directory.
15590 
         *
15591 
         * @param string $directory
15592 
         * @return bool
15593 
         * @static
15594 
         */
15595 
        public static function deleteDirectory($directory)
15596 
        {
15597 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15598 
                        return $instance->deleteDirectory($directory);
15599 
        }
15600 
                    /**
15601 
         * Get the Flysystem driver.
15602 
         *
15603 
         * @return \League\Flysystem\FilesystemOperator
15604 
         * @static
15605 
         */
15606 
        public static function getDriver()
15607 
        {
15608 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15609 
                        return $instance->getDriver();
15610 
        }
15611 
                    /**
15612 
         * Get the Flysystem adapter.
15613 
         *
15614 
         * @return \League\Flysystem\FilesystemAdapter
15615 
         * @static
15616 
         */
15617 
        public static function getAdapter()
15618 
        {
15619 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15620 
                        return $instance->getAdapter();
15621 
        }
15622 
                    /**
15623 
         * Get the configuration values.
15624 
         *
15625 
         * @return array
15626 
         * @static
15627 
         */
15628 
        public static function getConfig()
15629 
        {
15630 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15631 
                        return $instance->getConfig();
15632 
        }
15633 
                    /**
15634 
         * Define a custom temporary URL builder callback.
15635 
         *
15636 
         * @param \Closure $callback
15637 
         * @return void
15638 
         * @static
15639 
         */
15640 
        public static function buildTemporaryUrlsUsing($callback)
15641 
        {
15642 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15643 
                        $instance->buildTemporaryUrlsUsing($callback);
15644 
        }
15645 
                    /**
15646 
         * Apply the callback if the given "value" is (or resolves to) truthy.
15647 
         *
15648 
         * @template TWhenParameter
15649 
         * @template TWhenReturnType
15650 
         * @param \Illuminate\Filesystem\(\Closure($this):  TWhenParameter)|TWhenParameter|null  $value
15651 
         * @param \Illuminate\Filesystem\(callable($this,  TWhenParameter): TWhenReturnType)|null  $callback
15652 
         * @param \Illuminate\Filesystem\(callable($this,  TWhenParameter): TWhenReturnType)|null  $default
15653 
         * @return $this|\Illuminate\Filesystem\TWhenReturnType
15654 
         * @static
15655 
         */
15656 
        public static function when($value = null, $callback = null, $default = null)
15657 
        {
15658 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15659 
                        return $instance->when($value, $callback, $default);
15660 
        }
15661 
                    /**
15662 
         * Apply the callback if the given "value" is (or resolves to) falsy.
15663 
         *
15664 
         * @template TUnlessParameter
15665 
         * @template TUnlessReturnType
15666 
         * @param \Illuminate\Filesystem\(\Closure($this):  TUnlessParameter)|TUnlessParameter|null  $value
15667 
         * @param \Illuminate\Filesystem\(callable($this,  TUnlessParameter): TUnlessReturnType)|null  $callback
15668 
         * @param \Illuminate\Filesystem\(callable($this,  TUnlessParameter): TUnlessReturnType)|null  $default
15669 
         * @return $this|\Illuminate\Filesystem\TUnlessReturnType
15670 
         * @static
15671 
         */
15672 
        public static function unless($value = null, $callback = null, $default = null)
15673 
        {
15674 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15675 
                        return $instance->unless($value, $callback, $default);
15676 
        }
15677 
                    /**
15678 
         * Register a custom macro.
15679 
         *
15680 
         * @param string $name
15681 
         * @param object|callable $macro
15682 
         * @return void
15683 
         * @static
15684 
         */
15685 
        public static function macro($name, $macro)
15686 
        {
15687 
                        \Illuminate\Filesystem\FilesystemAdapter::macro($name, $macro);
15688 
        }
15689 
                    /**
15690 
         * Mix another object into the class.
15691 
         *
15692 
         * @param object $mixin
15693 
         * @param bool $replace
15694 
         * @return void
15695 
         * @throws \ReflectionException
15696 
         * @static
15697 
         */
15698 
        public static function mixin($mixin, $replace = true)
15699 
        {
15700 
                        \Illuminate\Filesystem\FilesystemAdapter::mixin($mixin, $replace);
15701 
        }
15702 
                    /**
15703 
         * Checks if macro is registered.
15704 
         *
15705 
         * @param string $name
15706 
         * @return bool
15707 
         * @static
15708 
         */
15709 
        public static function hasMacro($name)
15710 
        {
15711 
                        return \Illuminate\Filesystem\FilesystemAdapter::hasMacro($name);
15712 
        }
15713 
                    /**
15714 
         * Flush the existing macros.
15715 
         *
15716 
         * @return void
15717 
         * @static
15718 
         */
15719 
        public static function flushMacros()
15720 
        {
15721 
                        \Illuminate\Filesystem\FilesystemAdapter::flushMacros();
15722 
        }
15723 
                    /**
15724 
         * Dynamically handle calls to the class.
15725 
         *
15726 
         * @param string $method
15727 
         * @param array $parameters
15728 
         * @return mixed
15729 
         * @throws \BadMethodCallException
15730 
         * @static
15731 
         */
15732 
        public static function macroCall($method, $parameters)
15733 
        {
15734 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15735 
                        return $instance->macroCall($method, $parameters);
15736 
        }
15737 
 
15738 
    }
15739 
            /**
15740 
     *
15741 
     *
15742 
     * @see \Illuminate\Routing\UrlGenerator
15743 
     */
15744 
        class URL {
15745 
                    /**
15746 
         * Get the full URL for the current request.
15747 
         *
15748 
         * @return string
15749 
         * @static
15750 
         */
15751 
        public static function full()
15752 
        {
15753 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15754 
                        return $instance->full();
15755 
        }
15756 
                    /**
15757 
         * Get the current URL for the request.
15758 
         *
15759 
         * @return string
15760 
         * @static
15761 
         */
15762 
        public static function current()
15763 
        {
15764 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15765 
                        return $instance->current();
15766 
        }
15767 
                    /**
15768 
         * Get the URL for the previous request.
15769 
         *
15770 
         * @param mixed $fallback
15771 
         * @return string
15772 
         * @static
15773 
         */
15774 
        public static function previous($fallback = false)
15775 
        {
15776 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15777 
                        return $instance->previous($fallback);
15778 
        }
15779 
                    /**
15780 
         * Get the previous path info for the request.
15781 
         *
15782 
         * @param mixed $fallback
15783 
         * @return string
15784 
         * @static
15785 
         */
15786 
        public static function previousPath($fallback = false)
15787 
        {
15788 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15789 
                        return $instance->previousPath($fallback);
15790 
        }
15791 
                    /**
15792 
         * Generate an absolute URL to the given path.
15793 
         *
15794 
         * @param string $path
15795 
         * @param mixed $extra
15796 
         * @param bool|null $secure
15797 
         * @return string
15798 
         * @static
15799 
         */
15800 
        public static function to($path, $extra = [], $secure = null)
15801 
        {
15802 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15803 
                        return $instance->to($path, $extra, $secure);
15804 
        }
15805 
                    /**
15806 
         * Generate a secure, absolute URL to the given path.
15807 
         *
15808 
         * @param string $path
15809 
         * @param array $parameters
15810 
         * @return string
15811 
         * @static
15812 
         */
15813 
        public static function secure($path, $parameters = [])
15814 
        {
15815 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15816 
                        return $instance->secure($path, $parameters);
15817 
        }
15818 
                    /**
15819 
         * Generate the URL to an application asset.
15820 
         *
15821 
         * @param string $path
15822 
         * @param bool|null $secure
15823 
         * @return string
15824 
         * @static
15825 
         */
15826 
        public static function asset($path, $secure = null)
15827 
        {
15828 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15829 
                        return $instance->asset($path, $secure);
15830 
        }
15831 
                    /**
15832 
         * Generate the URL to a secure asset.
15833 
         *
15834 
         * @param string $path
15835 
         * @return string
15836 
         * @static
15837 
         */
15838 
        public static function secureAsset($path)
15839 
        {
15840 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15841 
                        return $instance->secureAsset($path);
15842 
        }
15843 
                    /**
15844 
         * Generate the URL to an asset from a custom root domain such as CDN, etc.
15845 
         *
15846 
         * @param string $root
15847 
         * @param string $path
15848 
         * @param bool|null $secure
15849 
         * @return string
15850 
         * @static
15851 
         */
15852 
        public static function assetFrom($root, $path, $secure = null)
15853 
        {
15854 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15855 
                        return $instance->assetFrom($root, $path, $secure);
15856 
        }
15857 
                    /**
15858 
         * Get the default scheme for a raw URL.
15859 
         *
15860 
         * @param bool|null $secure
15861 
         * @return string
15862 
         * @static
15863 
         */
15864 
        public static function formatScheme($secure = null)
15865 
        {
15866 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15867 
                        return $instance->formatScheme($secure);
15868 
        }
15869 
                    /**
15870 
         * Create a signed route URL for a named route.
15871 
         *
15872 
         * @param string $name
15873 
         * @param mixed $parameters
15874 
         * @param \DateTimeInterface|\DateInterval|int|null $expiration
15875 
         * @param bool $absolute
15876 
         * @return string
15877 
         * @throws \InvalidArgumentException
15878 
         * @static
15879 
         */
15880 
        public static function signedRoute($name, $parameters = [], $expiration = null, $absolute = true)
15881 
        {
15882 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15883 
                        return $instance->signedRoute($name, $parameters, $expiration, $absolute);
15884 
        }
15885 
                    /**
15886 
         * Create a temporary signed route URL for a named route.
15887 
         *
15888 
         * @param string $name
15889 
         * @param \DateTimeInterface|\DateInterval|int $expiration
15890 
         * @param array $parameters
15891 
         * @param bool $absolute
15892 
         * @return string
15893 
         * @static
15894 
         */
15895 
        public static function temporarySignedRoute($name, $expiration, $parameters = [], $absolute = true)
15896 
        {
15897 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15898 
                        return $instance->temporarySignedRoute($name, $expiration, $parameters, $absolute);
15899 
        }
15900 
                    /**
15901 
         * Determine if the given request has a valid signature.
15902 
         *
15903 
         * @param \Illuminate\Http\Request $request
15904 
         * @param bool $absolute
15905 
         * @param array $ignoreQuery
15906 
         * @return bool
15907 
         * @static
15908 
         */
15909 
        public static function hasValidSignature($request, $absolute = true, $ignoreQuery = [])
15910 
        {
15911 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15912 
                        return $instance->hasValidSignature($request, $absolute, $ignoreQuery);
15913 
        }
15914 
                    /**
15915 
         * Determine if the given request has a valid signature for a relative URL.
15916 
         *
15917 
         * @param \Illuminate\Http\Request $request
15918 
         * @param array $ignoreQuery
15919 
         * @return bool
15920 
         * @static
15921 
         */
15922 
        public static function hasValidRelativeSignature($request, $ignoreQuery = [])
15923 
        {
15924 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15925 
                        return $instance->hasValidRelativeSignature($request, $ignoreQuery);
15926 
        }
15927 
                    /**
15928 
         * Determine if the signature from the given request matches the URL.
15929 
         *
15930 
         * @param \Illuminate\Http\Request $request
15931 
         * @param bool $absolute
15932 
         * @param array $ignoreQuery
15933 
         * @return bool
15934 
         * @static
15935 
         */
15936 
        public static function hasCorrectSignature($request, $absolute = true, $ignoreQuery = [])
15937 
        {
15938 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15939 
                        return $instance->hasCorrectSignature($request, $absolute, $ignoreQuery);
15940 
        }
15941 
                    /**
15942 
         * Determine if the expires timestamp from the given request is not from the past.
15943 
         *
15944 
         * @param \Illuminate\Http\Request $request
15945 
         * @return bool
15946 
         * @static
15947 
         */
15948 
        public static function signatureHasNotExpired($request)
15949 
        {
15950 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15951 
                        return $instance->signatureHasNotExpired($request);
15952 
        }
15953 
                    /**
15954 
         * Get the URL to a named route.
15955 
         *
15956 
         * @param string $name
15957 
         * @param mixed $parameters
15958 
         * @param bool $absolute
15959 
         * @return string
15960 
         * @throws \Symfony\Component\Routing\Exception\RouteNotFoundException
15961 
         * @static
15962 
         */
15963 
        public static function route($name, $parameters = [], $absolute = true)
15964 
        {
15965 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15966 
                        return $instance->route($name, $parameters, $absolute);
15967 
        }
15968 
                    /**
15969 
         * Get the URL for a given route instance.
15970 
         *
15971 
         * @param \Illuminate\Routing\Route $route
15972 
         * @param mixed $parameters
15973 
         * @param bool $absolute
15974 
         * @return string
15975 
         * @throws \Illuminate\Routing\Exceptions\UrlGenerationException
15976 
         * @static
15977 
         */
15978 
        public static function toRoute($route, $parameters, $absolute)
15979 
        {
15980 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15981 
                        return $instance->toRoute($route, $parameters, $absolute);
15982 
        }
15983 
                    /**
15984 
         * Get the URL to a controller action.
15985 
         *
15986 
         * @param string|array $action
15987 
         * @param mixed $parameters
15988 
         * @param bool $absolute
15989 
         * @return string
15990 
         * @throws \InvalidArgumentException
15991 
         * @static
15992 
         */
15993 
        public static function action($action, $parameters = [], $absolute = true)
15994 
        {
15995 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15996 
                        return $instance->action($action, $parameters, $absolute);
15997 
        }
15998 
                    /**
15999 
         * Format the array of URL parameters.
16000 
         *
16001 
         * @param mixed|array $parameters
16002 
         * @return array
16003 
         * @static
16004 
         */
16005 
        public static function formatParameters($parameters)
16006 
        {
16007 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16008 
                        return $instance->formatParameters($parameters);
16009 
        }
16010 
                    /**
16011 
         * Get the base URL for the request.
16012 
         *
16013 
         * @param string $scheme
16014 
         * @param string|null $root
16015 
         * @return string
16016 
         * @static
16017 
         */
16018 
        public static function formatRoot($scheme, $root = null)
16019 
        {
16020 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16021 
                        return $instance->formatRoot($scheme, $root);
16022 
        }
16023 
                    /**
16024 
         * Format the given URL segments into a single URL.
16025 
         *
16026 
         * @param string $root
16027 
         * @param string $path
16028 
         * @param \Illuminate\Routing\Route|null $route
16029 
         * @return string
16030 
         * @static
16031 
         */
16032 
        public static function format($root, $path, $route = null)
16033 
        {
16034 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16035 
                        return $instance->format($root, $path, $route);
16036 
        }
16037 
                    /**
16038 
         * Determine if the given path is a valid URL.
16039 
         *
16040 
         * @param string $path
16041 
         * @return bool
16042 
         * @static
16043 
         */
16044 
        public static function isValidUrl($path)
16045 
        {
16046 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16047 
                        return $instance->isValidUrl($path);
16048 
        }
16049 
                    /**
16050 
         * Set the default named parameters used by the URL generator.
16051 
         *
16052 
         * @param array $defaults
16053 
         * @return void
16054 
         * @static
16055 
         */
16056 
        public static function defaults($defaults)
16057 
        {
16058 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16059 
                        $instance->defaults($defaults);
16060 
        }
16061 
                    /**
16062 
         * Get the default named parameters used by the URL generator.
16063 
         *
16064 
         * @return array
16065 
         * @static
16066 
         */
16067 
        public static function getDefaultParameters()
16068 
        {
16069 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16070 
                        return $instance->getDefaultParameters();
16071 
        }
16072 
                    /**
16073 
         * Force the scheme for URLs.
16074 
         *
16075 
         * @param string|null $scheme
16076 
         * @return void
16077 
         * @static
16078 
         */
16079 
        public static function forceScheme($scheme)
16080 
        {
16081 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16082 
                        $instance->forceScheme($scheme);
16083 
        }
16084 
                    /**
16085 
         * Set the forced root URL.
16086 
         *
16087 
         * @param string|null $root
16088 
         * @return void
16089 
         * @static
16090 
         */
16091 
        public static function forceRootUrl($root)
16092 
        {
16093 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16094 
                        $instance->forceRootUrl($root);
16095 
        }
16096 
                    /**
16097 
         * Set a callback to be used to format the host of generated URLs.
16098 
         *
16099 
         * @param \Closure $callback
16100 
         * @return \Illuminate\Routing\UrlGenerator
16101 
         * @static
16102 
         */
16103 
        public static function formatHostUsing($callback)
16104 
        {
16105 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16106 
                        return $instance->formatHostUsing($callback);
16107 
        }
16108 
                    /**
16109 
         * Set a callback to be used to format the path of generated URLs.
16110 
         *
16111 
         * @param \Closure $callback
16112 
         * @return \Illuminate\Routing\UrlGenerator
16113 
         * @static
16114 
         */
16115 
        public static function formatPathUsing($callback)
16116 
        {
16117 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16118 
                        return $instance->formatPathUsing($callback);
16119 
        }
16120 
                    /**
16121 
         * Get the path formatter being used by the URL generator.
16122 
         *
16123 
         * @return \Closure
16124 
         * @static
16125 
         */
16126 
        public static function pathFormatter()
16127 
        {
16128 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16129 
                        return $instance->pathFormatter();
16130 
        }
16131 
                    /**
16132 
         * Get the request instance.
16133 
         *
16134 
         * @return \Illuminate\Http\Request
16135 
         * @static
16136 
         */
16137 
        public static function getRequest()
16138 
        {
16139 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16140 
                        return $instance->getRequest();
16141 
        }
16142 
                    /**
16143 
         * Set the current request instance.
16144 
         *
16145 
         * @param \Illuminate\Http\Request $request
16146 
         * @return void
16147 
         * @static
16148 
         */
16149 
        public static function setRequest($request)
16150 
        {
16151 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16152 
                        $instance->setRequest($request);
16153 
        }
16154 
                    /**
16155 
         * Set the route collection.
16156 
         *
16157 
         * @param \Illuminate\Routing\RouteCollectionInterface $routes
16158 
         * @return \Illuminate\Routing\UrlGenerator
16159 
         * @static
16160 
         */
16161 
        public static function setRoutes($routes)
16162 
        {
16163 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16164 
                        return $instance->setRoutes($routes);
16165 
        }
16166 
                    /**
16167 
         * Set the session resolver for the generator.
16168 
         *
16169 
         * @param callable $sessionResolver
16170 
         * @return \Illuminate\Routing\UrlGenerator
16171 
         * @static
16172 
         */
16173 
        public static function setSessionResolver($sessionResolver)
16174 
        {
16175 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16176 
                        return $instance->setSessionResolver($sessionResolver);
16177 
        }
16178 
                    /**
16179 
         * Set the encryption key resolver.
16180 
         *
16181 
         * @param callable $keyResolver
16182 
         * @return \Illuminate\Routing\UrlGenerator
16183 
         * @static
16184 
         */
16185 
        public static function setKeyResolver($keyResolver)
16186 
        {
16187 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16188 
                        return $instance->setKeyResolver($keyResolver);
16189 
        }
16190 
                    /**
16191 
         * Clone a new instance of the URL generator with a different encryption key resolver.
16192 
         *
16193 
         * @param callable $keyResolver
16194 
         * @return \Illuminate\Routing\UrlGenerator
16195 
         * @static
16196 
         */
16197 
        public static function withKeyResolver($keyResolver)
16198 
        {
16199 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16200 
                        return $instance->withKeyResolver($keyResolver);
16201 
        }
16202 
                    /**
16203 
         * Get the root controller namespace.
16204 
         *
16205 
         * @return string
16206 
         * @static
16207 
         */
16208 
        public static function getRootControllerNamespace()
16209 
        {
16210 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16211 
                        return $instance->getRootControllerNamespace();
16212 
        }
16213 
                    /**
16214 
         * Set the root controller namespace.
16215 
         *
16216 
         * @param string $rootNamespace
16217 
         * @return \Illuminate\Routing\UrlGenerator
16218 
         * @static
16219 
         */
16220 
        public static function setRootControllerNamespace($rootNamespace)
16221 
        {
16222 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16223 
                        return $instance->setRootControllerNamespace($rootNamespace);
16224 
        }
16225 
                    /**
16226 
         * Register a custom macro.
16227 
         *
16228 
         * @param string $name
16229 
         * @param object|callable $macro
16230 
         * @return void
16231 
         * @static
16232 
         */
16233 
        public static function macro($name, $macro)
16234 
        {
16235 
                        \Illuminate\Routing\UrlGenerator::macro($name, $macro);
16236 
        }
16237 
                    /**
16238 
         * Mix another object into the class.
16239 
         *
16240 
         * @param object $mixin
16241 
         * @param bool $replace
16242 
         * @return void
16243 
         * @throws \ReflectionException
16244 
         * @static
16245 
         */
16246 
        public static function mixin($mixin, $replace = true)
16247 
        {
16248 
                        \Illuminate\Routing\UrlGenerator::mixin($mixin, $replace);
16249 
        }
16250 
                    /**
16251 
         * Checks if macro is registered.
16252 
         *
16253 
         * @param string $name
16254 
         * @return bool
16255 
         * @static
16256 
         */
16257 
        public static function hasMacro($name)
16258 
        {
16259 
                        return \Illuminate\Routing\UrlGenerator::hasMacro($name);
16260 
        }
16261 
                    /**
16262 
         * Flush the existing macros.
16263 
         *
16264 
         * @return void
16265 
         * @static
16266 
         */
16267 
        public static function flushMacros()
16268 
        {
16269 
                        \Illuminate\Routing\UrlGenerator::flushMacros();
16270 
        }
16271 
 
16272 
    }
16273 
            /**
16274 
     *
16275 
     *
16276 
     * @see \Illuminate\Validation\Factory
16277 
     */
16278 
        class Validator {
16279 
                    /**
16280 
         * Create a new Validator instance.
16281 
         *
16282 
         * @param array $data
16283 
         * @param array $rules
16284 
         * @param array $messages
16285 
         * @param array $customAttributes
16286 
         * @return \Illuminate\Validation\Validator
16287 
         * @static
16288 
         */
16289 
        public static function make($data, $rules, $messages = [], $customAttributes = [])
16290 
        {
16291 
                        /** @var \Illuminate\Validation\Factory $instance */
16292 
                        return $instance->make($data, $rules, $messages, $customAttributes);
16293 
        }
16294 
                    /**
16295 
         * Validate the given data against the provided rules.
16296 
         *
16297 
         * @param array $data
16298 
         * @param array $rules
16299 
         * @param array $messages
16300 
         * @param array $customAttributes
16301 
         * @return array
16302 
         * @throws \Illuminate\Validation\ValidationException
16303 
         * @static
16304 
         */
16305 
        public static function validate($data, $rules, $messages = [], $customAttributes = [])
16306 
        {
16307 
                        /** @var \Illuminate\Validation\Factory $instance */
16308 
                        return $instance->validate($data, $rules, $messages, $customAttributes);
16309 
        }
16310 
                    /**
16311 
         * Register a custom validator extension.
16312 
         *
16313 
         * @param string $rule
16314 
         * @param \Closure|string $extension
16315 
         * @param string|null $message
16316 
         * @return void
16317 
         * @static
16318 
         */
16319 
        public static function extend($rule, $extension, $message = null)
16320 
        {
16321 
                        /** @var \Illuminate\Validation\Factory $instance */
16322 
                        $instance->extend($rule, $extension, $message);
16323 
        }
16324 
                    /**
16325 
         * Register a custom implicit validator extension.
16326 
         *
16327 
         * @param string $rule
16328 
         * @param \Closure|string $extension
16329 
         * @param string|null $message
16330 
         * @return void
16331 
         * @static
16332 
         */
16333 
        public static function extendImplicit($rule, $extension, $message = null)
16334 
        {
16335 
                        /** @var \Illuminate\Validation\Factory $instance */
16336 
                        $instance->extendImplicit($rule, $extension, $message);
16337 
        }
16338 
                    /**
16339 
         * Register a custom dependent validator extension.
16340 
         *
16341 
         * @param string $rule
16342 
         * @param \Closure|string $extension
16343 
         * @param string|null $message
16344 
         * @return void
16345 
         * @static
16346 
         */
16347 
        public static function extendDependent($rule, $extension, $message = null)
16348 
        {
16349 
                        /** @var \Illuminate\Validation\Factory $instance */
16350 
                        $instance->extendDependent($rule, $extension, $message);
16351 
        }
16352 
                    /**
16353 
         * Register a custom validator message replacer.
16354 
         *
16355 
         * @param string $rule
16356 
         * @param \Closure|string $replacer
16357 
         * @return void
16358 
         * @static
16359 
         */
16360 
        public static function replacer($rule, $replacer)
16361 
        {
16362 
                        /** @var \Illuminate\Validation\Factory $instance */
16363 
                        $instance->replacer($rule, $replacer);
16364 
        }
16365 
                    /**
16366 
         * Indicate that unvalidated array keys should be included in validated data when the parent array is validated.
16367 
         *
16368 
         * @return void
16369 
         * @static
16370 
         */
16371 
        public static function includeUnvalidatedArrayKeys()
16372 
        {
16373 
                        /** @var \Illuminate\Validation\Factory $instance */
16374 
                        $instance->includeUnvalidatedArrayKeys();
16375 
        }
16376 
                    /**
16377 
         * Indicate that unvalidated array keys should be excluded from the validated data, even if the parent array was validated.
16378 
         *
16379 
         * @return void
16380 
         * @static
16381 
         */
16382 
        public static function excludeUnvalidatedArrayKeys()
16383 
        {
16384 
                        /** @var \Illuminate\Validation\Factory $instance */
16385 
                        $instance->excludeUnvalidatedArrayKeys();
16386 
        }
16387 
                    /**
16388 
         * Set the Validator instance resolver.
16389 
         *
16390 
         * @param \Closure $resolver
16391 
         * @return void
16392 
         * @static
16393 
         */
16394 
        public static function resolver($resolver)
16395 
        {
16396 
                        /** @var \Illuminate\Validation\Factory $instance */
16397 
                        $instance->resolver($resolver);
16398 
        }
16399 
                    /**
16400 
         * Get the Translator implementation.
16401 
         *
16402 
         * @return \Illuminate\Contracts\Translation\Translator
16403 
         * @static
16404 
         */
16405 
        public static function getTranslator()
16406 
        {
16407 
                        /** @var \Illuminate\Validation\Factory $instance */
16408 
                        return $instance->getTranslator();
16409 
        }
16410 
                    /**
16411 
         * Get the Presence Verifier implementation.
16412 
         *
16413 
         * @return \Illuminate\Validation\PresenceVerifierInterface
16414 
         * @static
16415 
         */
16416 
        public static function getPresenceVerifier()
16417 
        {
16418 
                        /** @var \Illuminate\Validation\Factory $instance */
16419 
                        return $instance->getPresenceVerifier();
16420 
        }
16421 
                    /**
16422 
         * Set the Presence Verifier implementation.
16423 
         *
16424 
         * @param \Illuminate\Validation\PresenceVerifierInterface $presenceVerifier
16425 
         * @return void
16426 
         * @static
16427 
         */
16428 
        public static function setPresenceVerifier($presenceVerifier)
16429 
        {
16430 
                        /** @var \Illuminate\Validation\Factory $instance */
16431 
                        $instance->setPresenceVerifier($presenceVerifier);
16432 
        }
16433 
                    /**
16434 
         * Get the container instance used by the validation factory.
16435 
         *
16436 
         * @return \Illuminate\Contracts\Container\Container|null
16437 
         * @static
16438 
         */
16439 
        public static function getContainer()
16440 
        {
16441 
                        /** @var \Illuminate\Validation\Factory $instance */
16442 
                        return $instance->getContainer();
16443 
        }
16444 
                    /**
16445 
         * Set the container instance used by the validation factory.
16446 
         *
16447 
         * @param \Illuminate\Contracts\Container\Container $container
16448 
         * @return \Illuminate\Validation\Factory
16449 
         * @static
16450 
         */
16451 
        public static function setContainer($container)
16452 
        {
16453 
                        /** @var \Illuminate\Validation\Factory $instance */
16454 
                        return $instance->setContainer($container);
16455 
        }
16456 
 
16457 
    }
16458 
            /**
16459 
     *
16460 
     *
16461 
     * @see \Illuminate\View\Factory
16462 
     */
16463 
        class View {
16464 
                    /**
16465 
         * Get the evaluated view contents for the given view.
16466 
         *
16467 
         * @param string $path
16468 
         * @param \Illuminate\Contracts\Support\Arrayable|array $data
16469 
         * @param array $mergeData
16470 
         * @return \Illuminate\Contracts\View\View
16471 
         * @static
16472 
         */
16473 
        public static function file($path, $data = [], $mergeData = [])
16474 
        {
16475 
                        /** @var \Illuminate\View\Factory $instance */
16476 
                        return $instance->file($path, $data, $mergeData);
16477 
        }
16478 
                    /**
16479 
         * Get the evaluated view contents for the given view.
16480 
         *
16481 
         * @param string $view
16482 
         * @param \Illuminate\Contracts\Support\Arrayable|array $data
16483 
         * @param array $mergeData
16484 
         * @return \Illuminate\Contracts\View\View
16485 
         * @static
16486 
         */
16487 
        public static function make($view, $data = [], $mergeData = [])
16488 
        {
16489 
                        /** @var \Illuminate\View\Factory $instance */
16490 
                        return $instance->make($view, $data, $mergeData);
16491 
        }
16492 
                    /**
16493 
         * Get the first view that actually exists from the given list.
16494 
         *
16495 
         * @param array $views
16496 
         * @param \Illuminate\Contracts\Support\Arrayable|array $data
16497 
         * @param array $mergeData
16498 
         * @return \Illuminate\Contracts\View\View
16499 
         * @throws \InvalidArgumentException
16500 
         * @static
16501 
         */
16502 
        public static function first($views, $data = [], $mergeData = [])
16503 
        {
16504 
                        /** @var \Illuminate\View\Factory $instance */
16505 
                        return $instance->first($views, $data, $mergeData);
16506 
        }
16507 
                    /**
16508 
         * Get the rendered content of the view based on a given condition.
16509 
         *
16510 
         * @param bool $condition
16511 
         * @param string $view
16512 
         * @param \Illuminate\Contracts\Support\Arrayable|array $data
16513 
         * @param array $mergeData
16514 
         * @return string
16515 
         * @static
16516 
         */
16517 
        public static function renderWhen($condition, $view, $data = [], $mergeData = [])
16518 
        {
16519 
                        /** @var \Illuminate\View\Factory $instance */
16520 
                        return $instance->renderWhen($condition, $view, $data, $mergeData);
16521 
        }
16522 
                    /**
16523 
         * Get the rendered content of the view based on the negation of a given condition.
16524 
         *
16525 
         * @param bool $condition
16526 
         * @param string $view
16527 
         * @param \Illuminate\Contracts\Support\Arrayable|array $data
16528 
         * @param array $mergeData
16529 
         * @return string
16530 
         * @static
16531 
         */
16532 
        public static function renderUnless($condition, $view, $data = [], $mergeData = [])
16533 
        {
16534 
                        /** @var \Illuminate\View\Factory $instance */
16535 
                        return $instance->renderUnless($condition, $view, $data, $mergeData);
16536 
        }
16537 
                    /**
16538 
         * Get the rendered contents of a partial from a loop.
16539 
         *
16540 
         * @param string $view
16541 
         * @param array $data
16542 
         * @param string $iterator
16543 
         * @param string $empty
16544 
         * @return string
16545 
         * @static
16546 
         */
16547 
        public static function renderEach($view, $data, $iterator, $empty = 'raw|')
16548 
        {
16549 
                        /** @var \Illuminate\View\Factory $instance */
16550 
                        return $instance->renderEach($view, $data, $iterator, $empty);
16551 
        }
16552 
                    /**
16553 
         * Determine if a given view exists.
16554 
         *
16555 
         * @param string $view
16556 
         * @return bool
16557 
         * @static
16558 
         */
16559 
        public static function exists($view)
16560 
        {
16561 
                        /** @var \Illuminate\View\Factory $instance */
16562 
                        return $instance->exists($view);
16563 
        }
16564 
                    /**
16565 
         * Get the appropriate view engine for the given path.
16566 
         *
16567 
         * @param string $path
16568 
         * @return \Illuminate\Contracts\View\Engine
16569 
         * @throws \InvalidArgumentException
16570 
         * @static
16571 
         */
16572 
        public static function getEngineFromPath($path)
16573 
        {
16574 
                        /** @var \Illuminate\View\Factory $instance */
16575 
                        return $instance->getEngineFromPath($path);
16576 
        }
16577 
                    /**
16578 
         * Add a piece of shared data to the environment.
16579 
         *
16580 
         * @param array|string $key
16581 
         * @param mixed|null $value
16582 
         * @return mixed
16583 
         * @static
16584 
         */
16585 
        public static function share($key, $value = null)
16586 
        {
16587 
                        /** @var \Illuminate\View\Factory $instance */
16588 
                        return $instance->share($key, $value);
16589 
        }
16590 
                    /**
16591 
         * Increment the rendering counter.
16592 
         *
16593 
         * @return void
16594 
         * @static
16595 
         */
16596 
        public static function incrementRender()
16597 
        {
16598 
                        /** @var \Illuminate\View\Factory $instance */
16599 
                        $instance->incrementRender();
16600 
        }
16601 
                    /**
16602 
         * Decrement the rendering counter.
16603 
         *
16604 
         * @return void
16605 
         * @static
16606 
         */
16607 
        public static function decrementRender()
16608 
        {
16609 
                        /** @var \Illuminate\View\Factory $instance */
16610 
                        $instance->decrementRender();
16611 
        }
16612 
                    /**
16613 
         * Check if there are no active render operations.
16614 
         *
16615 
         * @return bool
16616 
         * @static
16617 
         */
16618 
        public static function doneRendering()
16619 
        {
16620 
                        /** @var \Illuminate\View\Factory $instance */
16621 
                        return $instance->doneRendering();
16622 
        }
16623 
                    /**
16624 
         * Determine if the given once token has been rendered.
16625 
         *
16626 
         * @param string $id
16627 
         * @return bool
16628 
         * @static
16629 
         */
16630 
        public static function hasRenderedOnce($id)
16631 
        {
16632 
                        /** @var \Illuminate\View\Factory $instance */
16633 
                        return $instance->hasRenderedOnce($id);
16634 
        }
16635 
                    /**
16636 
         * Mark the given once token as having been rendered.
16637 
         *
16638 
         * @param string $id
16639 
         * @return void
16640 
         * @static
16641 
         */
16642 
        public static function markAsRenderedOnce($id)
16643 
        {
16644 
                        /** @var \Illuminate\View\Factory $instance */
16645 
                        $instance->markAsRenderedOnce($id);
16646 
        }
16647 
                    /**
16648 
         * Add a location to the array of view locations.
16649 
         *
16650 
         * @param string $location
16651 
         * @return void
16652 
         * @static
16653 
         */
16654 
        public static function addLocation($location)
16655 
        {
16656 
                        /** @var \Illuminate\View\Factory $instance */
16657 
                        $instance->addLocation($location);
16658 
        }
16659 
                    /**
16660 
         * Add a new namespace to the loader.
16661 
         *
16662 
         * @param string $namespace
16663 
         * @param string|array $hints
16664 
         * @return \Illuminate\View\Factory
16665 
         * @static
16666 
         */
16667 
        public static function addNamespace($namespace, $hints)
16668 
        {
16669 
                        /** @var \Illuminate\View\Factory $instance */
16670 
                        return $instance->addNamespace($namespace, $hints);
16671 
        }
16672 
                    /**
16673 
         * Prepend a new namespace to the loader.
16674 
         *
16675 
         * @param string $namespace
16676 
         * @param string|array $hints
16677 
         * @return \Illuminate\View\Factory
16678 
         * @static
16679 
         */
16680 
        public static function prependNamespace($namespace, $hints)
16681 
        {
16682 
                        /** @var \Illuminate\View\Factory $instance */
16683 
                        return $instance->prependNamespace($namespace, $hints);
16684 
        }
16685 
                    /**
16686 
         * Replace the namespace hints for the given namespace.
16687 
         *
16688 
         * @param string $namespace
16689 
         * @param string|array $hints
16690 
         * @return \Illuminate\View\Factory
16691 
         * @static
16692 
         */
16693 
        public static function replaceNamespace($namespace, $hints)
16694 
        {
16695 
                        /** @var \Illuminate\View\Factory $instance */
16696 
                        return $instance->replaceNamespace($namespace, $hints);
16697 
        }
16698 
                    /**
16699 
         * Register a valid view extension and its engine.
16700 
         *
16701 
         * @param string $extension
16702 
         * @param string $engine
16703 
         * @param \Closure|null $resolver
16704 
         * @return void
16705 
         * @static
16706 
         */
16707 
        public static function addExtension($extension, $engine, $resolver = null)
16708 
        {
16709 
                        /** @var \Illuminate\View\Factory $instance */
16710 
                        $instance->addExtension($extension, $engine, $resolver);
16711 
        }
16712 
                    /**
16713 
         * Flush all of the factory state like sections and stacks.
16714 
         *
16715 
         * @return void
16716 
         * @static
16717 
         */
16718 
        public static function flushState()
16719 
        {
16720 
                        /** @var \Illuminate\View\Factory $instance */
16721 
                        $instance->flushState();
16722 
        }
16723 
                    /**
16724 
         * Flush all of the section contents if done rendering.
16725 
         *
16726 
         * @return void
16727 
         * @static
16728 
         */
16729 
        public static function flushStateIfDoneRendering()
16730 
        {
16731 
                        /** @var \Illuminate\View\Factory $instance */
16732 
                        $instance->flushStateIfDoneRendering();
16733 
        }
16734 
                    /**
16735 
         * Get the extension to engine bindings.
16736 
         *
16737 
         * @return array
16738 
         * @static
16739 
         */
16740 
        public static function getExtensions()
16741 
        {
16742 
                        /** @var \Illuminate\View\Factory $instance */
16743 
                        return $instance->getExtensions();
16744 
        }
16745 
                    /**
16746 
         * Get the engine resolver instance.
16747 
         *
16748 
         * @return \Illuminate\View\Engines\EngineResolver
16749 
         * @static
16750 
         */
16751 
        public static function getEngineResolver()
16752 
        {
16753 
                        /** @var \Illuminate\View\Factory $instance */
16754 
                        return $instance->getEngineResolver();
16755 
        }
16756 
                    /**
16757 
         * Get the view finder instance.
16758 
         *
16759 
         * @return \Illuminate\View\ViewFinderInterface
16760 
         * @static
16761 
         */
16762 
        public static function getFinder()
16763 
        {
16764 
                        /** @var \Illuminate\View\Factory $instance */
16765 
                        return $instance->getFinder();
16766 
        }
16767 
                    /**
16768 
         * Set the view finder instance.
16769 
         *
16770 
         * @param \Illuminate\View\ViewFinderInterface $finder
16771 
         * @return void
16772 
         * @static
16773 
         */
16774 
        public static function setFinder($finder)
16775 
        {
16776 
                        /** @var \Illuminate\View\Factory $instance */
16777 
                        $instance->setFinder($finder);
16778 
        }
16779 
                    /**
16780 
         * Flush the cache of views located by the finder.
16781 
         *
16782 
         * @return void
16783 
         * @static
16784 
         */
16785 
        public static function flushFinderCache()
16786 
        {
16787 
                        /** @var \Illuminate\View\Factory $instance */
16788 
                        $instance->flushFinderCache();
16789 
        }
16790 
                    /**
16791 
         * Get the event dispatcher instance.
16792 
         *
16793 
         * @return \Illuminate\Contracts\Events\Dispatcher
16794 
         * @static
16795 
         */
16796 
        public static function getDispatcher()
16797 
        {
16798 
                        /** @var \Illuminate\View\Factory $instance */
16799 
                        return $instance->getDispatcher();
16800 
        }
16801 
                    /**
16802 
         * Set the event dispatcher instance.
16803 
         *
16804 
         * @param \Illuminate\Contracts\Events\Dispatcher $events
16805 
         * @return void
16806 
         * @static
16807 
         */
16808 
        public static function setDispatcher($events)
16809 
        {
16810 
                        /** @var \Illuminate\View\Factory $instance */
16811 
                        $instance->setDispatcher($events);
16812 
        }
16813 
                    /**
16814 
         * Get the IoC container instance.
16815 
         *
16816 
         * @return \Illuminate\Contracts\Container\Container
16817 
         * @static
16818 
         */
16819 
        public static function getContainer()
16820 
        {
16821 
                        /** @var \Illuminate\View\Factory $instance */
16822 
                        return $instance->getContainer();
16823 
        }
16824 
                    /**
16825 
         * Set the IoC container instance.
16826 
         *
16827 
         * @param \Illuminate\Contracts\Container\Container $container
16828 
         * @return void
16829 
         * @static
16830 
         */
16831 
        public static function setContainer($container)
16832 
        {
16833 
                        /** @var \Illuminate\View\Factory $instance */
16834 
                        $instance->setContainer($container);
16835 
        }
16836 
                    /**
16837 
         * Get an item from the shared data.
16838 
         *
16839 
         * @param string $key
16840 
         * @param mixed $default
16841 
         * @return mixed
16842 
         * @static
16843 
         */
16844 
        public static function shared($key, $default = null)
16845 
        {
16846 
                        /** @var \Illuminate\View\Factory $instance */
16847 
                        return $instance->shared($key, $default);
16848 
        }
16849 
                    /**
16850 
         * Get all of the shared data for the environment.
16851 
         *
16852 
         * @return array
16853 
         * @static
16854 
         */
16855 
        public static function getShared()
16856 
        {
16857 
                        /** @var \Illuminate\View\Factory $instance */
16858 
                        return $instance->getShared();
16859 
        }
16860 
                    /**
16861 
         * Register a custom macro.
16862 
         *
16863 
         * @param string $name
16864 
         * @param object|callable $macro
16865 
         * @return void
16866 
         * @static
16867 
         */
16868 
        public static function macro($name, $macro)
16869 
        {
16870 
                        \Illuminate\View\Factory::macro($name, $macro);
16871 
        }
16872 
                    /**
16873 
         * Mix another object into the class.
16874 
         *
16875 
         * @param object $mixin
16876 
         * @param bool $replace
16877 
         * @return void
16878 
         * @throws \ReflectionException
16879 
         * @static
16880 
         */
16881 
        public static function mixin($mixin, $replace = true)
16882 
        {
16883 
                        \Illuminate\View\Factory::mixin($mixin, $replace);
16884 
        }
16885 
                    /**
16886 
         * Checks if macro is registered.
16887 
         *
16888 
         * @param string $name
16889 
         * @return bool
16890 
         * @static
16891 
         */
16892 
        public static function hasMacro($name)
16893 
        {
16894 
                        return \Illuminate\View\Factory::hasMacro($name);
16895 
        }
16896 
                    /**
16897 
         * Flush the existing macros.
16898 
         *
16899 
         * @return void
16900 
         * @static
16901 
         */
16902 
        public static function flushMacros()
16903 
        {
16904 
                        \Illuminate\View\Factory::flushMacros();
16905 
        }
16906 
                    /**
16907 
         * Start a component rendering process.
16908 
         *
16909 
         * @param \Illuminate\Contracts\View\View|\Illuminate\Contracts\Support\Htmlable|\Closure|string $view
16910 
         * @param array $data
16911 
         * @return void
16912 
         * @static
16913 
         */
16914 
        public static function startComponent($view, $data = [])
16915 
        {
16916 
                        /** @var \Illuminate\View\Factory $instance */
16917 
                        $instance->startComponent($view, $data);
16918 
        }
16919 
                    /**
16920 
         * Get the first view that actually exists from the given list, and start a component.
16921 
         *
16922 
         * @param array $names
16923 
         * @param array $data
16924 
         * @return void
16925 
         * @static
16926 
         */
16927 
        public static function startComponentFirst($names, $data = [])
16928 
        {
16929 
                        /** @var \Illuminate\View\Factory $instance */
16930 
                        $instance->startComponentFirst($names, $data);
16931 
        }
16932 
                    /**
16933 
         * Render the current component.
16934 
         *
16935 
         * @return string
16936 
         * @static
16937 
         */
16938 
        public static function renderComponent()
16939 
        {
16940 
                        /** @var \Illuminate\View\Factory $instance */
16941 
                        return $instance->renderComponent();
16942 
        }
16943 
                    /**
16944 
         * Get an item from the component data that exists above the current component.
16945 
         *
16946 
         * @param string $key
16947 
         * @param mixed $default
16948 
         * @return mixed|null
16949 
         * @static
16950 
         */
16951 
        public static function getConsumableComponentData($key, $default = null)
16952 
        {
16953 
                        /** @var \Illuminate\View\Factory $instance */
16954 
                        return $instance->getConsumableComponentData($key, $default);
16955 
        }
16956 
                    /**
16957 
         * Start the slot rendering process.
16958 
         *
16959 
         * @param string $name
16960 
         * @param string|null $content
16961 
         * @param array $attributes
16962 
         * @return void
16963 
         * @static
16964 
         */
16965 
        public static function slot($name, $content = null, $attributes = [])
16966 
        {
16967 
                        /** @var \Illuminate\View\Factory $instance */
16968 
                        $instance->slot($name, $content, $attributes);
16969 
        }
16970 
                    /**
16971 
         * Save the slot content for rendering.
16972 
         *
16973 
         * @return void
16974 
         * @static
16975 
         */
16976 
        public static function endSlot()
16977 
        {
16978 
                        /** @var \Illuminate\View\Factory $instance */
16979 
                        $instance->endSlot();
16980 
        }
16981 
                    /**
16982 
         * Register a view creator event.
16983 
         *
16984 
         * @param array|string $views
16985 
         * @param \Closure|string $callback
16986 
         * @return array
16987 
         * @static
16988 
         */
16989 
        public static function creator($views, $callback)
16990 
        {
16991 
                        /** @var \Illuminate\View\Factory $instance */
16992 
                        return $instance->creator($views, $callback);
16993 
        }
16994 
                    /**
16995 
         * Register multiple view composers via an array.
16996 
         *
16997 
         * @param array $composers
16998 
         * @return array
16999 
         * @static
17000 
         */
17001 
        public static function composers($composers)
17002 
        {
17003 
                        /** @var \Illuminate\View\Factory $instance */
17004 
                        return $instance->composers($composers);
17005 
        }
17006 
                    /**
17007 
         * Register a view composer event.
17008 
         *
17009 
         * @param array|string $views
17010 
         * @param \Closure|string $callback
17011 
         * @return array
17012 
         * @static
17013 
         */
17014 
        public static function composer($views, $callback)
17015 
        {
17016 
                        /** @var \Illuminate\View\Factory $instance */
17017 
                        return $instance->composer($views, $callback);
17018 
        }
17019 
                    /**
17020 
         * Call the composer for a given view.
17021 
         *
17022 
         * @param \Illuminate\Contracts\View\View $view
17023 
         * @return void
17024 
         * @static
17025 
         */
17026 
        public static function callComposer($view)
17027 
        {
17028 
                        /** @var \Illuminate\View\Factory $instance */
17029 
                        $instance->callComposer($view);
17030 
        }
17031 
                    /**
17032 
         * Call the creator for a given view.
17033 
         *
17034 
         * @param \Illuminate\Contracts\View\View $view
17035 
         * @return void
17036 
         * @static
17037 
         */
17038 
        public static function callCreator($view)
17039 
        {
17040 
                        /** @var \Illuminate\View\Factory $instance */
17041 
                        $instance->callCreator($view);
17042 
        }
17043 
                    /**
17044 
         * Start injecting content into a fragment.
17045 
         *
17046 
         * @param string $fragment
17047 
         * @return void
17048 
         * @static
17049 
         */
17050 
        public static function startFragment($fragment)
17051 
        {
17052 
                        /** @var \Illuminate\View\Factory $instance */
17053 
                        $instance->startFragment($fragment);
17054 
        }
17055 
                    /**
17056 
         * Stop injecting content into a fragment.
17057 
         *
17058 
         * @return string
17059 
         * @throws \InvalidArgumentException
17060 
         * @static
17061 
         */
17062 
        public static function stopFragment()
17063 
        {
17064 
                        /** @var \Illuminate\View\Factory $instance */
17065 
                        return $instance->stopFragment();
17066 
        }
17067 
                    /**
17068 
         * Get the contents of a fragment.
17069 
         *
17070 
         * @param string $name
17071 
         * @param string|null $default
17072 
         * @return mixed
17073 
         * @static
17074 
         */
17075 
        public static function getFragment($name, $default = null)
17076 
        {
17077 
                        /** @var \Illuminate\View\Factory $instance */
17078 
                        return $instance->getFragment($name, $default);
17079 
        }
17080 
                    /**
17081 
         * Get the entire array of rendered fragments.
17082 
         *
17083 
         * @return array
17084 
         * @static
17085 
         */
17086 
        public static function getFragments()
17087 
        {
17088 
                        /** @var \Illuminate\View\Factory $instance */
17089 
                        return $instance->getFragments();
17090 
        }
17091 
                    /**
17092 
         * Flush all of the fragments.
17093 
         *
17094 
         * @return void
17095 
         * @static
17096 
         */
17097 
        public static function flushFragments()
17098 
        {
17099 
                        /** @var \Illuminate\View\Factory $instance */
17100 
                        $instance->flushFragments();
17101 
        }
17102 
                    /**
17103 
         * Start injecting content into a section.
17104 
         *
17105 
         * @param string $section
17106 
         * @param string|null $content
17107 
         * @return void
17108 
         * @static
17109 
         */
17110 
        public static function startSection($section, $content = null)
17111 
        {
17112 
                        /** @var \Illuminate\View\Factory $instance */
17113 
                        $instance->startSection($section, $content);
17114 
        }
17115 
                    /**
17116 
         * Inject inline content into a section.
17117 
         *
17118 
         * @param string $section
17119 
         * @param string $content
17120 
         * @return void
17121 
         * @static
17122 
         */
17123 
        public static function inject($section, $content)
17124 
        {
17125 
                        /** @var \Illuminate\View\Factory $instance */
17126 
                        $instance->inject($section, $content);
17127 
        }
17128 
                    /**
17129 
         * Stop injecting content into a section and return its contents.
17130 
         *
17131 
         * @return string
17132 
         * @static
17133 
         */
17134 
        public static function yieldSection()
17135 
        {
17136 
                        /** @var \Illuminate\View\Factory $instance */
17137 
                        return $instance->yieldSection();
17138 
        }
17139 
                    /**
17140 
         * Stop injecting content into a section.
17141 
         *
17142 
         * @param bool $overwrite
17143 
         * @return string
17144 
         * @throws \InvalidArgumentException
17145 
         * @static
17146 
         */
17147 
        public static function stopSection($overwrite = false)
17148 
        {
17149 
                        /** @var \Illuminate\View\Factory $instance */
17150 
                        return $instance->stopSection($overwrite);
17151 
        }
17152 
                    /**
17153 
         * Stop injecting content into a section and append it.
17154 
         *
17155 
         * @return string
17156 
         * @throws \InvalidArgumentException
17157 
         * @static
17158 
         */
17159 
        public static function appendSection()
17160 
        {
17161 
                        /** @var \Illuminate\View\Factory $instance */
17162 
                        return $instance->appendSection();
17163 
        }
17164 
                    /**
17165 
         * Get the string contents of a section.
17166 
         *
17167 
         * @param string $section
17168 
         * @param string $default
17169 
         * @return string
17170 
         * @static
17171 
         */
17172 
        public static function yieldContent($section, $default = '')
17173 
        {
17174 
                        /** @var \Illuminate\View\Factory $instance */
17175 
                        return $instance->yieldContent($section, $default);
17176 
        }
17177 
                    /**
17178 
         * Get the parent placeholder for the current request.
17179 
         *
17180 
         * @param string $section
17181 
         * @return string
17182 
         * @static
17183 
         */
17184 
        public static function parentPlaceholder($section = '')
17185 
        {
17186 
                        return \Illuminate\View\Factory::parentPlaceholder($section);
17187 
        }
17188 
                    /**
17189 
         * Check if section exists.
17190 
         *
17191 
         * @param string $name
17192 
         * @return bool
17193 
         * @static
17194 
         */
17195 
        public static function hasSection($name)
17196 
        {
17197 
                        /** @var \Illuminate\View\Factory $instance */
17198 
                        return $instance->hasSection($name);
17199 
        }
17200 
                    /**
17201 
         * Check if section does not exist.
17202 
         *
17203 
         * @param string $name
17204 
         * @return bool
17205 
         * @static
17206 
         */
17207 
        public static function sectionMissing($name)
17208 
        {
17209 
                        /** @var \Illuminate\View\Factory $instance */
17210 
                        return $instance->sectionMissing($name);
17211 
        }
17212 
                    /**
17213 
         * Get the contents of a section.
17214 
         *
17215 
         * @param string $name
17216 
         * @param string|null $default
17217 
         * @return mixed
17218 
         * @static
17219 
         */
17220 
        public static function getSection($name, $default = null)
17221 
        {
17222 
                        /** @var \Illuminate\View\Factory $instance */
17223 
                        return $instance->getSection($name, $default);
17224 
        }
17225 
                    /**
17226 
         * Get the entire array of sections.
17227 
         *
17228 
         * @return array
17229 
         * @static
17230 
         */
17231 
        public static function getSections()
17232 
        {
17233 
                        /** @var \Illuminate\View\Factory $instance */
17234 
                        return $instance->getSections();
17235 
        }
17236 
                    /**
17237 
         * Flush all of the sections.
17238 
         *
17239 
         * @return void
17240 
         * @static
17241 
         */
17242 
        public static function flushSections()
17243 
        {
17244 
                        /** @var \Illuminate\View\Factory $instance */
17245 
                        $instance->flushSections();
17246 
        }
17247 
                    /**
17248 
         * Add new loop to the stack.
17249 
         *
17250 
         * @param \Countable|array $data
17251 
         * @return void
17252 
         * @static
17253 
         */
17254 
        public static function addLoop($data)
17255 
        {
17256 
                        /** @var \Illuminate\View\Factory $instance */
17257 
                        $instance->addLoop($data);
17258 
        }
17259 
                    /**
17260 
         * Increment the top loop's indices.
17261 
         *
17262 
         * @return void
17263 
         * @static
17264 
         */
17265 
        public static function incrementLoopIndices()
17266 
        {
17267 
                        /** @var \Illuminate\View\Factory $instance */
17268 
                        $instance->incrementLoopIndices();
17269 
        }
17270 
                    /**
17271 
         * Pop a loop from the top of the loop stack.
17272 
         *
17273 
         * @return void
17274 
         * @static
17275 
         */
17276 
        public static function popLoop()
17277 
        {
17278 
                        /** @var \Illuminate\View\Factory $instance */
17279 
                        $instance->popLoop();
17280 
        }
17281 
                    /**
17282 
         * Get an instance of the last loop in the stack.
17283 
         *
17284 
         * @return \stdClass|null
17285 
         * @static
17286 
         */
17287 
        public static function getLastLoop()
17288 
        {
17289 
                        /** @var \Illuminate\View\Factory $instance */
17290 
                        return $instance->getLastLoop();
17291 
        }
17292 
                    /**
17293 
         * Get the entire loop stack.
17294 
         *
17295 
         * @return array
17296 
         * @static
17297 
         */
17298 
        public static function getLoopStack()
17299 
        {
17300 
                        /** @var \Illuminate\View\Factory $instance */
17301 
                        return $instance->getLoopStack();
17302 
        }
17303 
                    /**
17304 
         * Start injecting content into a push section.
17305 
         *
17306 
         * @param string $section
17307 
         * @param string $content
17308 
         * @return void
17309 
         * @static
17310 
         */
17311 
        public static function startPush($section, $content = '')
17312 
        {
17313 
                        /** @var \Illuminate\View\Factory $instance */
17314 
                        $instance->startPush($section, $content);
17315 
        }
17316 
                    /**
17317 
         * Stop injecting content into a push section.
17318 
         *
17319 
         * @return string
17320 
         * @throws \InvalidArgumentException
17321 
         * @static
17322 
         */
17323 
        public static function stopPush()
17324 
        {
17325 
                        /** @var \Illuminate\View\Factory $instance */
17326 
                        return $instance->stopPush();
17327 
        }
17328 
                    /**
17329 
         * Start prepending content into a push section.
17330 
         *
17331 
         * @param string $section
17332 
         * @param string $content
17333 
         * @return void
17334 
         * @static
17335 
         */
17336 
        public static function startPrepend($section, $content = '')
17337 
        {
17338 
                        /** @var \Illuminate\View\Factory $instance */
17339 
                        $instance->startPrepend($section, $content);
17340 
        }
17341 
                    /**
17342 
         * Stop prepending content into a push section.
17343 
         *
17344 
         * @return string
17345 
         * @throws \InvalidArgumentException
17346 
         * @static
17347 
         */
17348 
        public static function stopPrepend()
17349 
        {
17350 
                        /** @var \Illuminate\View\Factory $instance */
17351 
                        return $instance->stopPrepend();
17352 
        }
17353 
                    /**
17354 
         * Get the string contents of a push section.
17355 
         *
17356 
         * @param string $section
17357 
         * @param string $default
17358 
         * @return string
17359 
         * @static
17360 
         */
17361 
        public static function yieldPushContent($section, $default = '')
17362 
        {
17363 
                        /** @var \Illuminate\View\Factory $instance */
17364 
                        return $instance->yieldPushContent($section, $default);
17365 
        }
17366 
                    /**
17367 
         * Flush all of the stacks.
17368 
         *
17369 
         * @return void
17370 
         * @static
17371 
         */
17372 
        public static function flushStacks()
17373 
        {
17374 
                        /** @var \Illuminate\View\Factory $instance */
17375 
                        $instance->flushStacks();
17376 
        }
17377 
                    /**
17378 
         * Start a translation block.
17379 
         *
17380 
         * @param array $replacements
17381 
         * @return void
17382 
         * @static
17383 
         */
17384 
        public static function startTranslation($replacements = [])
17385 
        {
17386 
                        /** @var \Illuminate\View\Factory $instance */
17387 
                        $instance->startTranslation($replacements);
17388 
        }
17389 
                    /**
17390 
         * Render the current translation.
17391 
         *
17392 
         * @return string
17393 
         * @static
17394 
         */
17395 
        public static function renderTranslation()
17396 
        {
17397 
                        /** @var \Illuminate\View\Factory $instance */
17398 
                        return $instance->renderTranslation();
17399 
        }
17400 
 
17401 
    }
17402 
            /**
17403 
     *
17404 
     *
17405 
     * @see \Illuminate\Foundation\Vite
17406 
     */
17407 
        class Vite {
17408 
                    /**
17409 
         * Get the preloaded assets.
17410 
         *
17411 
         * @return array
17412 
         * @static
17413 
         */
17414 
        public static function preloadedAssets()
17415 
        {
17416 
                        /** @var \Illuminate\Foundation\Vite $instance */
17417 
                        return $instance->preloadedAssets();
17418 
        }
17419 
                    /**
17420 
         * Get the Content Security Policy nonce applied to all generated tags.
17421 
         *
17422 
         * @return string|null
17423 
         * @static
17424 
         */
17425 
        public static function cspNonce()
17426 
        {
17427 
                        /** @var \Illuminate\Foundation\Vite $instance */
17428 
                        return $instance->cspNonce();
17429 
        }
17430 
                    /**
17431 
         * Generate or set a Content Security Policy nonce to apply to all generated tags.
17432 
         *
17433 
         * @param string|null $nonce
17434 
         * @return string
17435 
         * @static
17436 
         */
17437 
        public static function useCspNonce($nonce = null)
17438 
        {
17439 
                        /** @var \Illuminate\Foundation\Vite $instance */
17440 
                        return $instance->useCspNonce($nonce);
17441 
        }
17442 
                    /**
17443 
         * Use the given key to detect integrity hashes in the manifest.
17444 
         *
17445 
         * @param string|false $key
17446 
         * @return \Illuminate\Foundation\Vite
17447 
         * @static
17448 
         */
17449 
        public static function useIntegrityKey($key)
17450 
        {
17451 
                        /** @var \Illuminate\Foundation\Vite $instance */
17452 
                        return $instance->useIntegrityKey($key);
17453 
        }
17454 
                    /**
17455 
         * Set the Vite entry points.
17456 
         *
17457 
         * @param array $entryPoints
17458 
         * @return \Illuminate\Foundation\Vite
17459 
         * @static
17460 
         */
17461 
        public static function withEntryPoints($entryPoints)
17462 
        {
17463 
                        /** @var \Illuminate\Foundation\Vite $instance */
17464 
                        return $instance->withEntryPoints($entryPoints);
17465 
        }
17466 
                    /**
17467 
         * Set the filename for the manifest file.
17468 
         *
17469 
         * @param string $filename
17470 
         * @return \Illuminate\Foundation\Vite
17471 
         * @static
17472 
         */
17473 
        public static function useManifestFilename($filename)
17474 
        {
17475 
                        /** @var \Illuminate\Foundation\Vite $instance */
17476 
                        return $instance->useManifestFilename($filename);
17477 
        }
17478 
                    /**
17479 
         * Get the Vite "hot" file path.
17480 
         *
17481 
         * @return string
17482 
         * @static
17483 
         */
17484 
        public static function hotFile()
17485 
        {
17486 
                        /** @var \Illuminate\Foundation\Vite $instance */
17487 
                        return $instance->hotFile();
17488 
        }
17489 
                    /**
17490 
         * Set the Vite "hot" file path.
17491 
         *
17492 
         * @param string $path
17493 
         * @return \Illuminate\Foundation\Vite
17494 
         * @static
17495 
         */
17496 
        public static function useHotFile($path)
17497 
        {
17498 
                        /** @var \Illuminate\Foundation\Vite $instance */
17499 
                        return $instance->useHotFile($path);
17500 
        }
17501 
                    /**
17502 
         * Set the Vite build directory.
17503 
         *
17504 
         * @param string $path
17505 
         * @return \Illuminate\Foundation\Vite
17506 
         * @static
17507 
         */
17508 
        public static function useBuildDirectory($path)
17509 
        {
17510 
                        /** @var \Illuminate\Foundation\Vite $instance */
17511 
                        return $instance->useBuildDirectory($path);
17512 
        }
17513 
                    /**
17514 
         * Use the given callback to resolve attributes for script tags.
17515 
         *
17516 
         * @param \Illuminate\Foundation\(callable(string,  string, ?array, ?array): array)|array  $attributes
17517 
         * @return \Illuminate\Foundation\Vite
17518 
         * @static
17519 
         */
17520 
        public static function useScriptTagAttributes($attributes)
17521 
        {
17522 
                        /** @var \Illuminate\Foundation\Vite $instance */
17523 
                        return $instance->useScriptTagAttributes($attributes);
17524 
        }
17525 
                    /**
17526 
         * Use the given callback to resolve attributes for style tags.
17527 
         *
17528 
         * @param \Illuminate\Foundation\(callable(string,  string, ?array, ?array): array)|array  $attributes
17529 
         * @return \Illuminate\Foundation\Vite
17530 
         * @static
17531 
         */
17532 
        public static function useStyleTagAttributes($attributes)
17533 
        {
17534 
                        /** @var \Illuminate\Foundation\Vite $instance */
17535 
                        return $instance->useStyleTagAttributes($attributes);
17536 
        }
17537 
                    /**
17538 
         * Use the given callback to resolve attributes for preload tags.
17539 
         *
17540 
         * @param \Illuminate\Foundation\(callable(string,  string, ?array, ?array): (array|false))|array|false  $attributes
17541 
         * @return \Illuminate\Foundation\Vite
17542 
         * @static
17543 
         */
17544 
        public static function usePreloadTagAttributes($attributes)
17545 
        {
17546 
                        /** @var \Illuminate\Foundation\Vite $instance */
17547 
                        return $instance->usePreloadTagAttributes($attributes);
17548 
        }
17549 
                    /**
17550 
         * Generate React refresh runtime script.
17551 
         *
17552 
         * @return \Illuminate\Support\HtmlString|void
17553 
         * @static
17554 
         */
17555 
        public static function reactRefresh()
17556 
        {
17557 
                        /** @var \Illuminate\Foundation\Vite $instance */
17558 
                        return $instance->reactRefresh();
17559 
        }
17560 
                    /**
17561 
         * Get the URL for an asset.
17562 
         *
17563 
         * @param string $asset
17564 
         * @param string|null $buildDirectory
17565 
         * @return string
17566 
         * @static
17567 
         */
17568 
        public static function asset($asset, $buildDirectory = null)
17569 
        {
17570 
                        /** @var \Illuminate\Foundation\Vite $instance */
17571 
                        return $instance->asset($asset, $buildDirectory);
17572 
        }
17573 
                    /**
17574 
         * Get a unique hash representing the current manifest, or null if there is no manifest.
17575 
         *
17576 
         * @param string|null $buildDirectory
17577 
         * @return string|null
17578 
         * @static
17579 
         */
17580 
        public static function manifestHash($buildDirectory = null)
17581 
        {
17582 
                        /** @var \Illuminate\Foundation\Vite $instance */
17583 
                        return $instance->manifestHash($buildDirectory);
17584 
        }
17585 
                    /**
17586 
         * Determine if the HMR server is running.
17587 
         *
17588 
         * @return bool
17589 
         * @static
17590 
         */
17591 
        public static function isRunningHot()
17592 
        {
17593 
                        /** @var \Illuminate\Foundation\Vite $instance */
17594 
                        return $instance->isRunningHot();
17595 
        }
17596 
                    /**
17597 
         * Get the Vite tag content as a string of HTML.
17598 
         *
17599 
         * @return string
17600 
         * @static
17601 
         */
17602 
        public static function toHtml()
17603 
        {
17604 
                        /** @var \Illuminate\Foundation\Vite $instance */
17605 
                        return $instance->toHtml();
17606 
        }
17607 
                    /**
17608 
         * Register a custom macro.
17609 
         *
17610 
         * @param string $name
17611 
         * @param object|callable $macro
17612 
         * @return void
17613 
         * @static
17614 
         */
17615 
        public static function macro($name, $macro)
17616 
        {
17617 
                        \Illuminate\Foundation\Vite::macro($name, $macro);
17618 
        }
17619 
                    /**
17620 
         * Mix another object into the class.
17621 
         *
17622 
         * @param object $mixin
17623 
         * @param bool $replace
17624 
         * @return void
17625 
         * @throws \ReflectionException
17626 
         * @static
17627 
         */
17628 
        public static function mixin($mixin, $replace = true)
17629 
        {
17630 
                        \Illuminate\Foundation\Vite::mixin($mixin, $replace);
17631 
        }
17632 
                    /**
17633 
         * Checks if macro is registered.
17634 
         *
17635 
         * @param string $name
17636 
         * @return bool
17637 
         * @static
17638 
         */
17639 
        public static function hasMacro($name)
17640 
        {
17641 
                        return \Illuminate\Foundation\Vite::hasMacro($name);
17642 
        }
17643 
                    /**
17644 
         * Flush the existing macros.
17645 
         *
17646 
         * @return void
17647 
         * @static
17648 
         */
17649 
        public static function flushMacros()
17650 
        {
17651 
                        \Illuminate\Foundation\Vite::flushMacros();
17652 
        }
17653 
 
17654 
    }
17655 
 
17656 
}
17657 
 
17658 
    namespace Illuminate\Support {
17659 
            /**
17660 
     *
17661 
     *
17662 
     */
17663 
        class Arr {
17664 
 
17665 
    }
17666 
            /**
17667 
     *
17668 
     *
17669 
     */
17670 
        class Js {
17671 
 
17672 
    }
17673 
            /**
17674 
     *
17675 
     *
17676 
     */
17677 
        class Str {
17678 
 
17679 
    }
17680 
 
17681 
}
17682 
 
17683 
        namespace Srmklive\PayPal\Facades {
17684 
            /**
17685 
     *
17686 
     *
17687 
     */
17688 
        class PayPal {
17689 
                    /**
17690 
         * Get specific PayPal API provider object to use.
17691 
         *
17692 
         * @throws Exception
17693 
         * @return \Srmklive\PayPal\Services\PayPal
17694 
         * @static
17695 
         */
17696 
        public static function getProvider()
17697 
        {
17698 
                        return \Srmklive\PayPal\PayPalFacadeAccessor::getProvider();
17699 
        }
17700 
                    /**
17701 
         * Set PayPal API Client to use.
17702 
         *
17703 
         * @throws \Exception
17704 
         * @return \Srmklive\PayPal\Services\PayPal
17705 
         * @static
17706 
         */
17707 
        public static function setProvider()
17708 
        {
17709 
                        return \Srmklive\PayPal\PayPalFacadeAccessor::setProvider();
17710 
        }
17711 
 
17712 
    }
17713 
 
17714 
}
17715 
 
17716 
    namespace Clockwork\Support\Laravel {
17717 
            /**
17718 
     *
17719 
     *
17720 
     */
17721 
        class Facade {
17722 
                    /**
17723 
         *
17724 
         *
17725 
         * @static
17726 
         */
17727 
        public static function addDataSource($dataSource)
17728 
        {
17729 
                        /** @var \Clockwork\Clockwork $instance */
17730 
                        return $instance->addDataSource($dataSource);
17731 
        }
17732 
                    /**
17733 
         *
17734 
         *
17735 
         * @static
17736 
         */
17737 
        public static function resolveRequest()
17738 
        {
17739 
                        /** @var \Clockwork\Clockwork $instance */
17740 
                        return $instance->resolveRequest();
17741 
        }
17742 
                    /**
17743 
         *
17744 
         *
17745 
         * @static
17746 
         */
17747 
        public static function resolveAsCommand($name, $exitCode = null, $arguments = [], $options = [], $argumentsDefaults = [], $optionsDefaults = [], $output = null)
17748 
        {
17749 
                        /** @var \Clockwork\Clockwork $instance */
17750 
                        return $instance->resolveAsCommand($name, $exitCode, $arguments, $options, $argumentsDefaults, $optionsDefaults, $output);
17751 
        }
17752 
                    /**
17753 
         *
17754 
         *
17755 
         * @static
17756 
         */
17757 
        public static function resolveAsQueueJob($name, $description = null, $status = 'processed', $payload = [], $queue = null, $connection = null, $options = [])
17758 
        {
17759 
                        /** @var \Clockwork\Clockwork $instance */
17760 
                        return $instance->resolveAsQueueJob($name, $description, $status, $payload, $queue, $connection, $options);
17761 
        }
17762 
                    /**
17763 
         *
17764 
         *
17765 
         * @static
17766 
         */
17767 
        public static function resolveAsTest($name, $status = 'passed', $statusMessage = null, $asserts = [])
17768 
        {
17769 
                        /** @var \Clockwork\Clockwork $instance */
17770 
                        return $instance->resolveAsTest($name, $status, $statusMessage, $asserts);
17771 
        }
17772 
                    /**
17773 
         *
17774 
         *
17775 
         * @static
17776 
         */
17777 
        public static function extendRequest($request = null)
17778 
        {
17779 
                        /** @var \Clockwork\Clockwork $instance */
17780 
                        return $instance->extendRequest($request);
17781 
        }
17782 
                    /**
17783 
         *
17784 
         *
17785 
         * @static
17786 
         */
17787 
        public static function storeRequest()
17788 
        {
17789 
                        /** @var \Clockwork\Clockwork $instance */
17790 
                        return $instance->storeRequest();
17791 
        }
17792 
                    /**
17793 
         *
17794 
         *
17795 
         * @static
17796 
         */
17797 
        public static function reset()
17798 
        {
17799 
                        /** @var \Clockwork\Clockwork $instance */
17800 
                        return $instance->reset();
17801 
        }
17802 
                    /**
17803 
         *
17804 
         *
17805 
         * @static
17806 
         */
17807 
        public static function request($request = null)
17808 
        {
17809 
                        /** @var \Clockwork\Clockwork $instance */
17810 
                        return $instance->request($request);
17811 
        }
17812 
                    /**
17813 
         *
17814 
         *
17815 
         * @static
17816 
         */
17817 
        public static function log($level = null, $message = null, $context = [])
17818 
        {
17819 
                        /** @var \Clockwork\Clockwork $instance */
17820 
                        return $instance->log($level, $message, $context);
17821 
        }
17822 
                    /**
17823 
         *
17824 
         *
17825 
         * @static
17826 
         */
17827 
        public static function timeline()
17828 
        {
17829 
                        /** @var \Clockwork\Clockwork $instance */
17830 
                        return $instance->timeline();
17831 
        }
17832 
                    /**
17833 
         *
17834 
         *
17835 
         * @static
17836 
         */
17837 
        public static function event($description, $data = [])
17838 
        {
17839 
                        /** @var \Clockwork\Clockwork $instance */
17840 
                        return $instance->event($description, $data);
17841 
        }
17842 
                    /**
17843 
         *
17844 
         *
17845 
         * @static
17846 
         */
17847 
        public static function shouldCollect($shouldCollect = null)
17848 
        {
17849 
                        /** @var \Clockwork\Clockwork $instance */
17850 
                        return $instance->shouldCollect($shouldCollect);
17851 
        }
17852 
                    /**
17853 
         *
17854 
         *
17855 
         * @static
17856 
         */
17857 
        public static function shouldRecord($shouldRecord = null)
17858 
        {
17859 
                        /** @var \Clockwork\Clockwork $instance */
17860 
                        return $instance->shouldRecord($shouldRecord);
17861 
        }
17862 
                    /**
17863 
         *
17864 
         *
17865 
         * @static
17866 
         */
17867 
        public static function dataSources($dataSources = null)
17868 
        {
17869 
                        /** @var \Clockwork\Clockwork $instance */
17870 
                        return $instance->dataSources($dataSources);
17871 
        }
17872 
                    /**
17873 
         *
17874 
         *
17875 
         * @static
17876 
         */
17877 
        public static function storage($storage = null)
17878 
        {
17879 
                        /** @var \Clockwork\Clockwork $instance */
17880 
                        return $instance->storage($storage);
17881 
        }
17882 
                    /**
17883 
         *
17884 
         *
17885 
         * @static
17886 
         */
17887 
        public static function authenticator($authenticator = null)
17888 
        {
17889 
                        /** @var \Clockwork\Clockwork $instance */
17890 
                        return $instance->authenticator($authenticator);
17891 
        }
17892 
                    /**
17893 
         *
17894 
         *
17895 
         * @static
17896 
         */
17897 
        public static function getDataSources()
17898 
        {
17899 
                        /** @var \Clockwork\Clockwork $instance */
17900 
                        return $instance->getDataSources();
17901 
        }
17902 
                    /**
17903 
         *
17904 
         *
17905 
         * @static
17906 
         */
17907 
        public static function getRequest()
17908 
        {
17909 
                        /** @var \Clockwork\Clockwork $instance */
17910 
                        return $instance->getRequest();
17911 
        }
17912 
                    /**
17913 
         *
17914 
         *
17915 
         * @static
17916 
         */
17917 
        public static function setRequest($request)
17918 
        {
17919 
                        /** @var \Clockwork\Clockwork $instance */
17920 
                        return $instance->setRequest($request);
17921 
        }
17922 
                    /**
17923 
         *
17924 
         *
17925 
         * @static
17926 
         */
17927 
        public static function getStorage()
17928 
        {
17929 
                        /** @var \Clockwork\Clockwork $instance */
17930 
                        return $instance->getStorage();
17931 
        }
17932 
                    /**
17933 
         *
17934 
         *
17935 
         * @static
17936 
         */
17937 
        public static function setStorage($storage)
17938 
        {
17939 
                        /** @var \Clockwork\Clockwork $instance */
17940 
                        return $instance->setStorage($storage);
17941 
        }
17942 
                    /**
17943 
         *
17944 
         *
17945 
         * @static
17946 
         */
17947 
        public static function getAuthenticator()
17948 
        {
17949 
                        /** @var \Clockwork\Clockwork $instance */
17950 
                        return $instance->getAuthenticator();
17951 
        }
17952 
                    /**
17953 
         *
17954 
         *
17955 
         * @static
17956 
         */
17957 
        public static function setAuthenticator($authenticator)
17958 
        {
17959 
                        /** @var \Clockwork\Clockwork $instance */
17960 
                        return $instance->setAuthenticator($authenticator);
17961 
        }
17962 
 
17963 
    }
17964 
 
17965 
}
17966 
 
17967 
    namespace Spatie\LaravelIgnition\Facades {
17968 
            /**
17969 
     *
17970 
     *
17971 
     * @see \Spatie\FlareClient\Flare
17972 
     */
17973 
        class Flare {
17974 
                    /**
17975 
         *
17976 
         *
17977 
         * @static
17978 
         */
17979 
        public static function make($apiKey = null, $contextDetector = null)
17980 
        {
17981 
                        return \Spatie\FlareClient\Flare::make($apiKey, $contextDetector);
17982 
        }
17983 
                    /**
17984 
         *
17985 
         *
17986 
         * @static
17987 
         */
17988 
        public static function setApiToken($apiToken)
17989 
        {
17990 
                        /** @var \Spatie\FlareClient\Flare $instance */
17991 
                        return $instance->setApiToken($apiToken);
17992 
        }
17993 
                    /**
17994 
         *
17995 
         *
17996 
         * @static
17997 
         */
17998 
        public static function apiTokenSet()
17999 
        {
18000 
                        /** @var \Spatie\FlareClient\Flare $instance */
18001 
                        return $instance->apiTokenSet();
18002 
        }
18003 
                    /**
18004 
         *
18005 
         *
18006 
         * @static
18007 
         */
18008 
        public static function setBaseUrl($baseUrl)
18009 
        {
18010 
                        /** @var \Spatie\FlareClient\Flare $instance */
18011 
                        return $instance->setBaseUrl($baseUrl);
18012 
        }
18013 
                    /**
18014 
         *
18015 
         *
18016 
         * @static
18017 
         */
18018 
        public static function setStage($stage)
18019 
        {
18020 
                        /** @var \Spatie\FlareClient\Flare $instance */
18021 
                        return $instance->setStage($stage);
18022 
        }
18023 
                    /**
18024 
         *
18025 
         *
18026 
         * @static
18027 
         */
18028 
        public static function sendReportsImmediately()
18029 
        {
18030 
                        /** @var \Spatie\FlareClient\Flare $instance */
18031 
                        return $instance->sendReportsImmediately();
18032 
        }
18033 
                    /**
18034 
         *
18035 
         *
18036 
         * @static
18037 
         */
18038 
        public static function determineVersionUsing($determineVersionCallable)
18039 
        {
18040 
                        /** @var \Spatie\FlareClient\Flare $instance */
18041 
                        return $instance->determineVersionUsing($determineVersionCallable);
18042 
        }
18043 
                    /**
18044 
         *
18045 
         *
18046 
         * @static
18047 
         */
18048 
        public static function reportErrorLevels($reportErrorLevels)
18049 
        {
18050 
                        /** @var \Spatie\FlareClient\Flare $instance */
18051 
                        return $instance->reportErrorLevels($reportErrorLevels);
18052 
        }
18053 
                    /**
18054 
         *
18055 
         *
18056 
         * @static
18057 
         */
18058 
        public static function filterExceptionsUsing($filterExceptionsCallable)
18059 
        {
18060 
                        /** @var \Spatie\FlareClient\Flare $instance */
18061 
                        return $instance->filterExceptionsUsing($filterExceptionsCallable);
18062 
        }
18063 
                    /**
18064 
         *
18065 
         *
18066 
         * @static
18067 
         */
18068 
        public static function filterReportsUsing($filterReportsCallable)
18069 
        {
18070 
                        /** @var \Spatie\FlareClient\Flare $instance */
18071 
                        return $instance->filterReportsUsing($filterReportsCallable);
18072 
        }
18073 
                    /**
18074 
         *
18075 
         *
18076 
         * @static
18077 
         */
18078 
        public static function version()
18079 
        {
18080 
                        /** @var \Spatie\FlareClient\Flare $instance */
18081 
                        return $instance->version();
18082 
        }
18083 
                    /**
18084 
         *
18085 
         *
18086 
         * @return array<int, FlareMiddleware|class-string<FlareMiddleware>>
18087 
         * @static
18088 
         */
18089 
        public static function getMiddleware()
18090 
        {
18091 
                        /** @var \Spatie\FlareClient\Flare $instance */
18092 
                        return $instance->getMiddleware();
18093 
        }
18094 
                    /**
18095 
         *
18096 
         *
18097 
         * @static
18098 
         */
18099 
        public static function setContextProviderDetector($contextDetector)
18100 
        {
18101 
                        /** @var \Spatie\FlareClient\Flare $instance */
18102 
                        return $instance->setContextProviderDetector($contextDetector);
18103 
        }
18104 
                    /**
18105 
         *
18106 
         *
18107 
         * @static
18108 
         */
18109 
        public static function setContainer($container)
18110 
        {
18111 
                        /** @var \Spatie\FlareClient\Flare $instance */
18112 
                        return $instance->setContainer($container);
18113 
        }
18114 
                    /**
18115 
         *
18116 
         *
18117 
         * @static
18118 
         */
18119 
        public static function registerFlareHandlers()
18120 
        {
18121 
                        /** @var \Spatie\FlareClient\Flare $instance */
18122 
                        return $instance->registerFlareHandlers();
18123 
        }
18124 
                    /**
18125 
         *
18126 
         *
18127 
         * @static
18128 
         */
18129 
        public static function registerExceptionHandler()
18130 
        {
18131 
                        /** @var \Spatie\FlareClient\Flare $instance */
18132 
                        return $instance->registerExceptionHandler();
18133 
        }
18134 
                    /**
18135 
         *
18136 
         *
18137 
         * @static
18138 
         */
18139 
        public static function registerErrorHandler()
18140 
        {
18141 
                        /** @var \Spatie\FlareClient\Flare $instance */
18142 
                        return $instance->registerErrorHandler();
18143 
        }
18144 
                    /**
18145 
         *
18146 
         *
18147 
         * @param \Spatie\FlareClient\FlareMiddleware\FlareMiddleware|array<FlareMiddleware>|\Spatie\FlareClient\class-string<FlareMiddleware>|callable $middleware
18148 
         * @return \Spatie\FlareClient\Flare
18149 
         * @static
18150 
         */
18151 
        public static function registerMiddleware($middleware)
18152 
        {
18153 
                        /** @var \Spatie\FlareClient\Flare $instance */
18154 
                        return $instance->registerMiddleware($middleware);
18155 
        }
18156 
                    /**
18157 
         *
18158 
         *
18159 
         * @return array<int,FlareMiddleware|class-string<FlareMiddleware>>
18160 
         * @static
18161 
         */
18162 
        public static function getMiddlewares()
18163 
        {
18164 
                        /** @var \Spatie\FlareClient\Flare $instance */
18165 
                        return $instance->getMiddlewares();
18166 
        }
18167 
                    /**
18168 
         *
18169 
         *
18170 
         * @param string $name
18171 
         * @param string $messageLevel
18172 
         * @param \Spatie\FlareClient\array<int,  mixed> $metaData
18173 
         * @return \Spatie\FlareClient\Flare
18174 
         * @static
18175 
         */
18176 
        public static function glow($name, $messageLevel = 'info', $metaData = [])
18177 
        {
18178 
                        /** @var \Spatie\FlareClient\Flare $instance */
18179 
                        return $instance->glow($name, $messageLevel, $metaData);
18180 
        }
18181 
                    /**
18182 
         *
18183 
         *
18184 
         * @static
18185 
         */
18186 
        public static function handleException($throwable)
18187 
        {
18188 
                        /** @var \Spatie\FlareClient\Flare $instance */
18189 
                        return $instance->handleException($throwable);
18190 
        }
18191 
                    /**
18192 
         *
18193 
         *
18194 
         * @return mixed
18195 
         * @static
18196 
         */
18197 
        public static function handleError($code, $message, $file = '', $line = 0)
18198 
        {
18199 
                        /** @var \Spatie\FlareClient\Flare $instance */
18200 
                        return $instance->handleError($code, $message, $file, $line);
18201 
        }
18202 
                    /**
18203 
         *
18204 
         *
18205 
         * @static
18206 
         */
18207 
        public static function applicationPath($applicationPath)
18208 
        {
18209 
                        /** @var \Spatie\FlareClient\Flare $instance */
18210 
                        return $instance->applicationPath($applicationPath);
18211 
        }
18212 
                    /**
18213 
         *
18214 
         *
18215 
         * @static
18216 
         */
18217 
        public static function report($throwable, $callback = null, $report = null)
18218 
        {
18219 
                        /** @var \Spatie\FlareClient\Flare $instance */
18220 
                        return $instance->report($throwable, $callback, $report);
18221 
        }
18222 
                    /**
18223 
         *
18224 
         *
18225 
         * @static
18226 
         */
18227 
        public static function reportMessage($message, $logLevel, $callback = null)
18228 
        {
18229 
                        /** @var \Spatie\FlareClient\Flare $instance */
18230 
                        return $instance->reportMessage($message, $logLevel, $callback);
18231 
        }
18232 
                    /**
18233 
         *
18234 
         *
18235 
         * @static
18236 
         */
18237 
        public static function sendTestReport($throwable)
18238 
        {
18239 
                        /** @var \Spatie\FlareClient\Flare $instance */
18240 
                        return $instance->sendTestReport($throwable);
18241 
        }
18242 
                    /**
18243 
         *
18244 
         *
18245 
         * @static
18246 
         */
18247 
        public static function reset()
18248 
        {
18249 
                        /** @var \Spatie\FlareClient\Flare $instance */
18250 
                        return $instance->reset();
18251 
        }
18252 
                    /**
18253 
         *
18254 
         *
18255 
         * @static
18256 
         */
18257 
        public static function anonymizeIp()
18258 
        {
18259 
                        /** @var \Spatie\FlareClient\Flare $instance */
18260 
                        return $instance->anonymizeIp();
18261 
        }
18262 
                    /**
18263 
         *
18264 
         *
18265 
         * @param \Spatie\FlareClient\array<int,  string> $fieldNames
18266 
         * @return \Spatie\FlareClient\Flare
18267 
         * @static
18268 
         */
18269 
        public static function censorRequestBodyFields($fieldNames)
18270 
        {
18271 
                        /** @var \Spatie\FlareClient\Flare $instance */
18272 
                        return $instance->censorRequestBodyFields($fieldNames);
18273 
        }
18274 
                    /**
18275 
         *
18276 
         *
18277 
         * @static
18278 
         */
18279 
        public static function createReport($throwable)
18280 
        {
18281 
                        /** @var \Spatie\FlareClient\Flare $instance */
18282 
                        return $instance->createReport($throwable);
18283 
        }
18284 
                    /**
18285 
         *
18286 
         *
18287 
         * @static
18288 
         */
18289 
        public static function createReportFromMessage($message, $logLevel)
18290 
        {
18291 
                        /** @var \Spatie\FlareClient\Flare $instance */
18292 
                        return $instance->createReportFromMessage($message, $logLevel);
18293 
        }
18294 
                    /**
18295 
         *
18296 
         *
18297 
         * @static
18298 
         */
18299 
        public static function stage($stage)
18300 
        {
18301 
                        /** @var \Spatie\FlareClient\Flare $instance */
18302 
                        return $instance->stage($stage);
18303 
        }
18304 
                    /**
18305 
         *
18306 
         *
18307 
         * @static
18308 
         */
18309 
        public static function messageLevel($messageLevel)
18310 
        {
18311 
                        /** @var \Spatie\FlareClient\Flare $instance */
18312 
                        return $instance->messageLevel($messageLevel);
18313 
        }
18314 
                    /**
18315 
         *
18316 
         *
18317 
         * @param string $groupName
18318 
         * @param mixed $default
18319 
         * @return array<int, mixed>
18320 
         * @static
18321 
         */
18322 
        public static function getGroup($groupName = 'context', $default = [])
18323 
        {
18324 
                        /** @var \Spatie\FlareClient\Flare $instance */
18325 
                        return $instance->getGroup($groupName, $default);
18326 
        }
18327 
                    /**
18328 
         *
18329 
         *
18330 
         * @static
18331 
         */
18332 
        public static function context($key, $value)
18333 
        {
18334 
                        /** @var \Spatie\FlareClient\Flare $instance */
18335 
                        return $instance->context($key, $value);
18336 
        }
18337 
                    /**
18338 
         *
18339 
         *
18340 
         * @param string $groupName
18341 
         * @param \Spatie\FlareClient\array<string,  mixed> $properties
18342 
         * @return \Spatie\FlareClient\Flare
18343 
         * @static
18344 
         */
18345 
        public static function group($groupName, $properties)
18346 
        {
18347 
                        /** @var \Spatie\FlareClient\Flare $instance */
18348 
                        return $instance->group($groupName, $properties);
18349 
        }
18350 
 
18351 
    }
18352 
 
18353 
}
18354 
 
18355 
    namespace Illuminate\Http {
18356 
            /**
18357 
     *
18358 
     *
18359 
     */
18360 
        class Request {
18361 
                    /**
18362 
         *
18363 
         *
18364 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
18365 
         * @param array $rules
18366 
         * @param mixed $params
18367 
         * @static
18368 
         */
18369 
        public static function validate($rules, ...$params)
18370 
        {
18371 
                        return \Illuminate\Http\Request::validate($rules, ...$params);
18372 
        }
18373 
                    /**
18374 
         *
18375 
         *
18376 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
18377 
         * @param string $errorBag
18378 
         * @param array $rules
18379 
         * @param mixed $params
18380 
         * @static
18381 
         */
18382 
        public static function validateWithBag($errorBag, $rules, ...$params)
18383 
        {
18384 
                        return \Illuminate\Http\Request::validateWithBag($errorBag, $rules, ...$params);
18385 
        }
18386 
                    /**
18387 
         *
18388 
         *
18389 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
18390 
         * @param mixed $absolute
18391 
         * @static
18392 
         */
18393 
        public static function hasValidSignature($absolute = true)
18394 
        {
18395 
                        return \Illuminate\Http\Request::hasValidSignature($absolute);
18396 
        }
18397 
                    /**
18398 
         *
18399 
         *
18400 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
18401 
         * @static
18402 
         */
18403 
        public static function hasValidRelativeSignature()
18404 
        {
18405 
                        return \Illuminate\Http\Request::hasValidRelativeSignature();
18406 
        }
18407 
                    /**
18408 
         *
18409 
         *
18410 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
18411 
         * @param mixed $ignoreQuery
18412 
         * @param mixed $absolute
18413 
         * @static
18414 
         */
18415 
        public static function hasValidSignatureWhileIgnoring($ignoreQuery = [], $absolute = true)
18416 
        {
18417 
                        return \Illuminate\Http\Request::hasValidSignatureWhileIgnoring($ignoreQuery, $absolute);
18418 
        }
18419 
 
18420 
    }
18421 
 
18422 
}
18423 
 
18424 
 
18425 
namespace  {
18426 
            class App extends \Illuminate\Support\Facades\App {}
18427 
            class Arr extends \Illuminate\Support\Arr {}
18428 
            class Artisan extends \Illuminate\Support\Facades\Artisan {}
18429 
            class Auth extends \Illuminate\Support\Facades\Auth {}
18430 
            class Blade extends \Illuminate\Support\Facades\Blade {}
18431 
            class Broadcast extends \Illuminate\Support\Facades\Broadcast {}
18432 
            class Bus extends \Illuminate\Support\Facades\Bus {}
18433 
            class Cache extends \Illuminate\Support\Facades\Cache {}
18434 
            class Config extends \Illuminate\Support\Facades\Config {}
18435 
            class Cookie extends \Illuminate\Support\Facades\Cookie {}
18436 
            class Crypt extends \Illuminate\Support\Facades\Crypt {}
18437 
            class Date extends \Illuminate\Support\Facades\Date {}
18438 
            class DB extends \Illuminate\Support\Facades\DB {}
18439 
            class Eloquent extends \Illuminate\Database\Eloquent\Model {
18440 
                /**
18441 
             * Create and return an un-saved model instance.
18442 
             *
18443 
             * @param array $attributes
18444 
             * @return \Illuminate\Database\Eloquent\Model|static
18445 
             * @static
18446 
             */
18447 
            public static function make($attributes = [])
18448 
            {
18449 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18450 
                                return $instance->make($attributes);
18451 
            }
18452 
 
18453 
                /**
18454 
             * Register a new global scope.
18455 
             *
18456 
             * @param string $identifier
18457 
             * @param \Illuminate\Database\Eloquent\Scope|\Closure $scope
18458 
             * @return \Illuminate\Database\Eloquent\Builder|static
18459 
             * @static
18460 
             */
18461 
            public static function withGlobalScope($identifier, $scope)
18462 
            {
18463 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18464 
                                return $instance->withGlobalScope($identifier, $scope);
18465 
            }
18466 
 
18467 
                /**
18468 
             * Remove a registered global scope.
18469 
             *
18470 
             * @param \Illuminate\Database\Eloquent\Scope|string $scope
18471 
             * @return \Illuminate\Database\Eloquent\Builder|static
18472 
             * @static
18473 
             */
18474 
            public static function withoutGlobalScope($scope)
18475 
            {
18476 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18477 
                                return $instance->withoutGlobalScope($scope);
18478 
            }
18479 
 
18480 
                /**
18481 
             * Remove all or passed registered global scopes.
18482 
             *
18483 
             * @param array|null $scopes
18484 
             * @return \Illuminate\Database\Eloquent\Builder|static
18485 
             * @static
18486 
             */
18487 
            public static function withoutGlobalScopes($scopes = null)
18488 
            {
18489 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18490 
                                return $instance->withoutGlobalScopes($scopes);
18491 
            }
18492 
 
18493 
                /**
18494 
             * Get an array of global scopes that were removed from the query.
18495 
             *
18496 
             * @return array
18497 
             * @static
18498 
             */
18499 
            public static function removedScopes()
18500 
            {
18501 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18502 
                                return $instance->removedScopes();
18503 
            }
18504 
 
18505 
                /**
18506 
             * Add a where clause on the primary key to the query.
18507 
             *
18508 
             * @param mixed $id
18509 
             * @return \Illuminate\Database\Eloquent\Builder|static
18510 
             * @static
18511 
             */
18512 
            public static function whereKey($id)
18513 
            {
18514 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18515 
                                return $instance->whereKey($id);
18516 
            }
18517 
 
18518 
                /**
18519 
             * Add a where clause on the primary key to the query.
18520 
             *
18521 
             * @param mixed $id
18522 
             * @return \Illuminate\Database\Eloquent\Builder|static
18523 
             * @static
18524 
             */
18525 
            public static function whereKeyNot($id)
18526 
            {
18527 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18528 
                                return $instance->whereKeyNot($id);
18529 
            }
18530 
 
18531 
                /**
18532 
             * Add a basic where clause to the query.
18533 
             *
18534 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
18535 
             * @param mixed $operator
18536 
             * @param mixed $value
18537 
             * @param string $boolean
18538 
             * @return \Illuminate\Database\Eloquent\Builder|static
18539 
             * @static
18540 
             */
18541 
            public static function where($column, $operator = null, $value = null, $boolean = 'and')
18542 
            {
18543 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18544 
                                return $instance->where($column, $operator, $value, $boolean);
18545 
            }
18546 
 
18547 
                /**
18548 
             * Add a basic where clause to the query, and return the first result.
18549 
             *
18550 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
18551 
             * @param mixed $operator
18552 
             * @param mixed $value
18553 
             * @param string $boolean
18554 
             * @return \Illuminate\Database\Eloquent\Model|static|null
18555 
             * @static
18556 
             */
18557 
            public static function firstWhere($column, $operator = null, $value = null, $boolean = 'and')
18558 
            {
18559 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18560 
                                return $instance->firstWhere($column, $operator, $value, $boolean);
18561 
            }
18562 
 
18563 
                /**
18564 
             * Add an "or where" clause to the query.
18565 
             *
18566 
             * @param \Closure|array|string|\Illuminate\Database\Query\Expression $column
18567 
             * @param mixed $operator
18568 
             * @param mixed $value
18569 
             * @return \Illuminate\Database\Eloquent\Builder|static
18570 
             * @static
18571 
             */
18572 
            public static function orWhere($column, $operator = null, $value = null)
18573 
            {
18574 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18575 
                                return $instance->orWhere($column, $operator, $value);
18576 
            }
18577 
 
18578 
                /**
18579 
             * Add a basic "where not" clause to the query.
18580 
             *
18581 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
18582 
             * @param mixed $operator
18583 
             * @param mixed $value
18584 
             * @param string $boolean
18585 
             * @return \Illuminate\Database\Eloquent\Builder|static
18586 
             * @static
18587 
             */
18588 
            public static function whereNot($column, $operator = null, $value = null, $boolean = 'and')
18589 
            {
18590 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18591 
                                return $instance->whereNot($column, $operator, $value, $boolean);
18592 
            }
18593 
 
18594 
                /**
18595 
             * Add an "or where not" clause to the query.
18596 
             *
18597 
             * @param \Closure|array|string|\Illuminate\Database\Query\Expression $column
18598 
             * @param mixed $operator
18599 
             * @param mixed $value
18600 
             * @return \Illuminate\Database\Eloquent\Builder|static
18601 
             * @static
18602 
             */
18603 
            public static function orWhereNot($column, $operator = null, $value = null)
18604 
            {
18605 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18606 
                                return $instance->orWhereNot($column, $operator, $value);
18607 
            }
18608 
 
18609 
                /**
18610 
             * Add an "order by" clause for a timestamp to the query.
18611 
             *
18612 
             * @param string|\Illuminate\Database\Query\Expression $column
18613 
             * @return \Illuminate\Database\Eloquent\Builder|static
18614 
             * @static
18615 
             */
18616 
            public static function latest($column = null)
18617 
            {
18618 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18619 
                                return $instance->latest($column);
18620 
            }
18621 
 
18622 
                /**
18623 
             * Add an "order by" clause for a timestamp to the query.
18624 
             *
18625 
             * @param string|\Illuminate\Database\Query\Expression $column
18626 
             * @return \Illuminate\Database\Eloquent\Builder|static
18627 
             * @static
18628 
             */
18629 
            public static function oldest($column = null)
18630 
            {
18631 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18632 
                                return $instance->oldest($column);
18633 
            }
18634 
 
18635 
                /**
18636 
             * Create a collection of models from plain arrays.
18637 
             *
18638 
             * @param array $items
18639 
             * @return \Illuminate\Database\Eloquent\Collection
18640 
             * @static
18641 
             */
18642 
            public static function hydrate($items)
18643 
            {
18644 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18645 
                                return $instance->hydrate($items);
18646 
            }
18647 
 
18648 
                /**
18649 
             * Create a collection of models from a raw query.
18650 
             *
18651 
             * @param string $query
18652 
             * @param array $bindings
18653 
             * @return \Illuminate\Database\Eloquent\Collection
18654 
             * @static
18655 
             */
18656 
            public static function fromQuery($query, $bindings = [])
18657 
            {
18658 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18659 
                                return $instance->fromQuery($query, $bindings);
18660 
            }
18661 
 
18662 
                /**
18663 
             * Find a model by its primary key.
18664 
             *
18665 
             * @param mixed $id
18666 
             * @param array|string $columns
18667 
             * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static[]|static|null
18668 
             * @static
18669 
             */
18670 
            public static function find($id, $columns = [])
18671 
            {
18672 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18673 
                                return $instance->find($id, $columns);
18674 
            }
18675 
 
18676 
                /**
18677 
             * Find multiple models by their primary keys.
18678 
             *
18679 
             * @param \Illuminate\Contracts\Support\Arrayable|array $ids
18680 
             * @param array|string $columns
18681 
             * @return \Illuminate\Database\Eloquent\Collection
18682 
             * @static
18683 
             */
18684 
            public static function findMany($ids, $columns = [])
18685 
            {
18686 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18687 
                                return $instance->findMany($ids, $columns);
18688 
            }
18689 
 
18690 
                /**
18691 
             * Find a model by its primary key or throw an exception.
18692 
             *
18693 
             * @param mixed $id
18694 
             * @param array|string $columns
18695 
             * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static|static[]
18696 
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
18697 
             * @static
18698 
             */
18699 
            public static function findOrFail($id, $columns = [])
18700 
            {
18701 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18702 
                                return $instance->findOrFail($id, $columns);
18703 
            }
18704 
 
18705 
                /**
18706 
             * Find a model by its primary key or return fresh model instance.
18707 
             *
18708 
             * @param mixed $id
18709 
             * @param array|string $columns
18710 
             * @return \Illuminate\Database\Eloquent\Model|static
18711 
             * @static
18712 
             */
18713 
            public static function findOrNew($id, $columns = [])
18714 
            {
18715 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18716 
                                return $instance->findOrNew($id, $columns);
18717 
            }
18718 
 
18719 
                /**
18720 
             * Find a model by its primary key or call a callback.
18721 
             *
18722 
             * @param mixed $id
18723 
             * @param \Closure|array|string $columns
18724 
             * @param \Closure|null $callback
18725 
             * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static[]|static|mixed
18726 
             * @static
18727 
             */
18728 
            public static function findOr($id, $columns = [], $callback = null)
18729 
            {
18730 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18731 
                                return $instance->findOr($id, $columns, $callback);
18732 
            }
18733 
 
18734 
                /**
18735 
             * Get the first record matching the attributes or instantiate it.
18736 
             *
18737 
             * @param array $attributes
18738 
             * @param array $values
18739 
             * @return \Illuminate\Database\Eloquent\Model|static
18740 
             * @static
18741 
             */
18742 
            public static function firstOrNew($attributes = [], $values = [])
18743 
            {
18744 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18745 
                                return $instance->firstOrNew($attributes, $values);
18746 
            }
18747 
 
18748 
                /**
18749 
             * Get the first record matching the attributes or create it.
18750 
             *
18751 
             * @param array $attributes
18752 
             * @param array $values
18753 
             * @return \Illuminate\Database\Eloquent\Model|static
18754 
             * @static
18755 
             */
18756 
            public static function firstOrCreate($attributes = [], $values = [])
18757 
            {
18758 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18759 
                                return $instance->firstOrCreate($attributes, $values);
18760 
            }
18761 
 
18762 
                /**
18763 
             * Create or update a record matching the attributes, and fill it with values.
18764 
             *
18765 
             * @param array $attributes
18766 
             * @param array $values
18767 
             * @return \Illuminate\Database\Eloquent\Model|static
18768 
             * @static
18769 
             */
18770 
            public static function updateOrCreate($attributes, $values = [])
18771 
            {
18772 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18773 
                                return $instance->updateOrCreate($attributes, $values);
18774 
            }
18775 
 
18776 
                /**
18777 
             * Execute the query and get the first result or throw an exception.
18778 
             *
18779 
             * @param array|string $columns
18780 
             * @return \Illuminate\Database\Eloquent\Model|static
18781 
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
18782 
             * @static
18783 
             */
18784 
            public static function firstOrFail($columns = [])
18785 
            {
18786 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18787 
                                return $instance->firstOrFail($columns);
18788 
            }
18789 
 
18790 
                /**
18791 
             * Execute the query and get the first result or call a callback.
18792 
             *
18793 
             * @param \Closure|array|string $columns
18794 
             * @param \Closure|null $callback
18795 
             * @return \Illuminate\Database\Eloquent\Model|static|mixed
18796 
             * @static
18797 
             */
18798 
            public static function firstOr($columns = [], $callback = null)
18799 
            {
18800 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18801 
                                return $instance->firstOr($columns, $callback);
18802 
            }
18803 
 
18804 
                /**
18805 
             * Execute the query and get the first result if it's the sole matching record.
18806 
             *
18807 
             * @param array|string $columns
18808 
             * @return \Illuminate\Database\Eloquent\Model
18809 
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
18810 
             * @throws \Illuminate\Database\MultipleRecordsFoundException
18811 
             * @static
18812 
             */
18813 
            public static function sole($columns = [])
18814 
            {
18815 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18816 
                                return $instance->sole($columns);
18817 
            }
18818 
 
18819 
                /**
18820 
             * Get a single column's value from the first result of a query.
18821 
             *
18822 
             * @param string|\Illuminate\Database\Query\Expression $column
18823 
             * @return mixed
18824 
             * @static
18825 
             */
18826 
            public static function value($column)
18827 
            {
18828 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18829 
                                return $instance->value($column);
18830 
            }
18831 
 
18832 
                /**
18833 
             * Get a single column's value from the first result of a query if it's the sole matching record.
18834 
             *
18835 
             * @param string|\Illuminate\Database\Query\Expression $column
18836 
             * @return mixed
18837 
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
18838 
             * @throws \Illuminate\Database\MultipleRecordsFoundException
18839 
             * @static
18840 
             */
18841 
            public static function soleValue($column)
18842 
            {
18843 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18844 
                                return $instance->soleValue($column);
18845 
            }
18846 
 
18847 
                /**
18848 
             * Get a single column's value from the first result of the query or throw an exception.
18849 
             *
18850 
             * @param string|\Illuminate\Database\Query\Expression $column
18851 
             * @return mixed
18852 
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
18853 
             * @static
18854 
             */
18855 
            public static function valueOrFail($column)
18856 
            {
18857 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18858 
                                return $instance->valueOrFail($column);
18859 
            }
18860 
 
18861 
                /**
18862 
             * Execute the query as a "select" statement.
18863 
             *
18864 
             * @param array|string $columns
18865 
             * @return \Illuminate\Database\Eloquent\Collection|static[]
18866 
             * @static
18867 
             */
18868 
            public static function get($columns = [])
18869 
            {
18870 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18871 
                                return $instance->get($columns);
18872 
            }
18873 
 
18874 
                /**
18875 
             * Get the hydrated models without eager loading.
18876 
             *
18877 
             * @param array|string $columns
18878 
             * @return \Illuminate\Database\Eloquent\Model[]|static[]
18879 
             * @static
18880 
             */
18881 
            public static function getModels($columns = [])
18882 
            {
18883 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18884 
                                return $instance->getModels($columns);
18885 
            }
18886 
 
18887 
                /**
18888 
             * Eager load the relationships for the models.
18889 
             *
18890 
             * @param array $models
18891 
             * @return array
18892 
             * @static
18893 
             */
18894 
            public static function eagerLoadRelations($models)
18895 
            {
18896 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18897 
                                return $instance->eagerLoadRelations($models);
18898 
            }
18899 
 
18900 
                /**
18901 
             * Get a lazy collection for the given query.
18902 
             *
18903 
             * @return \Illuminate\Support\LazyCollection
18904 
             * @static
18905 
             */
18906 
            public static function cursor()
18907 
            {
18908 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18909 
                                return $instance->cursor();
18910 
            }
18911 
 
18912 
                /**
18913 
             * Get a collection with the values of a given column.
18914 
             *
18915 
             * @param string|\Illuminate\Database\Query\Expression $column
18916 
             * @param string|null $key
18917 
             * @return \Illuminate\Support\Collection
18918 
             * @static
18919 
             */
18920 
            public static function pluck($column, $key = null)
18921 
            {
18922 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18923 
                                return $instance->pluck($column, $key);
18924 
            }
18925 
 
18926 
                /**
18927 
             * Paginate the given query.
18928 
             *
18929 
             * @param int|null|\Closure $perPage
18930 
             * @param array|string $columns
18931 
             * @param string $pageName
18932 
             * @param int|null $page
18933 
             * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator
18934 
             * @throws \InvalidArgumentException
18935 
             * @static
18936 
             */
18937 
            public static function paginate($perPage = null, $columns = [], $pageName = 'page', $page = null)
18938 
            {
18939 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18940 
                                return $instance->paginate($perPage, $columns, $pageName, $page);
18941 
            }
18942 
 
18943 
                /**
18944 
             * Paginate the given query into a simple paginator.
18945 
             *
18946 
             * @param int|null $perPage
18947 
             * @param array|string $columns
18948 
             * @param string $pageName
18949 
             * @param int|null $page
18950 
             * @return \Illuminate\Contracts\Pagination\Paginator
18951 
             * @static
18952 
             */
18953 
            public static function simplePaginate($perPage = null, $columns = [], $pageName = 'page', $page = null)
18954 
            {
18955 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18956 
                                return $instance->simplePaginate($perPage, $columns, $pageName, $page);
18957 
            }
18958 
 
18959 
                /**
18960 
             * Paginate the given query into a cursor paginator.
18961 
             *
18962 
             * @param int|null $perPage
18963 
             * @param array|string $columns
18964 
             * @param string $cursorName
18965 
             * @param \Illuminate\Pagination\Cursor|string|null $cursor
18966 
             * @return \Illuminate\Contracts\Pagination\CursorPaginator
18967 
             * @static
18968 
             */
18969 
            public static function cursorPaginate($perPage = null, $columns = [], $cursorName = 'cursor', $cursor = null)
18970 
            {
18971 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18972 
                                return $instance->cursorPaginate($perPage, $columns, $cursorName, $cursor);
18973 
            }
18974 
 
18975 
                /**
18976 
             * Save a new model and return the instance.
18977 
             *
18978 
             * @param array $attributes
18979 
             * @return \Illuminate\Database\Eloquent\Model|$this
18980 
             * @static
18981 
             */
18982 
            public static function create($attributes = [])
18983 
            {
18984 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18985 
                                return $instance->create($attributes);
18986 
            }
18987 
 
18988 
                /**
18989 
             * Save a new model and return the instance. Allow mass-assignment.
18990 
             *
18991 
             * @param array $attributes
18992 
             * @return \Illuminate\Database\Eloquent\Model|$this
18993 
             * @static
18994 
             */
18995 
            public static function forceCreate($attributes)
18996 
            {
18997 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
18998 
                                return $instance->forceCreate($attributes);
18999 
            }
19000 
 
19001 
                /**
19002 
             * Insert new records or update the existing ones.
19003 
             *
19004 
             * @param array $values
19005 
             * @param array|string $uniqueBy
19006 
             * @param array|null $update
19007 
             * @return int
19008 
             * @static
19009 
             */
19010 
            public static function upsert($values, $uniqueBy, $update = null)
19011 
            {
19012 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19013 
                                return $instance->upsert($values, $uniqueBy, $update);
19014 
            }
19015 
 
19016 
                /**
19017 
             * Register a replacement for the default delete function.
19018 
             *
19019 
             * @param \Closure $callback
19020 
             * @return void
19021 
             * @static
19022 
             */
19023 
            public static function onDelete($callback)
19024 
            {
19025 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19026 
                                $instance->onDelete($callback);
19027 
            }
19028 
 
19029 
                /**
19030 
             * Call the given local model scopes.
19031 
             *
19032 
             * @param array|string $scopes
19033 
             * @return static|mixed
19034 
             * @static
19035 
             */
19036 
            public static function scopes($scopes)
19037 
            {
19038 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19039 
                                return $instance->scopes($scopes);
19040 
            }
19041 
 
19042 
                /**
19043 
             * Apply the scopes to the Eloquent builder instance and return it.
19044 
             *
19045 
             * @return static
19046 
             * @static
19047 
             */
19048 
            public static function applyScopes()
19049 
            {
19050 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19051 
                                return $instance->applyScopes();
19052 
            }
19053 
 
19054 
                /**
19055 
             * Prevent the specified relations from being eager loaded.
19056 
             *
19057 
             * @param mixed $relations
19058 
             * @return \Illuminate\Database\Eloquent\Builder|static
19059 
             * @static
19060 
             */
19061 
            public static function without($relations)
19062 
            {
19063 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19064 
                                return $instance->without($relations);
19065 
            }
19066 
 
19067 
                /**
19068 
             * Set the relationships that should be eager loaded while removing any previously added eager loading specifications.
19069 
             *
19070 
             * @param mixed $relations
19071 
             * @return \Illuminate\Database\Eloquent\Builder|static
19072 
             * @static
19073 
             */
19074 
            public static function withOnly($relations)
19075 
            {
19076 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19077 
                                return $instance->withOnly($relations);
19078 
            }
19079 
 
19080 
                /**
19081 
             * Create a new instance of the model being queried.
19082 
             *
19083 
             * @param array $attributes
19084 
             * @return \Illuminate\Database\Eloquent\Model|static
19085 
             * @static
19086 
             */
19087 
            public static function newModelInstance($attributes = [])
19088 
            {
19089 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19090 
                                return $instance->newModelInstance($attributes);
19091 
            }
19092 
 
19093 
                /**
19094 
             * Apply query-time casts to the model instance.
19095 
             *
19096 
             * @param array $casts
19097 
             * @return \Illuminate\Database\Eloquent\Builder|static
19098 
             * @static
19099 
             */
19100 
            public static function withCasts($casts)
19101 
            {
19102 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19103 
                                return $instance->withCasts($casts);
19104 
            }
19105 
 
19106 
                /**
19107 
             * Get the underlying query builder instance.
19108 
             *
19109 
             * @return \Illuminate\Database\Query\Builder
19110 
             * @static
19111 
             */
19112 
            public static function getQuery()
19113 
            {
19114 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19115 
                                return $instance->getQuery();
19116 
            }
19117 
 
19118 
                /**
19119 
             * Set the underlying query builder instance.
19120 
             *
19121 
             * @param \Illuminate\Database\Query\Builder $query
19122 
             * @return \Illuminate\Database\Eloquent\Builder|static
19123 
             * @static
19124 
             */
19125 
            public static function setQuery($query)
19126 
            {
19127 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19128 
                                return $instance->setQuery($query);
19129 
            }
19130 
 
19131 
                /**
19132 
             * Get a base query builder instance.
19133 
             *
19134 
             * @return \Illuminate\Database\Query\Builder
19135 
             * @static
19136 
             */
19137 
            public static function toBase()
19138 
            {
19139 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19140 
                                return $instance->toBase();
19141 
            }
19142 
 
19143 
                /**
19144 
             * Get the relationships being eagerly loaded.
19145 
             *
19146 
             * @return array
19147 
             * @static
19148 
             */
19149 
            public static function getEagerLoads()
19150 
            {
19151 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19152 
                                return $instance->getEagerLoads();
19153 
            }
19154 
 
19155 
                /**
19156 
             * Set the relationships being eagerly loaded.
19157 
             *
19158 
             * @param array $eagerLoad
19159 
             * @return \Illuminate\Database\Eloquent\Builder|static
19160 
             * @static
19161 
             */
19162 
            public static function setEagerLoads($eagerLoad)
19163 
            {
19164 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19165 
                                return $instance->setEagerLoads($eagerLoad);
19166 
            }
19167 
 
19168 
                /**
19169 
             * Indicate that the given relationships should not be eagerly loaded.
19170 
             *
19171 
             * @param array $relations
19172 
             * @return \Illuminate\Database\Eloquent\Builder|static
19173 
             * @static
19174 
             */
19175 
            public static function withoutEagerLoad($relations)
19176 
            {
19177 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19178 
                                return $instance->withoutEagerLoad($relations);
19179 
            }
19180 
 
19181 
                /**
19182 
             * Flush the relationships being eagerly loaded.
19183 
             *
19184 
             * @return \Illuminate\Database\Eloquent\Builder|static
19185 
             * @static
19186 
             */
19187 
            public static function withoutEagerLoads()
19188 
            {
19189 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19190 
                                return $instance->withoutEagerLoads();
19191 
            }
19192 
 
19193 
                /**
19194 
             * Get the model instance being queried.
19195 
             *
19196 
             * @return \Illuminate\Database\Eloquent\Model|static
19197 
             * @static
19198 
             */
19199 
            public static function getModel()
19200 
            {
19201 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19202 
                                return $instance->getModel();
19203 
            }
19204 
 
19205 
                /**
19206 
             * Set a model instance for the model being queried.
19207 
             *
19208 
             * @param \Illuminate\Database\Eloquent\Model $model
19209 
             * @return \Illuminate\Database\Eloquent\Builder|static
19210 
             * @static
19211 
             */
19212 
            public static function setModel($model)
19213 
            {
19214 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19215 
                                return $instance->setModel($model);
19216 
            }
19217 
 
19218 
                /**
19219 
             * Get the given macro by name.
19220 
             *
19221 
             * @param string $name
19222 
             * @return \Closure
19223 
             * @static
19224 
             */
19225 
            public static function getMacro($name)
19226 
            {
19227 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19228 
                                return $instance->getMacro($name);
19229 
            }
19230 
 
19231 
                /**
19232 
             * Checks if a macro is registered.
19233 
             *
19234 
             * @param string $name
19235 
             * @return bool
19236 
             * @static
19237 
             */
19238 
            public static function hasMacro($name)
19239 
            {
19240 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19241 
                                return $instance->hasMacro($name);
19242 
            }
19243 
 
19244 
                /**
19245 
             * Get the given global macro by name.
19246 
             *
19247 
             * @param string $name
19248 
             * @return \Closure
19249 
             * @static
19250 
             */
19251 
            public static function getGlobalMacro($name)
19252 
            {
19253 
                                return \Illuminate\Database\Eloquent\Builder::getGlobalMacro($name);
19254 
            }
19255 
 
19256 
                /**
19257 
             * Checks if a global macro is registered.
19258 
             *
19259 
             * @param string $name
19260 
             * @return bool
19261 
             * @static
19262 
             */
19263 
            public static function hasGlobalMacro($name)
19264 
            {
19265 
                                return \Illuminate\Database\Eloquent\Builder::hasGlobalMacro($name);
19266 
            }
19267 
 
19268 
                /**
19269 
             * Clone the Eloquent query builder.
19270 
             *
19271 
             * @return static
19272 
             * @static
19273 
             */
19274 
            public static function clone()
19275 
            {
19276 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19277 
                                return $instance->clone();
19278 
            }
19279 
 
19280 
                /**
19281 
             * Chunk the results of the query.
19282 
             *
19283 
             * @param int $count
19284 
             * @param callable $callback
19285 
             * @return bool
19286 
             * @static
19287 
             */
19288 
            public static function chunk($count, $callback)
19289 
            {
19290 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19291 
                                return $instance->chunk($count, $callback);
19292 
            }
19293 
 
19294 
                /**
19295 
             * Run a map over each item while chunking.
19296 
             *
19297 
             * @param callable $callback
19298 
             * @param int $count
19299 
             * @return \Illuminate\Support\Collection
19300 
             * @static
19301 
             */
19302 
            public static function chunkMap($callback, $count = 1000)
19303 
            {
19304 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19305 
                                return $instance->chunkMap($callback, $count);
19306 
            }
19307 
 
19308 
                /**
19309 
             * Execute a callback over each item while chunking.
19310 
             *
19311 
             * @param callable $callback
19312 
             * @param int $count
19313 
             * @return bool
19314 
             * @throws \RuntimeException
19315 
             * @static
19316 
             */
19317 
            public static function each($callback, $count = 1000)
19318 
            {
19319 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19320 
                                return $instance->each($callback, $count);
19321 
            }
19322 
 
19323 
                /**
19324 
             * Chunk the results of a query by comparing IDs.
19325 
             *
19326 
             * @param int $count
19327 
             * @param callable $callback
19328 
             * @param string|null $column
19329 
             * @param string|null $alias
19330 
             * @return bool
19331 
             * @static
19332 
             */
19333 
            public static function chunkById($count, $callback, $column = null, $alias = null)
19334 
            {
19335 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19336 
                                return $instance->chunkById($count, $callback, $column, $alias);
19337 
            }
19338 
 
19339 
                /**
19340 
             * Execute a callback over each item while chunking by ID.
19341 
             *
19342 
             * @param callable $callback
19343 
             * @param int $count
19344 
             * @param string|null $column
19345 
             * @param string|null $alias
19346 
             * @return bool
19347 
             * @static
19348 
             */
19349 
            public static function eachById($callback, $count = 1000, $column = null, $alias = null)
19350 
            {
19351 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19352 
                                return $instance->eachById($callback, $count, $column, $alias);
19353 
            }
19354 
 
19355 
                /**
19356 
             * Query lazily, by chunks of the given size.
19357 
             *
19358 
             * @param int $chunkSize
19359 
             * @return \Illuminate\Support\LazyCollection
19360 
             * @throws \InvalidArgumentException
19361 
             * @static
19362 
             */
19363 
            public static function lazy($chunkSize = 1000)
19364 
            {
19365 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19366 
                                return $instance->lazy($chunkSize);
19367 
            }
19368 
 
19369 
                /**
19370 
             * Query lazily, by chunking the results of a query by comparing IDs.
19371 
             *
19372 
             * @param int $chunkSize
19373 
             * @param string|null $column
19374 
             * @param string|null $alias
19375 
             * @return \Illuminate\Support\LazyCollection
19376 
             * @throws \InvalidArgumentException
19377 
             * @static
19378 
             */
19379 
            public static function lazyById($chunkSize = 1000, $column = null, $alias = null)
19380 
            {
19381 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19382 
                                return $instance->lazyById($chunkSize, $column, $alias);
19383 
            }
19384 
 
19385 
                /**
19386 
             * Query lazily, by chunking the results of a query by comparing IDs in descending order.
19387 
             *
19388 
             * @param int $chunkSize
19389 
             * @param string|null $column
19390 
             * @param string|null $alias
19391 
             * @return \Illuminate\Support\LazyCollection
19392 
             * @throws \InvalidArgumentException
19393 
             * @static
19394 
             */
19395 
            public static function lazyByIdDesc($chunkSize = 1000, $column = null, $alias = null)
19396 
            {
19397 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19398 
                                return $instance->lazyByIdDesc($chunkSize, $column, $alias);
19399 
            }
19400 
 
19401 
                /**
19402 
             * Execute the query and get the first result.
19403 
             *
19404 
             * @param array|string $columns
19405 
             * @return \Illuminate\Database\Eloquent\Model|object|static|null
19406 
             * @static
19407 
             */
19408 
            public static function first($columns = [])
19409 
            {
19410 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19411 
                                return $instance->first($columns);
19412 
            }
19413 
 
19414 
                /**
19415 
             * Execute the query and get the first result if it's the sole matching record.
19416 
             *
19417 
             * @param array|string $columns
19418 
             * @return \Illuminate\Database\Eloquent\Model|object|static|null
19419 
             * @throws \Illuminate\Database\RecordsNotFoundException
19420 
             * @throws \Illuminate\Database\MultipleRecordsFoundException
19421 
             * @static
19422 
             */
19423 
            public static function baseSole($columns = [])
19424 
            {
19425 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19426 
                                return $instance->baseSole($columns);
19427 
            }
19428 
 
19429 
                /**
19430 
             * Pass the query to a given callback.
19431 
             *
19432 
             * @param callable $callback
19433 
             * @return \Illuminate\Database\Eloquent\Builder|static
19434 
             * @static
19435 
             */
19436 
            public static function tap($callback)
19437 
            {
19438 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19439 
                                return $instance->tap($callback);
19440 
            }
19441 
 
19442 
                /**
19443 
             * Apply the callback if the given "value" is (or resolves to) truthy.
19444 
             *
19445 
             * @template TWhenParameter
19446 
             * @template TWhenReturnType
19447 
             * @param \Illuminate\Database\Eloquent\(\Closure($this):  TWhenParameter)|TWhenParameter|null  $value
19448 
             * @param \Illuminate\Database\Eloquent\(callable($this,  TWhenParameter): TWhenReturnType)|null  $callback
19449 
             * @param \Illuminate\Database\Eloquent\(callable($this,  TWhenParameter): TWhenReturnType)|null  $default
19450 
             * @return $this|\Illuminate\Database\Eloquent\TWhenReturnType
19451 
             * @static
19452 
             */
19453 
            public static function when($value = null, $callback = null, $default = null)
19454 
            {
19455 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19456 
                                return $instance->when($value, $callback, $default);
19457 
            }
19458 
 
19459 
                /**
19460 
             * Apply the callback if the given "value" is (or resolves to) falsy.
19461 
             *
19462 
             * @template TUnlessParameter
19463 
             * @template TUnlessReturnType
19464 
             * @param \Illuminate\Database\Eloquent\(\Closure($this):  TUnlessParameter)|TUnlessParameter|null  $value
19465 
             * @param \Illuminate\Database\Eloquent\(callable($this,  TUnlessParameter): TUnlessReturnType)|null  $callback
19466 
             * @param \Illuminate\Database\Eloquent\(callable($this,  TUnlessParameter): TUnlessReturnType)|null  $default
19467 
             * @return $this|\Illuminate\Database\Eloquent\TUnlessReturnType
19468 
             * @static
19469 
             */
19470 
            public static function unless($value = null, $callback = null, $default = null)
19471 
            {
19472 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19473 
                                return $instance->unless($value, $callback, $default);
19474 
            }
19475 
 
19476 
                /**
19477 
             * Add a relationship count / exists condition to the query.
19478 
             *
19479 
             * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation
19480 
             * @param string $operator
19481 
             * @param int $count
19482 
             * @param string $boolean
19483 
             * @param \Closure|null $callback
19484 
             * @return \Illuminate\Database\Eloquent\Builder|static
19485 
             * @throws \RuntimeException
19486 
             * @static
19487 
             */
19488 
            public static function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
19489 
            {
19490 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19491 
                                return $instance->has($relation, $operator, $count, $boolean, $callback);
19492 
            }
19493 
 
19494 
                /**
19495 
             * Add a relationship count / exists condition to the query with an "or".
19496 
             *
19497 
             * @param string $relation
19498 
             * @param string $operator
19499 
             * @param int $count
19500 
             * @return \Illuminate\Database\Eloquent\Builder|static
19501 
             * @static
19502 
             */
19503 
            public static function orHas($relation, $operator = '>=', $count = 1)
19504 
            {
19505 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19506 
                                return $instance->orHas($relation, $operator, $count);
19507 
            }
19508 
 
19509 
                /**
19510 
             * Add a relationship count / exists condition to the query.
19511 
             *
19512 
             * @param string $relation
19513 
             * @param string $boolean
19514 
             * @param \Closure|null $callback
19515 
             * @return \Illuminate\Database\Eloquent\Builder|static
19516 
             * @static
19517 
             */
19518 
            public static function doesntHave($relation, $boolean = 'and', $callback = null)
19519 
            {
19520 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19521 
                                return $instance->doesntHave($relation, $boolean, $callback);
19522 
            }
19523 
 
19524 
                /**
19525 
             * Add a relationship count / exists condition to the query with an "or".
19526 
             *
19527 
             * @param string $relation
19528 
             * @return \Illuminate\Database\Eloquent\Builder|static
19529 
             * @static
19530 
             */
19531 
            public static function orDoesntHave($relation)
19532 
            {
19533 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19534 
                                return $instance->orDoesntHave($relation);
19535 
            }
19536 
 
19537 
                /**
19538 
             * Add a relationship count / exists condition to the query with where clauses.
19539 
             *
19540 
             * @param string $relation
19541 
             * @param \Closure|null $callback
19542 
             * @param string $operator
19543 
             * @param int $count
19544 
             * @return \Illuminate\Database\Eloquent\Builder|static
19545 
             * @static
19546 
             */
19547 
            public static function whereHas($relation, $callback = null, $operator = '>=', $count = 1)
19548 
            {
19549 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19550 
                                return $instance->whereHas($relation, $callback, $operator, $count);
19551 
            }
19552 
 
19553 
                /**
19554 
             * Add a relationship count / exists condition to the query with where clauses.
19555 
             *
19556 
             * Also load the relationship with same condition.
19557 
             *
19558 
             * @param string $relation
19559 
             * @param \Closure|null $callback
19560 
             * @param string $operator
19561 
             * @param int $count
19562 
             * @return \Illuminate\Database\Eloquent\Builder|static
19563 
             * @static
19564 
             */
19565 
            public static function withWhereHas($relation, $callback = null, $operator = '>=', $count = 1)
19566 
            {
19567 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19568 
                                return $instance->withWhereHas($relation, $callback, $operator, $count);
19569 
            }
19570 
 
19571 
                /**
19572 
             * Add a relationship count / exists condition to the query with where clauses and an "or".
19573 
             *
19574 
             * @param string $relation
19575 
             * @param \Closure|null $callback
19576 
             * @param string $operator
19577 
             * @param int $count
19578 
             * @return \Illuminate\Database\Eloquent\Builder|static
19579 
             * @static
19580 
             */
19581 
            public static function orWhereHas($relation, $callback = null, $operator = '>=', $count = 1)
19582 
            {
19583 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19584 
                                return $instance->orWhereHas($relation, $callback, $operator, $count);
19585 
            }
19586 
 
19587 
                /**
19588 
             * Add a relationship count / exists condition to the query with where clauses.
19589 
             *
19590 
             * @param string $relation
19591 
             * @param \Closure|null $callback
19592 
             * @return \Illuminate\Database\Eloquent\Builder|static
19593 
             * @static
19594 
             */
19595 
            public static function whereDoesntHave($relation, $callback = null)
19596 
            {
19597 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19598 
                                return $instance->whereDoesntHave($relation, $callback);
19599 
            }
19600 
 
19601 
                /**
19602 
             * Add a relationship count / exists condition to the query with where clauses and an "or".
19603 
             *
19604 
             * @param string $relation
19605 
             * @param \Closure|null $callback
19606 
             * @return \Illuminate\Database\Eloquent\Builder|static
19607 
             * @static
19608 
             */
19609 
            public static function orWhereDoesntHave($relation, $callback = null)
19610 
            {
19611 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19612 
                                return $instance->orWhereDoesntHave($relation, $callback);
19613 
            }
19614 
 
19615 
                /**
19616 
             * Add a polymorphic relationship count / exists condition to the query.
19617 
             *
19618 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19619 
             * @param string|array $types
19620 
             * @param string $operator
19621 
             * @param int $count
19622 
             * @param string $boolean
19623 
             * @param \Closure|null $callback
19624 
             * @return \Illuminate\Database\Eloquent\Builder|static
19625 
             * @static
19626 
             */
19627 
            public static function hasMorph($relation, $types, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
19628 
            {
19629 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19630 
                                return $instance->hasMorph($relation, $types, $operator, $count, $boolean, $callback);
19631 
            }
19632 
 
19633 
                /**
19634 
             * Add a polymorphic relationship count / exists condition to the query with an "or".
19635 
             *
19636 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19637 
             * @param string|array $types
19638 
             * @param string $operator
19639 
             * @param int $count
19640 
             * @return \Illuminate\Database\Eloquent\Builder|static
19641 
             * @static
19642 
             */
19643 
            public static function orHasMorph($relation, $types, $operator = '>=', $count = 1)
19644 
            {
19645 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19646 
                                return $instance->orHasMorph($relation, $types, $operator, $count);
19647 
            }
19648 
 
19649 
                /**
19650 
             * Add a polymorphic relationship count / exists condition to the query.
19651 
             *
19652 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19653 
             * @param string|array $types
19654 
             * @param string $boolean
19655 
             * @param \Closure|null $callback
19656 
             * @return \Illuminate\Database\Eloquent\Builder|static
19657 
             * @static
19658 
             */
19659 
            public static function doesntHaveMorph($relation, $types, $boolean = 'and', $callback = null)
19660 
            {
19661 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19662 
                                return $instance->doesntHaveMorph($relation, $types, $boolean, $callback);
19663 
            }
19664 
 
19665 
                /**
19666 
             * Add a polymorphic relationship count / exists condition to the query with an "or".
19667 
             *
19668 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19669 
             * @param string|array $types
19670 
             * @return \Illuminate\Database\Eloquent\Builder|static
19671 
             * @static
19672 
             */
19673 
            public static function orDoesntHaveMorph($relation, $types)
19674 
            {
19675 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19676 
                                return $instance->orDoesntHaveMorph($relation, $types);
19677 
            }
19678 
 
19679 
                /**
19680 
             * Add a polymorphic relationship count / exists condition to the query with where clauses.
19681 
             *
19682 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19683 
             * @param string|array $types
19684 
             * @param \Closure|null $callback
19685 
             * @param string $operator
19686 
             * @param int $count
19687 
             * @return \Illuminate\Database\Eloquent\Builder|static
19688 
             * @static
19689 
             */
19690 
            public static function whereHasMorph($relation, $types, $callback = null, $operator = '>=', $count = 1)
19691 
            {
19692 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19693 
                                return $instance->whereHasMorph($relation, $types, $callback, $operator, $count);
19694 
            }
19695 
 
19696 
                /**
19697 
             * Add a polymorphic relationship count / exists condition to the query with where clauses and an "or".
19698 
             *
19699 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19700 
             * @param string|array $types
19701 
             * @param \Closure|null $callback
19702 
             * @param string $operator
19703 
             * @param int $count
19704 
             * @return \Illuminate\Database\Eloquent\Builder|static
19705 
             * @static
19706 
             */
19707 
            public static function orWhereHasMorph($relation, $types, $callback = null, $operator = '>=', $count = 1)
19708 
            {
19709 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19710 
                                return $instance->orWhereHasMorph($relation, $types, $callback, $operator, $count);
19711 
            }
19712 
 
19713 
                /**
19714 
             * Add a polymorphic relationship count / exists condition to the query with where clauses.
19715 
             *
19716 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19717 
             * @param string|array $types
19718 
             * @param \Closure|null $callback
19719 
             * @return \Illuminate\Database\Eloquent\Builder|static
19720 
             * @static
19721 
             */
19722 
            public static function whereDoesntHaveMorph($relation, $types, $callback = null)
19723 
            {
19724 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19725 
                                return $instance->whereDoesntHaveMorph($relation, $types, $callback);
19726 
            }
19727 
 
19728 
                /**
19729 
             * Add a polymorphic relationship count / exists condition to the query with where clauses and an "or".
19730 
             *
19731 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19732 
             * @param string|array $types
19733 
             * @param \Closure|null $callback
19734 
             * @return \Illuminate\Database\Eloquent\Builder|static
19735 
             * @static
19736 
             */
19737 
            public static function orWhereDoesntHaveMorph($relation, $types, $callback = null)
19738 
            {
19739 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19740 
                                return $instance->orWhereDoesntHaveMorph($relation, $types, $callback);
19741 
            }
19742 
 
19743 
                /**
19744 
             * Add a basic where clause to a relationship query.
19745 
             *
19746 
             * @param string $relation
19747 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
19748 
             * @param mixed $operator
19749 
             * @param mixed $value
19750 
             * @return \Illuminate\Database\Eloquent\Builder|static
19751 
             * @static
19752 
             */
19753 
            public static function whereRelation($relation, $column, $operator = null, $value = null)
19754 
            {
19755 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19756 
                                return $instance->whereRelation($relation, $column, $operator, $value);
19757 
            }
19758 
 
19759 
                /**
19760 
             * Add an "or where" clause to a relationship query.
19761 
             *
19762 
             * @param string $relation
19763 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
19764 
             * @param mixed $operator
19765 
             * @param mixed $value
19766 
             * @return \Illuminate\Database\Eloquent\Builder|static
19767 
             * @static
19768 
             */
19769 
            public static function orWhereRelation($relation, $column, $operator = null, $value = null)
19770 
            {
19771 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19772 
                                return $instance->orWhereRelation($relation, $column, $operator, $value);
19773 
            }
19774 
 
19775 
                /**
19776 
             * Add a polymorphic relationship condition to the query with a where clause.
19777 
             *
19778 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19779 
             * @param string|array $types
19780 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
19781 
             * @param mixed $operator
19782 
             * @param mixed $value
19783 
             * @return \Illuminate\Database\Eloquent\Builder|static
19784 
             * @static
19785 
             */
19786 
            public static function whereMorphRelation($relation, $types, $column, $operator = null, $value = null)
19787 
            {
19788 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19789 
                                return $instance->whereMorphRelation($relation, $types, $column, $operator, $value);
19790 
            }
19791 
 
19792 
                /**
19793 
             * Add a polymorphic relationship condition to the query with an "or where" clause.
19794 
             *
19795 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19796 
             * @param string|array $types
19797 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
19798 
             * @param mixed $operator
19799 
             * @param mixed $value
19800 
             * @return \Illuminate\Database\Eloquent\Builder|static
19801 
             * @static
19802 
             */
19803 
            public static function orWhereMorphRelation($relation, $types, $column, $operator = null, $value = null)
19804 
            {
19805 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19806 
                                return $instance->orWhereMorphRelation($relation, $types, $column, $operator, $value);
19807 
            }
19808 
 
19809 
                /**
19810 
             * Add a morph-to relationship condition to the query.
19811 
             *
19812 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19813 
             * @param \Illuminate\Database\Eloquent\Model|string $model
19814 
             * @return \Illuminate\Database\Eloquent\Builder|static
19815 
             * @static
19816 
             */
19817 
            public static function whereMorphedTo($relation, $model, $boolean = 'and')
19818 
            {
19819 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19820 
                                return $instance->whereMorphedTo($relation, $model, $boolean);
19821 
            }
19822 
 
19823 
                /**
19824 
             * Add a not morph-to relationship condition to the query.
19825 
             *
19826 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19827 
             * @param \Illuminate\Database\Eloquent\Model|string $model
19828 
             * @return \Illuminate\Database\Eloquent\Builder|static
19829 
             * @static
19830 
             */
19831 
            public static function whereNotMorphedTo($relation, $model, $boolean = 'and')
19832 
            {
19833 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19834 
                                return $instance->whereNotMorphedTo($relation, $model, $boolean);
19835 
            }
19836 
 
19837 
                /**
19838 
             * Add a morph-to relationship condition to the query with an "or where" clause.
19839 
             *
19840 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19841 
             * @param \Illuminate\Database\Eloquent\Model|string $model
19842 
             * @return \Illuminate\Database\Eloquent\Builder|static
19843 
             * @static
19844 
             */
19845 
            public static function orWhereMorphedTo($relation, $model)
19846 
            {
19847 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19848 
                                return $instance->orWhereMorphedTo($relation, $model);
19849 
            }
19850 
 
19851 
                /**
19852 
             * Add a not morph-to relationship condition to the query with an "or where" clause.
19853 
             *
19854 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
19855 
             * @param \Illuminate\Database\Eloquent\Model|string $model
19856 
             * @return \Illuminate\Database\Eloquent\Builder|static
19857 
             * @static
19858 
             */
19859 
            public static function orWhereNotMorphedTo($relation, $model)
19860 
            {
19861 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19862 
                                return $instance->orWhereNotMorphedTo($relation, $model);
19863 
            }
19864 
 
19865 
                /**
19866 
             * Add a "belongs to" relationship where clause to the query.
19867 
             *
19868 
             * @param \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection<\Illuminate\Database\Eloquent\Model> $related
19869 
             * @param string|null $relationshipName
19870 
             * @param string $boolean
19871 
             * @return \Illuminate\Database\Eloquent\Builder|static
19872 
             * @throws \Illuminate\Database\Eloquent\RelationNotFoundException
19873 
             * @static
19874 
             */
19875 
            public static function whereBelongsTo($related, $relationshipName = null, $boolean = 'and')
19876 
            {
19877 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19878 
                                return $instance->whereBelongsTo($related, $relationshipName, $boolean);
19879 
            }
19880 
 
19881 
                /**
19882 
             * Add an "BelongsTo" relationship with an "or where" clause to the query.
19883 
             *
19884 
             * @param \Illuminate\Database\Eloquent\Model $related
19885 
             * @param string|null $relationshipName
19886 
             * @return \Illuminate\Database\Eloquent\Builder|static
19887 
             * @throws \RuntimeException
19888 
             * @static
19889 
             */
19890 
            public static function orWhereBelongsTo($related, $relationshipName = null)
19891 
            {
19892 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19893 
                                return $instance->orWhereBelongsTo($related, $relationshipName);
19894 
            }
19895 
 
19896 
                /**
19897 
             * Add subselect queries to include an aggregate value for a relationship.
19898 
             *
19899 
             * @param mixed $relations
19900 
             * @param string $column
19901 
             * @param string $function
19902 
             * @return \Illuminate\Database\Eloquent\Builder|static
19903 
             * @static
19904 
             */
19905 
            public static function withAggregate($relations, $column, $function = null)
19906 
            {
19907 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19908 
                                return $instance->withAggregate($relations, $column, $function);
19909 
            }
19910 
 
19911 
                /**
19912 
             * Add subselect queries to count the relations.
19913 
             *
19914 
             * @param mixed $relations
19915 
             * @return \Illuminate\Database\Eloquent\Builder|static
19916 
             * @static
19917 
             */
19918 
            public static function withCount($relations)
19919 
            {
19920 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19921 
                                return $instance->withCount($relations);
19922 
            }
19923 
 
19924 
                /**
19925 
             * Add subselect queries to include the max of the relation's column.
19926 
             *
19927 
             * @param string|array $relation
19928 
             * @param string $column
19929 
             * @return \Illuminate\Database\Eloquent\Builder|static
19930 
             * @static
19931 
             */
19932 
            public static function withMax($relation, $column)
19933 
            {
19934 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19935 
                                return $instance->withMax($relation, $column);
19936 
            }
19937 
 
19938 
                /**
19939 
             * Add subselect queries to include the min of the relation's column.
19940 
             *
19941 
             * @param string|array $relation
19942 
             * @param string $column
19943 
             * @return \Illuminate\Database\Eloquent\Builder|static
19944 
             * @static
19945 
             */
19946 
            public static function withMin($relation, $column)
19947 
            {
19948 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19949 
                                return $instance->withMin($relation, $column);
19950 
            }
19951 
 
19952 
                /**
19953 
             * Add subselect queries to include the sum of the relation's column.
19954 
             *
19955 
             * @param string|array $relation
19956 
             * @param string $column
19957 
             * @return \Illuminate\Database\Eloquent\Builder|static
19958 
             * @static
19959 
             */
19960 
            public static function withSum($relation, $column)
19961 
            {
19962 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19963 
                                return $instance->withSum($relation, $column);
19964 
            }
19965 
 
19966 
                /**
19967 
             * Add subselect queries to include the average of the relation's column.
19968 
             *
19969 
             * @param string|array $relation
19970 
             * @param string $column
19971 
             * @return \Illuminate\Database\Eloquent\Builder|static
19972 
             * @static
19973 
             */
19974 
            public static function withAvg($relation, $column)
19975 
            {
19976 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19977 
                                return $instance->withAvg($relation, $column);
19978 
            }
19979 
 
19980 
                /**
19981 
             * Add subselect queries to include the existence of related models.
19982 
             *
19983 
             * @param string|array $relation
19984 
             * @return \Illuminate\Database\Eloquent\Builder|static
19985 
             * @static
19986 
             */
19987 
            public static function withExists($relation)
19988 
            {
19989 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19990 
                                return $instance->withExists($relation);
19991 
            }
19992 
 
19993 
                /**
19994 
             * Merge the where constraints from another query to the current query.
19995 
             *
19996 
             * @param \Illuminate\Database\Eloquent\Builder $from
19997 
             * @return \Illuminate\Database\Eloquent\Builder|static
19998 
             * @static
19999 
             */
20000 
            public static function mergeConstraintsFrom($from)
20001 
            {
20002 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20003 
                                return $instance->mergeConstraintsFrom($from);
20004 
            }
20005 
 
20006 
                /**
20007 
             * Set the columns to be selected.
20008 
             *
20009 
             * @param array|mixed $columns
20010 
             * @return \Illuminate\Database\Query\Builder
20011 
             * @static
20012 
             */
20013 
            public static function select($columns = [])
20014 
            {
20015 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20016 
                                return $instance->select($columns);
20017 
            }
20018 
 
20019 
                /**
20020 
             * Add a subselect expression to the query.
20021 
             *
20022 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20023 
             * @param string $as
20024 
             * @return \Illuminate\Database\Query\Builder
20025 
             * @throws \InvalidArgumentException
20026 
             * @static
20027 
             */
20028 
            public static function selectSub($query, $as)
20029 
            {
20030 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20031 
                                return $instance->selectSub($query, $as);
20032 
            }
20033 
 
20034 
                /**
20035 
             * Add a new "raw" select expression to the query.
20036 
             *
20037 
             * @param string $expression
20038 
             * @param array $bindings
20039 
             * @return \Illuminate\Database\Query\Builder
20040 
             * @static
20041 
             */
20042 
            public static function selectRaw($expression, $bindings = [])
20043 
            {
20044 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20045 
                                return $instance->selectRaw($expression, $bindings);
20046 
            }
20047 
 
20048 
                /**
20049 
             * Makes "from" fetch from a subquery.
20050 
             *
20051 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20052 
             * @param string $as
20053 
             * @return \Illuminate\Database\Query\Builder
20054 
             * @throws \InvalidArgumentException
20055 
             * @static
20056 
             */
20057 
            public static function fromSub($query, $as)
20058 
            {
20059 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20060 
                                return $instance->fromSub($query, $as);
20061 
            }
20062 
 
20063 
                /**
20064 
             * Add a raw from clause to the query.
20065 
             *
20066 
             * @param string $expression
20067 
             * @param mixed $bindings
20068 
             * @return \Illuminate\Database\Query\Builder
20069 
             * @static
20070 
             */
20071 
            public static function fromRaw($expression, $bindings = [])
20072 
            {
20073 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20074 
                                return $instance->fromRaw($expression, $bindings);
20075 
            }
20076 
 
20077 
                /**
20078 
             * Add a new select column to the query.
20079 
             *
20080 
             * @param array|mixed $column
20081 
             * @return \Illuminate\Database\Query\Builder
20082 
             * @static
20083 
             */
20084 
            public static function addSelect($column)
20085 
            {
20086 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20087 
                                return $instance->addSelect($column);
20088 
            }
20089 
 
20090 
                /**
20091 
             * Force the query to only return distinct results.
20092 
             *
20093 
             * @return \Illuminate\Database\Query\Builder
20094 
             * @static
20095 
             */
20096 
            public static function distinct()
20097 
            {
20098 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20099 
                                return $instance->distinct();
20100 
            }
20101 
 
20102 
                /**
20103 
             * Set the table which the query is targeting.
20104 
             *
20105 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $table
20106 
             * @param string|null $as
20107 
             * @return \Illuminate\Database\Query\Builder
20108 
             * @static
20109 
             */
20110 
            public static function from($table, $as = null)
20111 
            {
20112 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20113 
                                return $instance->from($table, $as);
20114 
            }
20115 
 
20116 
                /**
20117 
             * Add an index hint to suggest a query index.
20118 
             *
20119 
             * @param string $index
20120 
             * @return \Illuminate\Database\Query\Builder
20121 
             * @static
20122 
             */
20123 
            public static function useIndex($index)
20124 
            {
20125 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20126 
                                return $instance->useIndex($index);
20127 
            }
20128 
 
20129 
                /**
20130 
             * Add an index hint to force a query index.
20131 
             *
20132 
             * @param string $index
20133 
             * @return \Illuminate\Database\Query\Builder
20134 
             * @static
20135 
             */
20136 
            public static function forceIndex($index)
20137 
            {
20138 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20139 
                                return $instance->forceIndex($index);
20140 
            }
20141 
 
20142 
                /**
20143 
             * Add an index hint to ignore a query index.
20144 
             *
20145 
             * @param string $index
20146 
             * @return \Illuminate\Database\Query\Builder
20147 
             * @static
20148 
             */
20149 
            public static function ignoreIndex($index)
20150 
            {
20151 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20152 
                                return $instance->ignoreIndex($index);
20153 
            }
20154 
 
20155 
                /**
20156 
             * Add a join clause to the query.
20157 
             *
20158 
             * @param string $table
20159 
             * @param \Closure|string $first
20160 
             * @param string|null $operator
20161 
             * @param string|null $second
20162 
             * @param string $type
20163 
             * @param bool $where
20164 
             * @return \Illuminate\Database\Query\Builder
20165 
             * @static
20166 
             */
20167 
            public static function join($table, $first, $operator = null, $second = null, $type = 'inner', $where = false)
20168 
            {
20169 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20170 
                                return $instance->join($table, $first, $operator, $second, $type, $where);
20171 
            }
20172 
 
20173 
                /**
20174 
             * Add a "join where" clause to the query.
20175 
             *
20176 
             * @param string $table
20177 
             * @param \Closure|string $first
20178 
             * @param string $operator
20179 
             * @param string $second
20180 
             * @param string $type
20181 
             * @return \Illuminate\Database\Query\Builder
20182 
             * @static
20183 
             */
20184 
            public static function joinWhere($table, $first, $operator, $second, $type = 'inner')
20185 
            {
20186 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20187 
                                return $instance->joinWhere($table, $first, $operator, $second, $type);
20188 
            }
20189 
 
20190 
                /**
20191 
             * Add a subquery join clause to the query.
20192 
             *
20193 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20194 
             * @param string $as
20195 
             * @param \Closure|string $first
20196 
             * @param string|null $operator
20197 
             * @param string|null $second
20198 
             * @param string $type
20199 
             * @param bool $where
20200 
             * @return \Illuminate\Database\Query\Builder
20201 
             * @throws \InvalidArgumentException
20202 
             * @static
20203 
             */
20204 
            public static function joinSub($query, $as, $first, $operator = null, $second = null, $type = 'inner', $where = false)
20205 
            {
20206 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20207 
                                return $instance->joinSub($query, $as, $first, $operator, $second, $type, $where);
20208 
            }
20209 
 
20210 
                /**
20211 
             * Add a left join to the query.
20212 
             *
20213 
             * @param string $table
20214 
             * @param \Closure|string $first
20215 
             * @param string|null $operator
20216 
             * @param string|null $second
20217 
             * @return \Illuminate\Database\Query\Builder
20218 
             * @static
20219 
             */
20220 
            public static function leftJoin($table, $first, $operator = null, $second = null)
20221 
            {
20222 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20223 
                                return $instance->leftJoin($table, $first, $operator, $second);
20224 
            }
20225 
 
20226 
                /**
20227 
             * Add a "join where" clause to the query.
20228 
             *
20229 
             * @param string $table
20230 
             * @param \Closure|string $first
20231 
             * @param string $operator
20232 
             * @param string $second
20233 
             * @return \Illuminate\Database\Query\Builder
20234 
             * @static
20235 
             */
20236 
            public static function leftJoinWhere($table, $first, $operator, $second)
20237 
            {
20238 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20239 
                                return $instance->leftJoinWhere($table, $first, $operator, $second);
20240 
            }
20241 
 
20242 
                /**
20243 
             * Add a subquery left join to the query.
20244 
             *
20245 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20246 
             * @param string $as
20247 
             * @param \Closure|string $first
20248 
             * @param string|null $operator
20249 
             * @param string|null $second
20250 
             * @return \Illuminate\Database\Query\Builder
20251 
             * @static
20252 
             */
20253 
            public static function leftJoinSub($query, $as, $first, $operator = null, $second = null)
20254 
            {
20255 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20256 
                                return $instance->leftJoinSub($query, $as, $first, $operator, $second);
20257 
            }
20258 
 
20259 
                /**
20260 
             * Add a right join to the query.
20261 
             *
20262 
             * @param string $table
20263 
             * @param \Closure|string $first
20264 
             * @param string|null $operator
20265 
             * @param string|null $second
20266 
             * @return \Illuminate\Database\Query\Builder
20267 
             * @static
20268 
             */
20269 
            public static function rightJoin($table, $first, $operator = null, $second = null)
20270 
            {
20271 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20272 
                                return $instance->rightJoin($table, $first, $operator, $second);
20273 
            }
20274 
 
20275 
                /**
20276 
             * Add a "right join where" clause to the query.
20277 
             *
20278 
             * @param string $table
20279 
             * @param \Closure|string $first
20280 
             * @param string $operator
20281 
             * @param string $second
20282 
             * @return \Illuminate\Database\Query\Builder
20283 
             * @static
20284 
             */
20285 
            public static function rightJoinWhere($table, $first, $operator, $second)
20286 
            {
20287 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20288 
                                return $instance->rightJoinWhere($table, $first, $operator, $second);
20289 
            }
20290 
 
20291 
                /**
20292 
             * Add a subquery right join to the query.
20293 
             *
20294 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20295 
             * @param string $as
20296 
             * @param \Closure|string $first
20297 
             * @param string|null $operator
20298 
             * @param string|null $second
20299 
             * @return \Illuminate\Database\Query\Builder
20300 
             * @static
20301 
             */
20302 
            public static function rightJoinSub($query, $as, $first, $operator = null, $second = null)
20303 
            {
20304 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20305 
                                return $instance->rightJoinSub($query, $as, $first, $operator, $second);
20306 
            }
20307 
 
20308 
                /**
20309 
             * Add a "cross join" clause to the query.
20310 
             *
20311 
             * @param string $table
20312 
             * @param \Closure|string|null $first
20313 
             * @param string|null $operator
20314 
             * @param string|null $second
20315 
             * @return \Illuminate\Database\Query\Builder
20316 
             * @static
20317 
             */
20318 
            public static function crossJoin($table, $first = null, $operator = null, $second = null)
20319 
            {
20320 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20321 
                                return $instance->crossJoin($table, $first, $operator, $second);
20322 
            }
20323 
 
20324 
                /**
20325 
             * Add a subquery cross join to the query.
20326 
             *
20327 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20328 
             * @param string $as
20329 
             * @return \Illuminate\Database\Query\Builder
20330 
             * @static
20331 
             */
20332 
            public static function crossJoinSub($query, $as)
20333 
            {
20334 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20335 
                                return $instance->crossJoinSub($query, $as);
20336 
            }
20337 
 
20338 
                /**
20339 
             * Merge an array of where clauses and bindings.
20340 
             *
20341 
             * @param array $wheres
20342 
             * @param array $bindings
20343 
             * @return \Illuminate\Database\Query\Builder
20344 
             * @static
20345 
             */
20346 
            public static function mergeWheres($wheres, $bindings)
20347 
            {
20348 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20349 
                                return $instance->mergeWheres($wheres, $bindings);
20350 
            }
20351 
 
20352 
                /**
20353 
             * Prepare the value and operator for a where clause.
20354 
             *
20355 
             * @param string $value
20356 
             * @param string $operator
20357 
             * @param bool $useDefault
20358 
             * @return array
20359 
             * @throws \InvalidArgumentException
20360 
             * @static
20361 
             */
20362 
            public static function prepareValueAndOperator($value, $operator, $useDefault = false)
20363 
            {
20364 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20365 
                                return $instance->prepareValueAndOperator($value, $operator, $useDefault);
20366 
            }
20367 
 
20368 
                /**
20369 
             * Add a "where" clause comparing two columns to the query.
20370 
             *
20371 
             * @param string|array $first
20372 
             * @param string|null $operator
20373 
             * @param string|null $second
20374 
             * @param string|null $boolean
20375 
             * @return \Illuminate\Database\Query\Builder
20376 
             * @static
20377 
             */
20378 
            public static function whereColumn($first, $operator = null, $second = null, $boolean = 'and')
20379 
            {
20380 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20381 
                                return $instance->whereColumn($first, $operator, $second, $boolean);
20382 
            }
20383 
 
20384 
                /**
20385 
             * Add an "or where" clause comparing two columns to the query.
20386 
             *
20387 
             * @param string|array $first
20388 
             * @param string|null $operator
20389 
             * @param string|null $second
20390 
             * @return \Illuminate\Database\Query\Builder
20391 
             * @static
20392 
             */
20393 
            public static function orWhereColumn($first, $operator = null, $second = null)
20394 
            {
20395 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20396 
                                return $instance->orWhereColumn($first, $operator, $second);
20397 
            }
20398 
 
20399 
                /**
20400 
             * Add a raw where clause to the query.
20401 
             *
20402 
             * @param string $sql
20403 
             * @param mixed $bindings
20404 
             * @param string $boolean
20405 
             * @return \Illuminate\Database\Query\Builder
20406 
             * @static
20407 
             */
20408 
            public static function whereRaw($sql, $bindings = [], $boolean = 'and')
20409 
            {
20410 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20411 
                                return $instance->whereRaw($sql, $bindings, $boolean);
20412 
            }
20413 
 
20414 
                /**
20415 
             * Add a raw or where clause to the query.
20416 
             *
20417 
             * @param string $sql
20418 
             * @param mixed $bindings
20419 
             * @return \Illuminate\Database\Query\Builder
20420 
             * @static
20421 
             */
20422 
            public static function orWhereRaw($sql, $bindings = [])
20423 
            {
20424 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20425 
                                return $instance->orWhereRaw($sql, $bindings);
20426 
            }
20427 
 
20428 
                /**
20429 
             * Add a "where in" clause to the query.
20430 
             *
20431 
             * @param string $column
20432 
             * @param mixed $values
20433 
             * @param string $boolean
20434 
             * @param bool $not
20435 
             * @return \Illuminate\Database\Query\Builder
20436 
             * @static
20437 
             */
20438 
            public static function whereIn($column, $values, $boolean = 'and', $not = false)
20439 
            {
20440 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20441 
                                return $instance->whereIn($column, $values, $boolean, $not);
20442 
            }
20443 
 
20444 
                /**
20445 
             * Add an "or where in" clause to the query.
20446 
             *
20447 
             * @param string $column
20448 
             * @param mixed $values
20449 
             * @return \Illuminate\Database\Query\Builder
20450 
             * @static
20451 
             */
20452 
            public static function orWhereIn($column, $values)
20453 
            {
20454 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20455 
                                return $instance->orWhereIn($column, $values);
20456 
            }
20457 
 
20458 
                /**
20459 
             * Add a "where not in" clause to the query.
20460 
             *
20461 
             * @param string $column
20462 
             * @param mixed $values
20463 
             * @param string $boolean
20464 
             * @return \Illuminate\Database\Query\Builder
20465 
             * @static
20466 
             */
20467 
            public static function whereNotIn($column, $values, $boolean = 'and')
20468 
            {
20469 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20470 
                                return $instance->whereNotIn($column, $values, $boolean);
20471 
            }
20472 
 
20473 
                /**
20474 
             * Add an "or where not in" clause to the query.
20475 
             *
20476 
             * @param string $column
20477 
             * @param mixed $values
20478 
             * @return \Illuminate\Database\Query\Builder
20479 
             * @static
20480 
             */
20481 
            public static function orWhereNotIn($column, $values)
20482 
            {
20483 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20484 
                                return $instance->orWhereNotIn($column, $values);
20485 
            }
20486 
 
20487 
                /**
20488 
             * Add a "where in raw" clause for integer values to the query.
20489 
             *
20490 
             * @param string $column
20491 
             * @param \Illuminate\Contracts\Support\Arrayable|array $values
20492 
             * @param string $boolean
20493 
             * @param bool $not
20494 
             * @return \Illuminate\Database\Query\Builder
20495 
             * @static
20496 
             */
20497 
            public static function whereIntegerInRaw($column, $values, $boolean = 'and', $not = false)
20498 
            {
20499 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20500 
                                return $instance->whereIntegerInRaw($column, $values, $boolean, $not);
20501 
            }
20502 
 
20503 
                /**
20504 
             * Add an "or where in raw" clause for integer values to the query.
20505 
             *
20506 
             * @param string $column
20507 
             * @param \Illuminate\Contracts\Support\Arrayable|array $values
20508 
             * @return \Illuminate\Database\Query\Builder
20509 
             * @static
20510 
             */
20511 
            public static function orWhereIntegerInRaw($column, $values)
20512 
            {
20513 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20514 
                                return $instance->orWhereIntegerInRaw($column, $values);
20515 
            }
20516 
 
20517 
                /**
20518 
             * Add a "where not in raw" clause for integer values to the query.
20519 
             *
20520 
             * @param string $column
20521 
             * @param \Illuminate\Contracts\Support\Arrayable|array $values
20522 
             * @param string $boolean
20523 
             * @return \Illuminate\Database\Query\Builder
20524 
             * @static
20525 
             */
20526 
            public static function whereIntegerNotInRaw($column, $values, $boolean = 'and')
20527 
            {
20528 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20529 
                                return $instance->whereIntegerNotInRaw($column, $values, $boolean);
20530 
            }
20531 
 
20532 
                /**
20533 
             * Add an "or where not in raw" clause for integer values to the query.
20534 
             *
20535 
             * @param string $column
20536 
             * @param \Illuminate\Contracts\Support\Arrayable|array $values
20537 
             * @return \Illuminate\Database\Query\Builder
20538 
             * @static
20539 
             */
20540 
            public static function orWhereIntegerNotInRaw($column, $values)
20541 
            {
20542 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20543 
                                return $instance->orWhereIntegerNotInRaw($column, $values);
20544 
            }
20545 
 
20546 
                /**
20547 
             * Add a "where null" clause to the query.
20548 
             *
20549 
             * @param string|array $columns
20550 
             * @param string $boolean
20551 
             * @param bool $not
20552 
             * @return \Illuminate\Database\Query\Builder
20553 
             * @static
20554 
             */
20555 
            public static function whereNull($columns, $boolean = 'and', $not = false)
20556 
            {
20557 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20558 
                                return $instance->whereNull($columns, $boolean, $not);
20559 
            }
20560 
 
20561 
                /**
20562 
             * Add an "or where null" clause to the query.
20563 
             *
20564 
             * @param string|array $column
20565 
             * @return \Illuminate\Database\Query\Builder
20566 
             * @static
20567 
             */
20568 
            public static function orWhereNull($column)
20569 
            {
20570 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20571 
                                return $instance->orWhereNull($column);
20572 
            }
20573 
 
20574 
                /**
20575 
             * Add a "where not null" clause to the query.
20576 
             *
20577 
             * @param string|array $columns
20578 
             * @param string $boolean
20579 
             * @return \Illuminate\Database\Query\Builder
20580 
             * @static
20581 
             */
20582 
            public static function whereNotNull($columns, $boolean = 'and')
20583 
            {
20584 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20585 
                                return $instance->whereNotNull($columns, $boolean);
20586 
            }
20587 
 
20588 
                /**
20589 
             * Add a where between statement to the query.
20590 
             *
20591 
             * @param string|\Illuminate\Database\Query\Expression $column
20592 
             * @param \Illuminate\Database\Query\iterable $values
20593 
             * @param string $boolean
20594 
             * @param bool $not
20595 
             * @return \Illuminate\Database\Query\Builder
20596 
             * @static
20597 
             */
20598 
            public static function whereBetween($column, $values, $boolean = 'and', $not = false)
20599 
            {
20600 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20601 
                                return $instance->whereBetween($column, $values, $boolean, $not);
20602 
            }
20603 
 
20604 
                /**
20605 
             * Add a where between statement using columns to the query.
20606 
             *
20607 
             * @param string $column
20608 
             * @param array $values
20609 
             * @param string $boolean
20610 
             * @param bool $not
20611 
             * @return \Illuminate\Database\Query\Builder
20612 
             * @static
20613 
             */
20614 
            public static function whereBetweenColumns($column, $values, $boolean = 'and', $not = false)
20615 
            {
20616 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20617 
                                return $instance->whereBetweenColumns($column, $values, $boolean, $not);
20618 
            }
20619 
 
20620 
                /**
20621 
             * Add an or where between statement to the query.
20622 
             *
20623 
             * @param string $column
20624 
             * @param \Illuminate\Database\Query\iterable $values
20625 
             * @return \Illuminate\Database\Query\Builder
20626 
             * @static
20627 
             */
20628 
            public static function orWhereBetween($column, $values)
20629 
            {
20630 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20631 
                                return $instance->orWhereBetween($column, $values);
20632 
            }
20633 
 
20634 
                /**
20635 
             * Add an or where between statement using columns to the query.
20636 
             *
20637 
             * @param string $column
20638 
             * @param array $values
20639 
             * @return \Illuminate\Database\Query\Builder
20640 
             * @static
20641 
             */
20642 
            public static function orWhereBetweenColumns($column, $values)
20643 
            {
20644 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20645 
                                return $instance->orWhereBetweenColumns($column, $values);
20646 
            }
20647 
 
20648 
                /**
20649 
             * Add a where not between statement to the query.
20650 
             *
20651 
             * @param string $column
20652 
             * @param \Illuminate\Database\Query\iterable $values
20653 
             * @param string $boolean
20654 
             * @return \Illuminate\Database\Query\Builder
20655 
             * @static
20656 
             */
20657 
            public static function whereNotBetween($column, $values, $boolean = 'and')
20658 
            {
20659 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20660 
                                return $instance->whereNotBetween($column, $values, $boolean);
20661 
            }
20662 
 
20663 
                /**
20664 
             * Add a where not between statement using columns to the query.
20665 
             *
20666 
             * @param string $column
20667 
             * @param array $values
20668 
             * @param string $boolean
20669 
             * @return \Illuminate\Database\Query\Builder
20670 
             * @static
20671 
             */
20672 
            public static function whereNotBetweenColumns($column, $values, $boolean = 'and')
20673 
            {
20674 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20675 
                                return $instance->whereNotBetweenColumns($column, $values, $boolean);
20676 
            }
20677 
 
20678 
                /**
20679 
             * Add an or where not between statement to the query.
20680 
             *
20681 
             * @param string $column
20682 
             * @param \Illuminate\Database\Query\iterable $values
20683 
             * @return \Illuminate\Database\Query\Builder
20684 
             * @static
20685 
             */
20686 
            public static function orWhereNotBetween($column, $values)
20687 
            {
20688 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20689 
                                return $instance->orWhereNotBetween($column, $values);
20690 
            }
20691 
 
20692 
                /**
20693 
             * Add an or where not between statement using columns to the query.
20694 
             *
20695 
             * @param string $column
20696 
             * @param array $values
20697 
             * @return \Illuminate\Database\Query\Builder
20698 
             * @static
20699 
             */
20700 
            public static function orWhereNotBetweenColumns($column, $values)
20701 
            {
20702 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20703 
                                return $instance->orWhereNotBetweenColumns($column, $values);
20704 
            }
20705 
 
20706 
                /**
20707 
             * Add an "or where not null" clause to the query.
20708 
             *
20709 
             * @param string $column
20710 
             * @return \Illuminate\Database\Query\Builder
20711 
             * @static
20712 
             */
20713 
            public static function orWhereNotNull($column)
20714 
            {
20715 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20716 
                                return $instance->orWhereNotNull($column);
20717 
            }
20718 
 
20719 
                /**
20720 
             * Add a "where date" statement to the query.
20721 
             *
20722 
             * @param string $column
20723 
             * @param string $operator
20724 
             * @param \DateTimeInterface|string|null $value
20725 
             * @param string $boolean
20726 
             * @return \Illuminate\Database\Query\Builder
20727 
             * @static
20728 
             */
20729 
            public static function whereDate($column, $operator, $value = null, $boolean = 'and')
20730 
            {
20731 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20732 
                                return $instance->whereDate($column, $operator, $value, $boolean);
20733 
            }
20734 
 
20735 
                /**
20736 
             * Add an "or where date" statement to the query.
20737 
             *
20738 
             * @param string $column
20739 
             * @param string $operator
20740 
             * @param \DateTimeInterface|string|null $value
20741 
             * @return \Illuminate\Database\Query\Builder
20742 
             * @static
20743 
             */
20744 
            public static function orWhereDate($column, $operator, $value = null)
20745 
            {
20746 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20747 
                                return $instance->orWhereDate($column, $operator, $value);
20748 
            }
20749 
 
20750 
                /**
20751 
             * Add a "where time" statement to the query.
20752 
             *
20753 
             * @param string $column
20754 
             * @param string $operator
20755 
             * @param \DateTimeInterface|string|null $value
20756 
             * @param string $boolean
20757 
             * @return \Illuminate\Database\Query\Builder
20758 
             * @static
20759 
             */
20760 
            public static function whereTime($column, $operator, $value = null, $boolean = 'and')
20761 
            {
20762 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20763 
                                return $instance->whereTime($column, $operator, $value, $boolean);
20764 
            }
20765 
 
20766 
                /**
20767 
             * Add an "or where time" statement to the query.
20768 
             *
20769 
             * @param string $column
20770 
             * @param string $operator
20771 
             * @param \DateTimeInterface|string|null $value
20772 
             * @return \Illuminate\Database\Query\Builder
20773 
             * @static
20774 
             */
20775 
            public static function orWhereTime($column, $operator, $value = null)
20776 
            {
20777 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20778 
                                return $instance->orWhereTime($column, $operator, $value);
20779 
            }
20780 
 
20781 
                /**
20782 
             * Add a "where day" statement to the query.
20783 
             *
20784 
             * @param string $column
20785 
             * @param string $operator
20786 
             * @param \DateTimeInterface|string|int|null $value
20787 
             * @param string $boolean
20788 
             * @return \Illuminate\Database\Query\Builder
20789 
             * @static
20790 
             */
20791 
            public static function whereDay($column, $operator, $value = null, $boolean = 'and')
20792 
            {
20793 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20794 
                                return $instance->whereDay($column, $operator, $value, $boolean);
20795 
            }
20796 
 
20797 
                /**
20798 
             * Add an "or where day" statement to the query.
20799 
             *
20800 
             * @param string $column
20801 
             * @param string $operator
20802 
             * @param \DateTimeInterface|string|int|null $value
20803 
             * @return \Illuminate\Database\Query\Builder
20804 
             * @static
20805 
             */
20806 
            public static function orWhereDay($column, $operator, $value = null)
20807 
            {
20808 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20809 
                                return $instance->orWhereDay($column, $operator, $value);
20810 
            }
20811 
 
20812 
                /**
20813 
             * Add a "where month" statement to the query.
20814 
             *
20815 
             * @param string $column
20816 
             * @param string $operator
20817 
             * @param \DateTimeInterface|string|int|null $value
20818 
             * @param string $boolean
20819 
             * @return \Illuminate\Database\Query\Builder
20820 
             * @static
20821 
             */
20822 
            public static function whereMonth($column, $operator, $value = null, $boolean = 'and')
20823 
            {
20824 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20825 
                                return $instance->whereMonth($column, $operator, $value, $boolean);
20826 
            }
20827 
 
20828 
                /**
20829 
             * Add an "or where month" statement to the query.
20830 
             *
20831 
             * @param string $column
20832 
             * @param string $operator
20833 
             * @param \DateTimeInterface|string|int|null $value
20834 
             * @return \Illuminate\Database\Query\Builder
20835 
             * @static
20836 
             */
20837 
            public static function orWhereMonth($column, $operator, $value = null)
20838 
            {
20839 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20840 
                                return $instance->orWhereMonth($column, $operator, $value);
20841 
            }
20842 
 
20843 
                /**
20844 
             * Add a "where year" statement to the query.
20845 
             *
20846 
             * @param string $column
20847 
             * @param string $operator
20848 
             * @param \DateTimeInterface|string|int|null $value
20849 
             * @param string $boolean
20850 
             * @return \Illuminate\Database\Query\Builder
20851 
             * @static
20852 
             */
20853 
            public static function whereYear($column, $operator, $value = null, $boolean = 'and')
20854 
            {
20855 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20856 
                                return $instance->whereYear($column, $operator, $value, $boolean);
20857 
            }
20858 
 
20859 
                /**
20860 
             * Add an "or where year" statement to the query.
20861 
             *
20862 
             * @param string $column
20863 
             * @param string $operator
20864 
             * @param \DateTimeInterface|string|int|null $value
20865 
             * @return \Illuminate\Database\Query\Builder
20866 
             * @static
20867 
             */
20868 
            public static function orWhereYear($column, $operator, $value = null)
20869 
            {
20870 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20871 
                                return $instance->orWhereYear($column, $operator, $value);
20872 
            }
20873 
 
20874 
                /**
20875 
             * Add a nested where statement to the query.
20876 
             *
20877 
             * @param \Closure $callback
20878 
             * @param string $boolean
20879 
             * @return \Illuminate\Database\Query\Builder
20880 
             * @static
20881 
             */
20882 
            public static function whereNested($callback, $boolean = 'and')
20883 
            {
20884 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20885 
                                return $instance->whereNested($callback, $boolean);
20886 
            }
20887 
 
20888 
                /**
20889 
             * Create a new query instance for nested where condition.
20890 
             *
20891 
             * @return \Illuminate\Database\Query\Builder
20892 
             * @static
20893 
             */
20894 
            public static function forNestedWhere()
20895 
            {
20896 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20897 
                                return $instance->forNestedWhere();
20898 
            }
20899 
 
20900 
                /**
20901 
             * Add another query builder as a nested where to the query builder.
20902 
             *
20903 
             * @param \Illuminate\Database\Query\Builder $query
20904 
             * @param string $boolean
20905 
             * @return \Illuminate\Database\Query\Builder
20906 
             * @static
20907 
             */
20908 
            public static function addNestedWhereQuery($query, $boolean = 'and')
20909 
            {
20910 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20911 
                                return $instance->addNestedWhereQuery($query, $boolean);
20912 
            }
20913 
 
20914 
                /**
20915 
             * Add an exists clause to the query.
20916 
             *
20917 
             * @param \Closure $callback
20918 
             * @param string $boolean
20919 
             * @param bool $not
20920 
             * @return \Illuminate\Database\Query\Builder
20921 
             * @static
20922 
             */
20923 
            public static function whereExists($callback, $boolean = 'and', $not = false)
20924 
            {
20925 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20926 
                                return $instance->whereExists($callback, $boolean, $not);
20927 
            }
20928 
 
20929 
                /**
20930 
             * Add an or exists clause to the query.
20931 
             *
20932 
             * @param \Closure $callback
20933 
             * @param bool $not
20934 
             * @return \Illuminate\Database\Query\Builder
20935 
             * @static
20936 
             */
20937 
            public static function orWhereExists($callback, $not = false)
20938 
            {
20939 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20940 
                                return $instance->orWhereExists($callback, $not);
20941 
            }
20942 
 
20943 
                /**
20944 
             * Add a where not exists clause to the query.
20945 
             *
20946 
             * @param \Closure $callback
20947 
             * @param string $boolean
20948 
             * @return \Illuminate\Database\Query\Builder
20949 
             * @static
20950 
             */
20951 
            public static function whereNotExists($callback, $boolean = 'and')
20952 
            {
20953 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20954 
                                return $instance->whereNotExists($callback, $boolean);
20955 
            }
20956 
 
20957 
                /**
20958 
             * Add a where not exists clause to the query.
20959 
             *
20960 
             * @param \Closure $callback
20961 
             * @return \Illuminate\Database\Query\Builder
20962 
             * @static
20963 
             */
20964 
            public static function orWhereNotExists($callback)
20965 
            {
20966 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20967 
                                return $instance->orWhereNotExists($callback);
20968 
            }
20969 
 
20970 
                /**
20971 
             * Add an exists clause to the query.
20972 
             *
20973 
             * @param \Illuminate\Database\Query\Builder $query
20974 
             * @param string $boolean
20975 
             * @param bool $not
20976 
             * @return \Illuminate\Database\Query\Builder
20977 
             * @static
20978 
             */
20979 
            public static function addWhereExistsQuery($query, $boolean = 'and', $not = false)
20980 
            {
20981 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20982 
                                return $instance->addWhereExistsQuery($query, $boolean, $not);
20983 
            }
20984 
 
20985 
                /**
20986 
             * Adds a where condition using row values.
20987 
             *
20988 
             * @param array $columns
20989 
             * @param string $operator
20990 
             * @param array $values
20991 
             * @param string $boolean
20992 
             * @return \Illuminate\Database\Query\Builder
20993 
             * @throws \InvalidArgumentException
20994 
             * @static
20995 
             */
20996 
            public static function whereRowValues($columns, $operator, $values, $boolean = 'and')
20997 
            {
20998 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20999 
                                return $instance->whereRowValues($columns, $operator, $values, $boolean);
21000 
            }
21001 
 
21002 
                /**
21003 
             * Adds an or where condition using row values.
21004 
             *
21005 
             * @param array $columns
21006 
             * @param string $operator
21007 
             * @param array $values
21008 
             * @return \Illuminate\Database\Query\Builder
21009 
             * @static
21010 
             */
21011 
            public static function orWhereRowValues($columns, $operator, $values)
21012 
            {
21013 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21014 
                                return $instance->orWhereRowValues($columns, $operator, $values);
21015 
            }
21016 
 
21017 
                /**
21018 
             * Add a "where JSON contains" clause to the query.
21019 
             *
21020 
             * @param string $column
21021 
             * @param mixed $value
21022 
             * @param string $boolean
21023 
             * @param bool $not
21024 
             * @return \Illuminate\Database\Query\Builder
21025 
             * @static
21026 
             */
21027 
            public static function whereJsonContains($column, $value, $boolean = 'and', $not = false)
21028 
            {
21029 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21030 
                                return $instance->whereJsonContains($column, $value, $boolean, $not);
21031 
            }
21032 
 
21033 
                /**
21034 
             * Add an "or where JSON contains" clause to the query.
21035 
             *
21036 
             * @param string $column
21037 
             * @param mixed $value
21038 
             * @return \Illuminate\Database\Query\Builder
21039 
             * @static
21040 
             */
21041 
            public static function orWhereJsonContains($column, $value)
21042 
            {
21043 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21044 
                                return $instance->orWhereJsonContains($column, $value);
21045 
            }
21046 
 
21047 
                /**
21048 
             * Add a "where JSON not contains" clause to the query.
21049 
             *
21050 
             * @param string $column
21051 
             * @param mixed $value
21052 
             * @param string $boolean
21053 
             * @return \Illuminate\Database\Query\Builder
21054 
             * @static
21055 
             */
21056 
            public static function whereJsonDoesntContain($column, $value, $boolean = 'and')
21057 
            {
21058 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21059 
                                return $instance->whereJsonDoesntContain($column, $value, $boolean);
21060 
            }
21061 
 
21062 
                /**
21063 
             * Add an "or where JSON not contains" clause to the query.
21064 
             *
21065 
             * @param string $column
21066 
             * @param mixed $value
21067 
             * @return \Illuminate\Database\Query\Builder
21068 
             * @static
21069 
             */
21070 
            public static function orWhereJsonDoesntContain($column, $value)
21071 
            {
21072 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21073 
                                return $instance->orWhereJsonDoesntContain($column, $value);
21074 
            }
21075 
 
21076 
                /**
21077 
             * Add a clause that determines if a JSON path exists to the query.
21078 
             *
21079 
             * @param string $column
21080 
             * @param string $boolean
21081 
             * @param bool $not
21082 
             * @return \Illuminate\Database\Query\Builder
21083 
             * @static
21084 
             */
21085 
            public static function whereJsonContainsKey($column, $boolean = 'and', $not = false)
21086 
            {
21087 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21088 
                                return $instance->whereJsonContainsKey($column, $boolean, $not);
21089 
            }
21090 
 
21091 
                /**
21092 
             * Add an "or" clause that determines if a JSON path exists to the query.
21093 
             *
21094 
             * @param string $column
21095 
             * @return \Illuminate\Database\Query\Builder
21096 
             * @static
21097 
             */
21098 
            public static function orWhereJsonContainsKey($column)
21099 
            {
21100 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21101 
                                return $instance->orWhereJsonContainsKey($column);
21102 
            }
21103 
 
21104 
                /**
21105 
             * Add a clause that determines if a JSON path does not exist to the query.
21106 
             *
21107 
             * @param string $column
21108 
             * @param string $boolean
21109 
             * @return \Illuminate\Database\Query\Builder
21110 
             * @static
21111 
             */
21112 
            public static function whereJsonDoesntContainKey($column, $boolean = 'and')
21113 
            {
21114 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21115 
                                return $instance->whereJsonDoesntContainKey($column, $boolean);
21116 
            }
21117 
 
21118 
                /**
21119 
             * Add an "or" clause that determines if a JSON path does not exist to the query.
21120 
             *
21121 
             * @param string $column
21122 
             * @return \Illuminate\Database\Query\Builder
21123 
             * @static
21124 
             */
21125 
            public static function orWhereJsonDoesntContainKey($column)
21126 
            {
21127 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21128 
                                return $instance->orWhereJsonDoesntContainKey($column);
21129 
            }
21130 
 
21131 
                /**
21132 
             * Add a "where JSON length" clause to the query.
21133 
             *
21134 
             * @param string $column
21135 
             * @param mixed $operator
21136 
             * @param mixed $value
21137 
             * @param string $boolean
21138 
             * @return \Illuminate\Database\Query\Builder
21139 
             * @static
21140 
             */
21141 
            public static function whereJsonLength($column, $operator, $value = null, $boolean = 'and')
21142 
            {
21143 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21144 
                                return $instance->whereJsonLength($column, $operator, $value, $boolean);
21145 
            }
21146 
 
21147 
                /**
21148 
             * Add an "or where JSON length" clause to the query.
21149 
             *
21150 
             * @param string $column
21151 
             * @param mixed $operator
21152 
             * @param mixed $value
21153 
             * @return \Illuminate\Database\Query\Builder
21154 
             * @static
21155 
             */
21156 
            public static function orWhereJsonLength($column, $operator, $value = null)
21157 
            {
21158 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21159 
                                return $instance->orWhereJsonLength($column, $operator, $value);
21160 
            }
21161 
 
21162 
                /**
21163 
             * Handles dynamic "where" clauses to the query.
21164 
             *
21165 
             * @param string $method
21166 
             * @param array $parameters
21167 
             * @return \Illuminate\Database\Query\Builder
21168 
             * @static
21169 
             */
21170 
            public static function dynamicWhere($method, $parameters)
21171 
            {
21172 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21173 
                                return $instance->dynamicWhere($method, $parameters);
21174 
            }
21175 
 
21176 
                /**
21177 
             * Add a "where fulltext" clause to the query.
21178 
             *
21179 
             * @param string|string[] $columns
21180 
             * @param string $value
21181 
             * @param string $boolean
21182 
             * @return \Illuminate\Database\Query\Builder
21183 
             * @static
21184 
             */
21185 
            public static function whereFullText($columns, $value, $options = [], $boolean = 'and')
21186 
            {
21187 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21188 
                                return $instance->whereFullText($columns, $value, $options, $boolean);
21189 
            }
21190 
 
21191 
                /**
21192 
             * Add a "or where fulltext" clause to the query.
21193 
             *
21194 
             * @param string|string[] $columns
21195 
             * @param string $value
21196 
             * @return \Illuminate\Database\Query\Builder
21197 
             * @static
21198 
             */
21199 
            public static function orWhereFullText($columns, $value, $options = [])
21200 
            {
21201 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21202 
                                return $instance->orWhereFullText($columns, $value, $options);
21203 
            }
21204 
 
21205 
                /**
21206 
             * Add a "group by" clause to the query.
21207 
             *
21208 
             * @param array|string $groups
21209 
             * @return \Illuminate\Database\Query\Builder
21210 
             * @static
21211 
             */
21212 
            public static function groupBy(...$groups)
21213 
            {
21214 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21215 
                                return $instance->groupBy(...$groups);
21216 
            }
21217 
 
21218 
                /**
21219 
             * Add a raw groupBy clause to the query.
21220 
             *
21221 
             * @param string $sql
21222 
             * @param array $bindings
21223 
             * @return \Illuminate\Database\Query\Builder
21224 
             * @static
21225 
             */
21226 
            public static function groupByRaw($sql, $bindings = [])
21227 
            {
21228 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21229 
                                return $instance->groupByRaw($sql, $bindings);
21230 
            }
21231 
 
21232 
                /**
21233 
             * Add a "having" clause to the query.
21234 
             *
21235 
             * @param \Closure|string $column
21236 
             * @param string|int|float|null $operator
21237 
             * @param string|int|float|null $value
21238 
             * @param string $boolean
21239 
             * @return \Illuminate\Database\Query\Builder
21240 
             * @static
21241 
             */
21242 
            public static function having($column, $operator = null, $value = null, $boolean = 'and')
21243 
            {
21244 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21245 
                                return $instance->having($column, $operator, $value, $boolean);
21246 
            }
21247 
 
21248 
                /**
21249 
             * Add an "or having" clause to the query.
21250 
             *
21251 
             * @param \Closure|string $column
21252 
             * @param string|int|float|null $operator
21253 
             * @param string|int|float|null $value
21254 
             * @return \Illuminate\Database\Query\Builder
21255 
             * @static
21256 
             */
21257 
            public static function orHaving($column, $operator = null, $value = null)
21258 
            {
21259 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21260 
                                return $instance->orHaving($column, $operator, $value);
21261 
            }
21262 
 
21263 
                /**
21264 
             * Add a nested having statement to the query.
21265 
             *
21266 
             * @param \Closure $callback
21267 
             * @param string $boolean
21268 
             * @return \Illuminate\Database\Query\Builder
21269 
             * @static
21270 
             */
21271 
            public static function havingNested($callback, $boolean = 'and')
21272 
            {
21273 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21274 
                                return $instance->havingNested($callback, $boolean);
21275 
            }
21276 
 
21277 
                /**
21278 
             * Add another query builder as a nested having to the query builder.
21279 
             *
21280 
             * @param \Illuminate\Database\Query\Builder $query
21281 
             * @param string $boolean
21282 
             * @return \Illuminate\Database\Query\Builder
21283 
             * @static
21284 
             */
21285 
            public static function addNestedHavingQuery($query, $boolean = 'and')
21286 
            {
21287 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21288 
                                return $instance->addNestedHavingQuery($query, $boolean);
21289 
            }
21290 
 
21291 
                /**
21292 
             * Add a "having null" clause to the query.
21293 
             *
21294 
             * @param string|array $columns
21295 
             * @param string $boolean
21296 
             * @param bool $not
21297 
             * @return \Illuminate\Database\Query\Builder
21298 
             * @static
21299 
             */
21300 
            public static function havingNull($columns, $boolean = 'and', $not = false)
21301 
            {
21302 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21303 
                                return $instance->havingNull($columns, $boolean, $not);
21304 
            }
21305 
 
21306 
                /**
21307 
             * Add an "or having null" clause to the query.
21308 
             *
21309 
             * @param string $column
21310 
             * @return \Illuminate\Database\Query\Builder
21311 
             * @static
21312 
             */
21313 
            public static function orHavingNull($column)
21314 
            {
21315 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21316 
                                return $instance->orHavingNull($column);
21317 
            }
21318 
 
21319 
                /**
21320 
             * Add a "having not null" clause to the query.
21321 
             *
21322 
             * @param string|array $columns
21323 
             * @param string $boolean
21324 
             * @return \Illuminate\Database\Query\Builder
21325 
             * @static
21326 
             */
21327 
            public static function havingNotNull($columns, $boolean = 'and')
21328 
            {
21329 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21330 
                                return $instance->havingNotNull($columns, $boolean);
21331 
            }
21332 
 
21333 
                /**
21334 
             * Add an "or having not null" clause to the query.
21335 
             *
21336 
             * @param string $column
21337 
             * @return \Illuminate\Database\Query\Builder
21338 
             * @static
21339 
             */
21340 
            public static function orHavingNotNull($column)
21341 
            {
21342 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21343 
                                return $instance->orHavingNotNull($column);
21344 
            }
21345 
 
21346 
                /**
21347 
             * Add a "having between " clause to the query.
21348 
             *
21349 
             * @param string $column
21350 
             * @param array $values
21351 
             * @param string $boolean
21352 
             * @param bool $not
21353 
             * @return \Illuminate\Database\Query\Builder
21354 
             * @static
21355 
             */
21356 
            public static function havingBetween($column, $values, $boolean = 'and', $not = false)
21357 
            {
21358 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21359 
                                return $instance->havingBetween($column, $values, $boolean, $not);
21360 
            }
21361 
 
21362 
                /**
21363 
             * Add a raw having clause to the query.
21364 
             *
21365 
             * @param string $sql
21366 
             * @param array $bindings
21367 
             * @param string $boolean
21368 
             * @return \Illuminate\Database\Query\Builder
21369 
             * @static
21370 
             */
21371 
            public static function havingRaw($sql, $bindings = [], $boolean = 'and')
21372 
            {
21373 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21374 
                                return $instance->havingRaw($sql, $bindings, $boolean);
21375 
            }
21376 
 
21377 
                /**
21378 
             * Add a raw or having clause to the query.
21379 
             *
21380 
             * @param string $sql
21381 
             * @param array $bindings
21382 
             * @return \Illuminate\Database\Query\Builder
21383 
             * @static
21384 
             */
21385 
            public static function orHavingRaw($sql, $bindings = [])
21386 
            {
21387 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21388 
                                return $instance->orHavingRaw($sql, $bindings);
21389 
            }
21390 
 
21391 
                /**
21392 
             * Add an "order by" clause to the query.
21393 
             *
21394 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Query\Expression|string $column
21395 
             * @param string $direction
21396 
             * @return \Illuminate\Database\Query\Builder
21397 
             * @throws \InvalidArgumentException
21398 
             * @static
21399 
             */
21400 
            public static function orderBy($column, $direction = 'asc')
21401 
            {
21402 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21403 
                                return $instance->orderBy($column, $direction);
21404 
            }
21405 
 
21406 
                /**
21407 
             * Add a descending "order by" clause to the query.
21408 
             *
21409 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Query\Expression|string $column
21410 
             * @return \Illuminate\Database\Query\Builder
21411 
             * @static
21412 
             */
21413 
            public static function orderByDesc($column)
21414 
            {
21415 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21416 
                                return $instance->orderByDesc($column);
21417 
            }
21418 
 
21419 
                /**
21420 
             * Put the query's results in random order.
21421 
             *
21422 
             * @param string|int $seed
21423 
             * @return \Illuminate\Database\Query\Builder
21424 
             * @static
21425 
             */
21426 
            public static function inRandomOrder($seed = '')
21427 
            {
21428 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21429 
                                return $instance->inRandomOrder($seed);
21430 
            }
21431 
 
21432 
                /**
21433 
             * Add a raw "order by" clause to the query.
21434 
             *
21435 
             * @param string $sql
21436 
             * @param array $bindings
21437 
             * @return \Illuminate\Database\Query\Builder
21438 
             * @static
21439 
             */
21440 
            public static function orderByRaw($sql, $bindings = [])
21441 
            {
21442 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21443 
                                return $instance->orderByRaw($sql, $bindings);
21444 
            }
21445 
 
21446 
                /**
21447 
             * Alias to set the "offset" value of the query.
21448 
             *
21449 
             * @param int $value
21450 
             * @return \Illuminate\Database\Query\Builder
21451 
             * @static
21452 
             */
21453 
            public static function skip($value)
21454 
            {
21455 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21456 
                                return $instance->skip($value);
21457 
            }
21458 
 
21459 
                /**
21460 
             * Set the "offset" value of the query.
21461 
             *
21462 
             * @param int $value
21463 
             * @return \Illuminate\Database\Query\Builder
21464 
             * @static
21465 
             */
21466 
            public static function offset($value)
21467 
            {
21468 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21469 
                                return $instance->offset($value);
21470 
            }
21471 
 
21472 
                /**
21473 
             * Alias to set the "limit" value of the query.
21474 
             *
21475 
             * @param int $value
21476 
             * @return \Illuminate\Database\Query\Builder
21477 
             * @static
21478 
             */
21479 
            public static function take($value)
21480 
            {
21481 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21482 
                                return $instance->take($value);
21483 
            }
21484 
 
21485 
                /**
21486 
             * Set the "limit" value of the query.
21487 
             *
21488 
             * @param int $value
21489 
             * @return \Illuminate\Database\Query\Builder
21490 
             * @static
21491 
             */
21492 
            public static function limit($value)
21493 
            {
21494 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21495 
                                return $instance->limit($value);
21496 
            }
21497 
 
21498 
                /**
21499 
             * Set the limit and offset for a given page.
21500 
             *
21501 
             * @param int $page
21502 
             * @param int $perPage
21503 
             * @return \Illuminate\Database\Query\Builder
21504 
             * @static
21505 
             */
21506 
            public static function forPage($page, $perPage = 15)
21507 
            {
21508 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21509 
                                return $instance->forPage($page, $perPage);
21510 
            }
21511 
 
21512 
                /**
21513 
             * Constrain the query to the previous "page" of results before a given ID.
21514 
             *
21515 
             * @param int $perPage
21516 
             * @param int|null $lastId
21517 
             * @param string $column
21518 
             * @return \Illuminate\Database\Query\Builder
21519 
             * @static
21520 
             */
21521 
            public static function forPageBeforeId($perPage = 15, $lastId = 0, $column = 'id')
21522 
            {
21523 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21524 
                                return $instance->forPageBeforeId($perPage, $lastId, $column);
21525 
            }
21526 
 
21527 
                /**
21528 
             * Constrain the query to the next "page" of results after a given ID.
21529 
             *
21530 
             * @param int $perPage
21531 
             * @param int|null $lastId
21532 
             * @param string $column
21533 
             * @return \Illuminate\Database\Query\Builder
21534 
             * @static
21535 
             */
21536 
            public static function forPageAfterId($perPage = 15, $lastId = 0, $column = 'id')
21537 
            {
21538 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21539 
                                return $instance->forPageAfterId($perPage, $lastId, $column);
21540 
            }
21541 
 
21542 
                /**
21543 
             * Remove all existing orders and optionally add a new order.
21544 
             *
21545 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Query\Expression|string|null $column
21546 
             * @param string $direction
21547 
             * @return \Illuminate\Database\Query\Builder
21548 
             * @static
21549 
             */
21550 
            public static function reorder($column = null, $direction = 'asc')
21551 
            {
21552 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21553 
                                return $instance->reorder($column, $direction);
21554 
            }
21555 
 
21556 
                /**
21557 
             * Add a union statement to the query.
21558 
             *
21559 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder $query
21560 
             * @param bool $all
21561 
             * @return \Illuminate\Database\Query\Builder
21562 
             * @static
21563 
             */
21564 
            public static function union($query, $all = false)
21565 
            {
21566 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21567 
                                return $instance->union($query, $all);
21568 
            }
21569 
 
21570 
                /**
21571 
             * Add a union all statement to the query.
21572 
             *
21573 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder $query
21574 
             * @return \Illuminate\Database\Query\Builder
21575 
             * @static
21576 
             */
21577 
            public static function unionAll($query)
21578 
            {
21579 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21580 
                                return $instance->unionAll($query);
21581 
            }
21582 
 
21583 
                /**
21584 
             * Lock the selected rows in the table.
21585 
             *
21586 
             * @param string|bool $value
21587 
             * @return \Illuminate\Database\Query\Builder
21588 
             * @static
21589 
             */
21590 
            public static function lock($value = true)
21591 
            {
21592 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21593 
                                return $instance->lock($value);
21594 
            }
21595 
 
21596 
                /**
21597 
             * Lock the selected rows in the table for updating.
21598 
             *
21599 
             * @return \Illuminate\Database\Query\Builder
21600 
             * @static
21601 
             */
21602 
            public static function lockForUpdate()
21603 
            {
21604 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21605 
                                return $instance->lockForUpdate();
21606 
            }
21607 
 
21608 
                /**
21609 
             * Share lock the selected rows in the table.
21610 
             *
21611 
             * @return \Illuminate\Database\Query\Builder
21612 
             * @static
21613 
             */
21614 
            public static function sharedLock()
21615 
            {
21616 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21617 
                                return $instance->sharedLock();
21618 
            }
21619 
 
21620 
                /**
21621 
             * Register a closure to be invoked before the query is executed.
21622 
             *
21623 
             * @param callable $callback
21624 
             * @return \Illuminate\Database\Query\Builder
21625 
             * @static
21626 
             */
21627 
            public static function beforeQuery($callback)
21628 
            {
21629 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21630 
                                return $instance->beforeQuery($callback);
21631 
            }
21632 
 
21633 
                /**
21634 
             * Invoke the "before query" modification callbacks.
21635 
             *
21636 
             * @return void
21637 
             * @static
21638 
             */
21639 
            public static function applyBeforeQueryCallbacks()
21640 
            {
21641 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21642 
                                $instance->applyBeforeQueryCallbacks();
21643 
            }
21644 
 
21645 
                /**
21646 
             * Get the SQL representation of the query.
21647 
             *
21648 
             * @return string
21649 
             * @static
21650 
             */
21651 
            public static function toSql()
21652 
            {
21653 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21654 
                                return $instance->toSql();
21655 
            }
21656 
 
21657 
                /**
21658 
             * Get a single expression value from the first result of a query.
21659 
             *
21660 
             * @param string $expression
21661 
             * @param array $bindings
21662 
             * @return mixed
21663 
             * @static
21664 
             */
21665 
            public static function rawValue($expression, $bindings = [])
21666 
            {
21667 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21668 
                                return $instance->rawValue($expression, $bindings);
21669 
            }
21670 
 
21671 
                /**
21672 
             * Get the count of the total records for the paginator.
21673 
             *
21674 
             * @param array $columns
21675 
             * @return int
21676 
             * @static
21677 
             */
21678 
            public static function getCountForPagination($columns = [])
21679 
            {
21680 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21681 
                                return $instance->getCountForPagination($columns);
21682 
            }
21683 
 
21684 
                /**
21685 
             * Concatenate values of a given column as a string.
21686 
             *
21687 
             * @param string $column
21688 
             * @param string $glue
21689 
             * @return string
21690 
             * @static
21691 
             */
21692 
            public static function implode($column, $glue = '')
21693 
            {
21694 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21695 
                                return $instance->implode($column, $glue);
21696 
            }
21697 
 
21698 
                /**
21699 
             * Determine if any rows exist for the current query.
21700 
             *
21701 
             * @return bool
21702 
             * @static
21703 
             */
21704 
            public static function exists()
21705 
            {
21706 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21707 
                                return $instance->exists();
21708 
            }
21709 
 
21710 
                /**
21711 
             * Determine if no rows exist for the current query.
21712 
             *
21713 
             * @return bool
21714 
             * @static
21715 
             */
21716 
            public static function doesntExist()
21717 
            {
21718 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21719 
                                return $instance->doesntExist();
21720 
            }
21721 
 
21722 
                /**
21723 
             * Execute the given callback if no rows exist for the current query.
21724 
             *
21725 
             * @param \Closure $callback
21726 
             * @return mixed
21727 
             * @static
21728 
             */
21729 
            public static function existsOr($callback)
21730 
            {
21731 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21732 
                                return $instance->existsOr($callback);
21733 
            }
21734 
 
21735 
                /**
21736 
             * Execute the given callback if rows exist for the current query.
21737 
             *
21738 
             * @param \Closure $callback
21739 
             * @return mixed
21740 
             * @static
21741 
             */
21742 
            public static function doesntExistOr($callback)
21743 
            {
21744 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21745 
                                return $instance->doesntExistOr($callback);
21746 
            }
21747 
 
21748 
                /**
21749 
             * Retrieve the "count" result of the query.
21750 
             *
21751 
             * @param string $columns
21752 
             * @return int
21753 
             * @static
21754 
             */
21755 
            public static function count($columns = '*')
21756 
            {
21757 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21758 
                                return $instance->count($columns);
21759 
            }
21760 
 
21761 
                /**
21762 
             * Retrieve the minimum value of a given column.
21763 
             *
21764 
             * @param string $column
21765 
             * @return mixed
21766 
             * @static
21767 
             */
21768 
            public static function min($column)
21769 
            {
21770 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21771 
                                return $instance->min($column);
21772 
            }
21773 
 
21774 
                /**
21775 
             * Retrieve the maximum value of a given column.
21776 
             *
21777 
             * @param string $column
21778 
             * @return mixed
21779 
             * @static
21780 
             */
21781 
            public static function max($column)
21782 
            {
21783 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21784 
                                return $instance->max($column);
21785 
            }
21786 
 
21787 
                /**
21788 
             * Retrieve the sum of the values of a given column.
21789 
             *
21790 
             * @param string $column
21791 
             * @return mixed
21792 
             * @static
21793 
             */
21794 
            public static function sum($column)
21795 
            {
21796 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21797 
                                return $instance->sum($column);
21798 
            }
21799 
 
21800 
                /**
21801 
             * Retrieve the average of the values of a given column.
21802 
             *
21803 
             * @param string $column
21804 
             * @return mixed
21805 
             * @static
21806 
             */
21807 
            public static function avg($column)
21808 
            {
21809 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21810 
                                return $instance->avg($column);
21811 
            }
21812 
 
21813 
                /**
21814 
             * Alias for the "avg" method.
21815 
             *
21816 
             * @param string $column
21817 
             * @return mixed
21818 
             * @static
21819 
             */
21820 
            public static function average($column)
21821 
            {
21822 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21823 
                                return $instance->average($column);
21824 
            }
21825 
 
21826 
                /**
21827 
             * Execute an aggregate function on the database.
21828 
             *
21829 
             * @param string $function
21830 
             * @param array $columns
21831 
             * @return mixed
21832 
             * @static
21833 
             */
21834 
            public static function aggregate($function, $columns = [])
21835 
            {
21836 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21837 
                                return $instance->aggregate($function, $columns);
21838 
            }
21839 
 
21840 
                /**
21841 
             * Execute a numeric aggregate function on the database.
21842 
             *
21843 
             * @param string $function
21844 
             * @param array $columns
21845 
             * @return float|int
21846 
             * @static
21847 
             */
21848 
            public static function numericAggregate($function, $columns = [])
21849 
            {
21850 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21851 
                                return $instance->numericAggregate($function, $columns);
21852 
            }
21853 
 
21854 
                /**
21855 
             * Insert new records into the database.
21856 
             *
21857 
             * @param array $values
21858 
             * @return bool
21859 
             * @static
21860 
             */
21861 
            public static function insert($values)
21862 
            {
21863 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21864 
                                return $instance->insert($values);
21865 
            }
21866 
 
21867 
                /**
21868 
             * Insert new records into the database while ignoring errors.
21869 
             *
21870 
             * @param array $values
21871 
             * @return int
21872 
             * @static
21873 
             */
21874 
            public static function insertOrIgnore($values)
21875 
            {
21876 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21877 
                                return $instance->insertOrIgnore($values);
21878 
            }
21879 
 
21880 
                /**
21881 
             * Insert a new record and get the value of the primary key.
21882 
             *
21883 
             * @param array $values
21884 
             * @param string|null $sequence
21885 
             * @return int
21886 
             * @static
21887 
             */
21888 
            public static function insertGetId($values, $sequence = null)
21889 
            {
21890 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21891 
                                return $instance->insertGetId($values, $sequence);
21892 
            }
21893 
 
21894 
                /**
21895 
             * Insert new records into the table using a subquery.
21896 
             *
21897 
             * @param array $columns
21898 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
21899 
             * @return int
21900 
             * @static
21901 
             */
21902 
            public static function insertUsing($columns, $query)
21903 
            {
21904 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21905 
                                return $instance->insertUsing($columns, $query);
21906 
            }
21907 
 
21908 
                /**
21909 
             * Update records in a PostgreSQL database using the update from syntax.
21910 
             *
21911 
             * @param array $values
21912 
             * @return int
21913 
             * @static
21914 
             */
21915 
            public static function updateFrom($values)
21916 
            {
21917 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21918 
                                return $instance->updateFrom($values);
21919 
            }
21920 
 
21921 
                /**
21922 
             * Insert or update a record matching the attributes, and fill it with values.
21923 
             *
21924 
             * @param array $attributes
21925 
             * @param array $values
21926 
             * @return bool
21927 
             * @static
21928 
             */
21929 
            public static function updateOrInsert($attributes, $values = [])
21930 
            {
21931 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21932 
                                return $instance->updateOrInsert($attributes, $values);
21933 
            }
21934 
 
21935 
                /**
21936 
             * Increment the given column's values by the given amounts.
21937 
             *
21938 
             * @param \Illuminate\Database\Query\array<string,  float|int|numeric-string>  $columns
21939 
             * @param \Illuminate\Database\Query\array<string,  mixed>  $extra
21940 
             * @return int
21941 
             * @throws \InvalidArgumentException
21942 
             * @static
21943 
             */
21944 
            public static function incrementEach($columns, $extra = [])
21945 
            {
21946 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21947 
                                return $instance->incrementEach($columns, $extra);
21948 
            }
21949 
 
21950 
                /**
21951 
             * Decrement the given column's values by the given amounts.
21952 
             *
21953 
             * @param \Illuminate\Database\Query\array<string,  float|int|numeric-string>  $columns
21954 
             * @param \Illuminate\Database\Query\array<string,  mixed>  $extra
21955 
             * @return int
21956 
             * @throws \InvalidArgumentException
21957 
             * @static
21958 
             */
21959 
            public static function decrementEach($columns, $extra = [])
21960 
            {
21961 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21962 
                                return $instance->decrementEach($columns, $extra);
21963 
            }
21964 
 
21965 
                /**
21966 
             * Run a truncate statement on the table.
21967 
             *
21968 
             * @return void
21969 
             * @static
21970 
             */
21971 
            public static function truncate()
21972 
            {
21973 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21974 
                                $instance->truncate();
21975 
            }
21976 
 
21977 
                /**
21978 
             * Create a raw database expression.
21979 
             *
21980 
             * @param mixed $value
21981 
             * @return \Illuminate\Database\Query\Expression
21982 
             * @static
21983 
             */
21984 
            public static function raw($value)
21985 
            {
21986 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21987 
                                return $instance->raw($value);
21988 
            }
21989 
 
21990 
                /**
21991 
             * Get the current query value bindings in a flattened array.
21992 
             *
21993 
             * @return array
21994 
             * @static
21995 
             */
21996 
            public static function getBindings()
21997 
            {
21998 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21999 
                                return $instance->getBindings();
22000 
            }
22001 
 
22002 
                /**
22003 
             * Get the raw array of bindings.
22004 
             *
22005 
             * @return array
22006 
             * @static
22007 
             */
22008 
            public static function getRawBindings()
22009 
            {
22010 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22011 
                                return $instance->getRawBindings();
22012 
            }
22013 
 
22014 
                /**
22015 
             * Set the bindings on the query builder.
22016 
             *
22017 
             * @param array $bindings
22018 
             * @param string $type
22019 
             * @return \Illuminate\Database\Query\Builder
22020 
             * @throws \InvalidArgumentException
22021 
             * @static
22022 
             */
22023 
            public static function setBindings($bindings, $type = 'where')
22024 
            {
22025 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22026 
                                return $instance->setBindings($bindings, $type);
22027 
            }
22028 
 
22029 
                /**
22030 
             * Add a binding to the query.
22031 
             *
22032 
             * @param mixed $value
22033 
             * @param string $type
22034 
             * @return \Illuminate\Database\Query\Builder
22035 
             * @throws \InvalidArgumentException
22036 
             * @static
22037 
             */
22038 
            public static function addBinding($value, $type = 'where')
22039 
            {
22040 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22041 
                                return $instance->addBinding($value, $type);
22042 
            }
22043 
 
22044 
                /**
22045 
             * Cast the given binding value.
22046 
             *
22047 
             * @param mixed $value
22048 
             * @return mixed
22049 
             * @static
22050 
             */
22051 
            public static function castBinding($value)
22052 
            {
22053 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22054 
                                return $instance->castBinding($value);
22055 
            }
22056 
 
22057 
                /**
22058 
             * Merge an array of bindings into our bindings.
22059 
             *
22060 
             * @param \Illuminate\Database\Query\Builder $query
22061 
             * @return \Illuminate\Database\Query\Builder
22062 
             * @static
22063 
             */
22064 
            public static function mergeBindings($query)
22065 
            {
22066 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22067 
                                return $instance->mergeBindings($query);
22068 
            }
22069 
 
22070 
                /**
22071 
             * Remove all of the expressions from a list of bindings.
22072 
             *
22073 
             * @param array $bindings
22074 
             * @return array
22075 
             * @static
22076 
             */
22077 
            public static function cleanBindings($bindings)
22078 
            {
22079 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22080 
                                return $instance->cleanBindings($bindings);
22081 
            }
22082 
 
22083 
                /**
22084 
             * Get the database query processor instance.
22085 
             *
22086 
             * @return \Illuminate\Database\Query\Processors\Processor
22087 
             * @static
22088 
             */
22089 
            public static function getProcessor()
22090 
            {
22091 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22092 
                                return $instance->getProcessor();
22093 
            }
22094 
 
22095 
                /**
22096 
             * Get the query grammar instance.
22097 
             *
22098 
             * @return \Illuminate\Database\Query\Grammars\Grammar
22099 
             * @static
22100 
             */
22101 
            public static function getGrammar()
22102 
            {
22103 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22104 
                                return $instance->getGrammar();
22105 
            }
22106 
 
22107 
                /**
22108 
             * Use the "write" PDO connection when executing the query.
22109 
             *
22110 
             * @return \Illuminate\Database\Query\Builder
22111 
             * @static
22112 
             */
22113 
            public static function useWritePdo()
22114 
            {
22115 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22116 
                                return $instance->useWritePdo();
22117 
            }
22118 
 
22119 
                /**
22120 
             * Clone the query without the given properties.
22121 
             *
22122 
             * @param array $properties
22123 
             * @return static
22124 
             * @static
22125 
             */
22126 
            public static function cloneWithout($properties)
22127 
            {
22128 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22129 
                                return $instance->cloneWithout($properties);
22130 
            }
22131 
 
22132 
                /**
22133 
             * Clone the query without the given bindings.
22134 
             *
22135 
             * @param array $except
22136 
             * @return static
22137 
             * @static
22138 
             */
22139 
            public static function cloneWithoutBindings($except)
22140 
            {
22141 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22142 
                                return $instance->cloneWithoutBindings($except);
22143 
            }
22144 
 
22145 
                /**
22146 
             * Dump the current SQL and bindings.
22147 
             *
22148 
             * @return \Illuminate\Database\Query\Builder
22149 
             * @static
22150 
             */
22151 
            public static function dump()
22152 
            {
22153 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22154 
                                return $instance->dump();
22155 
            }
22156 
 
22157 
                /**
22158 
             * Die and dump the current SQL and bindings.
22159 
             *
22160 
             * @return \Illuminate\Database\Query\never
22161 
             * @static
22162 
             */
22163 
            public static function dd()
22164 
            {
22165 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22166 
                                return $instance->dd();
22167 
            }
22168 
 
22169 
                /**
22170 
             * Explains the query.
22171 
             *
22172 
             * @return \Illuminate\Support\Collection
22173 
             * @static
22174 
             */
22175 
            public static function explain()
22176 
            {
22177 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22178 
                                return $instance->explain();
22179 
            }
22180 
 
22181 
                /**
22182 
             * Register a custom macro.
22183 
             *
22184 
             * @param string $name
22185 
             * @param object|callable $macro
22186 
             * @return void
22187 
             * @static
22188 
             */
22189 
            public static function macro($name, $macro)
22190 
            {
22191 
                                \Illuminate\Database\Query\Builder::macro($name, $macro);
22192 
            }
22193 
 
22194 
                /**
22195 
             * Mix another object into the class.
22196 
             *
22197 
             * @param object $mixin
22198 
             * @param bool $replace
22199 
             * @return void
22200 
             * @throws \ReflectionException
22201 
             * @static
22202 
             */
22203 
            public static function mixin($mixin, $replace = true)
22204 
            {
22205 
                                \Illuminate\Database\Query\Builder::mixin($mixin, $replace);
22206 
            }
22207 
 
22208 
                /**
22209 
             * Flush the existing macros.
22210 
             *
22211 
             * @return void
22212 
             * @static
22213 
             */
22214 
            public static function flushMacros()
22215 
            {
22216 
                                \Illuminate\Database\Query\Builder::flushMacros();
22217 
            }
22218 
 
22219 
                /**
22220 
             * Dynamically handle calls to the class.
22221 
             *
22222 
             * @param string $method
22223 
             * @param array $parameters
22224 
             * @return mixed
22225 
             * @throws \BadMethodCallException
22226 
             * @static
22227 
             */
22228 
            public static function macroCall($method, $parameters)
22229 
            {
22230 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22231 
                                return $instance->macroCall($method, $parameters);
22232 
            }
22233 
                    }
22234 
            class Event extends \Illuminate\Support\Facades\Event {}
22235 
            class File extends \Illuminate\Support\Facades\File {}
22236 
            class Gate extends \Illuminate\Support\Facades\Gate {}
22237 
            class Hash extends \Illuminate\Support\Facades\Hash {}
22238 
            class Http extends \Illuminate\Support\Facades\Http {}
22239 
            class Js extends \Illuminate\Support\Js {}
22240 
            class Lang extends \Illuminate\Support\Facades\Lang {}
22241 
            class Log extends \Illuminate\Support\Facades\Log {}
22242 
            class Mail extends \Illuminate\Support\Facades\Mail {}
22243 
            class Notification extends \Illuminate\Support\Facades\Notification {}
22244 
            class Password extends \Illuminate\Support\Facades\Password {}
22245 
            class Queue extends \Illuminate\Support\Facades\Queue {}
22246 
            class RateLimiter extends \Illuminate\Support\Facades\RateLimiter {}
22247 
            class Redirect extends \Illuminate\Support\Facades\Redirect {}
22248 
            class Request extends \Illuminate\Support\Facades\Request {}
22249 
            class Response extends \Illuminate\Support\Facades\Response {}
22250 
            class Route extends \Illuminate\Support\Facades\Route {}
22251 
            class Schema extends \Illuminate\Support\Facades\Schema {}
22252 
            class Session extends \Illuminate\Support\Facades\Session {}
22253 
            class Storage extends \Illuminate\Support\Facades\Storage {}
22254 
            class Str extends \Illuminate\Support\Str {}
22255 
            class URL extends \Illuminate\Support\Facades\URL {}
22256 
            class Validator extends \Illuminate\Support\Facades\Validator {}
22257 
            class View extends \Illuminate\Support\Facades\View {}
22258 
            class Vite extends \Illuminate\Support\Facades\Vite {}
22259 
            class PayPal extends \Srmklive\PayPal\Facades\PayPal {}
22260 
            class Clockwork extends \Clockwork\Support\Laravel\Facade {}
22261 
            class Flare extends \Spatie\LaravelIgnition\Facades\Flare {}
22262 
 
22263 
}
22264 
 
22265 
 
22266 
 
22267