Subversion-Projekte lars-tiefland.webanos.marine-sales.de

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
415 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.15.
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 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\BackendUser|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\BackendUser|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\BackendUser|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\BackendUser|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\BackendUser
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\BackendUser|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\BackendUser
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 
         * @return void
10960 
         * @static
10961 
         */
10962 
        public static function initialize($query = [], $request = [], $attributes = [], $cookies = [], $files = [], $server = [], $content = null)
10963 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
10964 
                        /** @var \Illuminate\Http\Request $instance */
10965 
                        $instance->initialize($query, $request, $attributes, $cookies, $files, $server, $content);
10966 
        }
10967 
                    /**
10968 
         * Creates a new request with values from PHP's super globals.
10969 
         *
10970 
         * @static
10971 
         */
10972 
        public static function createFromGlobals()
10973 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
10974 
                        return \Illuminate\Http\Request::createFromGlobals();
10975 
        }
10976 
                    /**
10977 
         * Creates a Request based on a given URI and configuration.
10978 
         *
10979 
         * The information contained in the URI always take precedence
10980 
         * over the other information (server and parameters).
10981 
         *
10982 
         * @param string $uri The URI
10983 
         * @param string $method The HTTP method
10984 
         * @param array $parameters The query (GET) or request (POST) parameters
10985 
         * @param array $cookies The request cookies ($_COOKIE)
10986 
         * @param array $files The request files ($_FILES)
10987 
         * @param array $server The server parameters ($_SERVER)
10988 
         * @param string|resource|null $content The raw body data
10989 
         * @static
10990 
         */
10991 
        public static function create($uri, $method = 'GET', $parameters = [], $cookies = [], $files = [], $server = [], $content = null)
10992 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
10993 
                        return \Illuminate\Http\Request::create($uri, $method, $parameters, $cookies, $files, $server, $content);
10994 
        }
10995 
                    /**
10996 
         * Sets a callable able to create a Request instance.
10997 
         *
10998 
         * This is mainly useful when you need to override the Request class
10999 
         * to keep BC with an existing system. It should not be used for any
11000 
         * other purpose.
11001 
         *
11002 
         * @return void
11003 
         * @static
11004 
         */
11005 
        public static function setFactory($callable)
11006 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11007 
                        \Illuminate\Http\Request::setFactory($callable);
11008 
        }
11009 
                    /**
11010 
         * Overrides the PHP global variables according to this request instance.
11011 
         *
11012 
         * It overrides $_GET, $_POST, $_REQUEST, $_SERVER, $_COOKIE.
11013 
         * $_FILES is never overridden, see rfc1867
11014 
         *
11015 
         * @return void
11016 
         * @static
11017 
         */
11018 
        public static function overrideGlobals()
11019 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11020 
                        /** @var \Illuminate\Http\Request $instance */
11021 
                        $instance->overrideGlobals();
11022 
        }
11023 
                    /**
11024 
         * Sets a list of trusted proxies.
11025 
         *
11026 
         * You should only list the reverse proxies that you manage directly.
11027 
         *
11028 
         * @param array $proxies A list of trusted proxies, the string 'REMOTE_ADDR' will be replaced with $_SERVER['REMOTE_ADDR']
11029 
         * @param int $trustedHeaderSet A bit field of Request::HEADER_*, to set which headers to trust from your proxies
11030 
         * @return void
11031 
         * @static
11032 
         */
11033 
        public static function setTrustedProxies($proxies, $trustedHeaderSet)
11034 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11035 
                        \Illuminate\Http\Request::setTrustedProxies($proxies, $trustedHeaderSet);
11036 
        }
11037 
                    /**
11038 
         * Gets the list of trusted proxies.
11039 
         *
11040 
         * @return string[]
11041 
         * @static
11042 
         */
11043 
        public static function getTrustedProxies()
11044 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11045 
                        return \Illuminate\Http\Request::getTrustedProxies();
11046 
        }
11047 
                    /**
11048 
         * Gets the set of trusted headers from trusted proxies.
11049 
         *
11050 
         * @return int A bit field of Request::HEADER_* that defines which headers are trusted from your proxies
11051 
         * @static
11052 
         */
11053 
        public static function getTrustedHeaderSet()
11054 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11055 
                        return \Illuminate\Http\Request::getTrustedHeaderSet();
11056 
        }
11057 
                    /**
11058 
         * Sets a list of trusted host patterns.
11059 
         *
11060 
         * You should only list the hosts you manage using regexs.
11061 
         *
11062 
         * @param array $hostPatterns A list of trusted host patterns
11063 
         * @return void
11064 
         * @static
11065 
         */
11066 
        public static function setTrustedHosts($hostPatterns)
11067 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11068 
                        \Illuminate\Http\Request::setTrustedHosts($hostPatterns);
11069 
        }
11070 
                    /**
11071 
         * Gets the list of trusted host patterns.
11072 
         *
11073 
         * @return string[]
11074 
         * @static
11075 
         */
11076 
        public static function getTrustedHosts()
11077 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11078 
                        return \Illuminate\Http\Request::getTrustedHosts();
11079 
        }
11080 
                    /**
11081 
         * Normalizes a query string.
11082 
         *
11083 
         * It builds a normalized query string, where keys/value pairs are alphabetized,
11084 
         * have consistent escaping and unneeded delimiters are removed.
11085 
         *
11086 
         * @static
11087 
         */
11088 
        public static function normalizeQueryString($qs)
11089 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11090 
                        return \Illuminate\Http\Request::normalizeQueryString($qs);
11091 
        }
11092 
                    /**
11093 
         * Enables support for the _method request parameter to determine the intended HTTP method.
11094 
         *
11095 
         * Be warned that enabling this feature might lead to CSRF issues in your code.
11096 
         * Check that you are using CSRF tokens when required.
11097 
         * If the HTTP method parameter override is enabled, an html-form with method "POST" can be altered
11098 
         * and used to send a "PUT" or "DELETE" request via the _method request parameter.
11099 
         * If these methods are not protected against CSRF, this presents a possible vulnerability.
11100 
         *
11101 
         * The HTTP method can only be overridden when the real HTTP method is POST.
11102 
         *
11103 
         * @return void
11104 
         * @static
11105 
         */
11106 
        public static function enableHttpMethodParameterOverride()
11107 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11108 
                        \Illuminate\Http\Request::enableHttpMethodParameterOverride();
11109 
        }
11110 
                    /**
11111 
         * Checks whether support for the _method request parameter is enabled.
11112 
         *
11113 
         * @static
11114 
         */
11115 
        public static function getHttpMethodParameterOverride()
11116 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11117 
                        return \Illuminate\Http\Request::getHttpMethodParameterOverride();
11118 
        }
11119 
                    /**
11120 
         * Whether the request contains a Session which was started in one of the
11121 
         * previous requests.
11122 
         *
11123 
         * @static
11124 
         */
11125 
        public static function hasPreviousSession()
11126 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11127 
                        /** @var \Illuminate\Http\Request $instance */
11128 
                        return $instance->hasPreviousSession();
11129 
        }
11130 
                    /**
11131 
         *
11132 
         *
11133 
         * @return void
11134 
         * @static
11135 
         */
11136 
        public static function setSession($session)
11137 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11138 
                        /** @var \Illuminate\Http\Request $instance */
11139 
                        $instance->setSession($session);
11140 
        }
11141 
                    /**
11142 
         *
11143 
         *
11144 
         * @internal
11145 
         * @param \Symfony\Component\HttpFoundation\callable():  SessionInterface $factory
11146 
         * @static
11147 
         */
11148 
        public static function setSessionFactory($factory)
11149 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11150 
                        /** @var \Illuminate\Http\Request $instance */
11151 
                        return $instance->setSessionFactory($factory);
11152 
        }
11153 
                    /**
11154 
         * Returns the client IP addresses.
11155 
         *
11156 
         * In the returned array the most trusted IP address is first, and the
11157 
         * least trusted one last. The "real" client IP address is the last one,
11158 
         * but this is also the least trusted one. Trusted proxies are stripped.
11159 
         *
11160 
         * Use this method carefully; you should use getClientIp() instead.
11161 
         *
11162 
         * @see getClientIp()
11163 
         * @static
11164 
         */
11165 
        public static function getClientIps()
11166 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11167 
                        /** @var \Illuminate\Http\Request $instance */
11168 
                        return $instance->getClientIps();
11169 
        }
11170 
                    /**
11171 
         * Returns the client IP address.
11172 
         *
11173 
         * This method can read the client IP address from the "X-Forwarded-For" header
11174 
         * when trusted proxies were set via "setTrustedProxies()". The "X-Forwarded-For"
11175 
         * header value is a comma+space separated list of IP addresses, the left-most
11176 
         * being the original client, and each successive proxy that passed the request
11177 
         * adding the IP address where it received the request from.
11178 
         *
11179 
         * If your reverse proxy uses a different header name than "X-Forwarded-For",
11180 
         * ("Client-Ip" for instance), configure it via the $trustedHeaderSet
11181 
         * argument of the Request::setTrustedProxies() method instead.
11182 
         *
11183 
         * @see getClientIps()
11184 
         * @see https://wikipedia.org/wiki/X-Forwarded-For
11185 
         * @static
11186 
         */
11187 
        public static function getClientIp()
11188 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11189 
                        /** @var \Illuminate\Http\Request $instance */
11190 
                        return $instance->getClientIp();
11191 
        }
11192 
                    /**
11193 
         * Returns current script name.
11194 
         *
11195 
         * @static
11196 
         */
11197 
        public static function getScriptName()
11198 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11199 
                        /** @var \Illuminate\Http\Request $instance */
11200 
                        return $instance->getScriptName();
11201 
        }
11202 
                    /**
11203 
         * Returns the path being requested relative to the executed script.
11204 
         *
11205 
         * The path info always starts with a /.
11206 
         *
11207 
         * Suppose this request is instantiated from /mysite on localhost:
11208 
         *
11209 
         *  * http://localhost/mysite              returns an empty string
11210 
         *  * http://localhost/mysite/about        returns '/about'
11211 
         *  * http://localhost/mysite/enco%20ded   returns '/enco%20ded'
11212 
         *  * http://localhost/mysite/about?var=1  returns '/about'
11213 
         *
11214 
         * @return string The raw path (i.e. not urldecoded)
11215 
         * @static
11216 
         */
11217 
        public static function getPathInfo()
11218 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11219 
                        /** @var \Illuminate\Http\Request $instance */
11220 
                        return $instance->getPathInfo();
11221 
        }
11222 
                    /**
11223 
         * Returns the root path from which this request is executed.
11224 
         *
11225 
         * Suppose that an index.php file instantiates this request object:
11226 
         *
11227 
         *  * http://localhost/index.php         returns an empty string
11228 
         *  * http://localhost/index.php/page    returns an empty string
11229 
         *  * http://localhost/web/index.php     returns '/web'
11230 
         *  * http://localhost/we%20b/index.php  returns '/we%20b'
11231 
         *
11232 
         * @return string The raw path (i.e. not urldecoded)
11233 
         * @static
11234 
         */
11235 
        public static function getBasePath()
11236 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11237 
                        /** @var \Illuminate\Http\Request $instance */
11238 
                        return $instance->getBasePath();
11239 
        }
11240 
                    /**
11241 
         * Returns the root URL from which this request is executed.
11242 
         *
11243 
         * The base URL never ends with a /.
11244 
         *
11245 
         * This is similar to getBasePath(), except that it also includes the
11246 
         * script filename (e.g. index.php) if one exists.
11247 
         *
11248 
         * @return string The raw URL (i.e. not urldecoded)
11249 
         * @static
11250 
         */
11251 
        public static function getBaseUrl()
11252 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11253 
                        /** @var \Illuminate\Http\Request $instance */
11254 
                        return $instance->getBaseUrl();
11255 
        }
11256 
                    /**
11257 
         * Gets the request's scheme.
11258 
         *
11259 
         * @static
11260 
         */
11261 
        public static function getScheme()
11262 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11263 
                        /** @var \Illuminate\Http\Request $instance */
11264 
                        return $instance->getScheme();
11265 
        }
11266 
                    /**
11267 
         * Returns the port on which the request is made.
11268 
         *
11269 
         * This method can read the client port from the "X-Forwarded-Port" header
11270 
         * when trusted proxies were set via "setTrustedProxies()".
11271 
         *
11272 
         * The "X-Forwarded-Port" header must contain the client port.
11273 
         *
11274 
         * @return int|string|null Can be a string if fetched from the server bag
11275 
         * @static
11276 
         */
11277 
        public static function getPort()
11278 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11279 
                        /** @var \Illuminate\Http\Request $instance */
11280 
                        return $instance->getPort();
11281 
        }
11282 
                    /**
11283 
         * Returns the user.
11284 
         *
11285 
         * @static
11286 
         */
11287 
        public static function getUser()
11288 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11289 
                        /** @var \Illuminate\Http\Request $instance */
11290 
                        return $instance->getUser();
11291 
        }
11292 
                    /**
11293 
         * Returns the password.
11294 
         *
11295 
         * @static
11296 
         */
11297 
        public static function getPassword()
11298 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11299 
                        /** @var \Illuminate\Http\Request $instance */
11300 
                        return $instance->getPassword();
11301 
        }
11302 
                    /**
11303 
         * Gets the user info.
11304 
         *
11305 
         * @return string|null A user name if any and, optionally, scheme-specific information about how to gain authorization to access the server
11306 
         * @static
11307 
         */
11308 
        public static function getUserInfo()
11309 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11310 
                        /** @var \Illuminate\Http\Request $instance */
11311 
                        return $instance->getUserInfo();
11312 
        }
11313 
                    /**
11314 
         * Returns the HTTP host being requested.
11315 
         *
11316 
         * The port name will be appended to the host if it's non-standard.
11317 
         *
11318 
         * @static
11319 
         */
11320 
        public static function getHttpHost()
11321 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11322 
                        /** @var \Illuminate\Http\Request $instance */
11323 
                        return $instance->getHttpHost();
11324 
        }
11325 
                    /**
11326 
         * Returns the requested URI (path and query string).
11327 
         *
11328 
         * @return string The raw URI (i.e. not URI decoded)
11329 
         * @static
11330 
         */
11331 
        public static function getRequestUri()
11332 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11333 
                        /** @var \Illuminate\Http\Request $instance */
11334 
                        return $instance->getRequestUri();
11335 
        }
11336 
                    /**
11337 
         * Gets the scheme and HTTP host.
11338 
         *
11339 
         * If the URL was called with basic authentication, the user
11340 
         * and the password are not added to the generated string.
11341 
         *
11342 
         * @static
11343 
         */
11344 
        public static function getSchemeAndHttpHost()
11345 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11346 
                        /** @var \Illuminate\Http\Request $instance */
11347 
                        return $instance->getSchemeAndHttpHost();
11348 
        }
11349 
                    /**
11350 
         * Generates a normalized URI (URL) for the Request.
11351 
         *
11352 
         * @see getQueryString()
11353 
         * @static
11354 
         */
11355 
        public static function getUri()
11356 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11357 
                        /** @var \Illuminate\Http\Request $instance */
11358 
                        return $instance->getUri();
11359 
        }
11360 
                    /**
11361 
         * Generates a normalized URI for the given path.
11362 
         *
11363 
         * @param string $path A path to use instead of the current one
11364 
         * @static
11365 
         */
11366 
        public static function getUriForPath($path)
11367 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11368 
                        /** @var \Illuminate\Http\Request $instance */
11369 
                        return $instance->getUriForPath($path);
11370 
        }
11371 
                    /**
11372 
         * Returns the path as relative reference from the current Request path.
11373 
         *
11374 
         * Only the URIs path component (no schema, host etc.) is relevant and must be given.
11375 
         * Both paths must be absolute and not contain relative parts.
11376 
         * Relative URLs from one resource to another are useful when generating self-contained downloadable document archives.
11377 
         * Furthermore, they can be used to reduce the link size in documents.
11378 
         *
11379 
         * Example target paths, given a base path of "/a/b/c/d":
11380 
         * - "/a/b/c/d"     -> ""
11381 
         * - "/a/b/c/"      -> "./"
11382 
         * - "/a/b/"        -> "../"
11383 
         * - "/a/b/c/other" -> "other"
11384 
         * - "/a/x/y"       -> "../../x/y"
11385 
         *
11386 
         * @static
11387 
         */
11388 
        public static function getRelativeUriForPath($path)
11389 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11390 
                        /** @var \Illuminate\Http\Request $instance */
11391 
                        return $instance->getRelativeUriForPath($path);
11392 
        }
11393 
                    /**
11394 
         * Generates the normalized query string for the Request.
11395 
         *
11396 
         * It builds a normalized query string, where keys/value pairs are alphabetized
11397 
         * and have consistent escaping.
11398 
         *
11399 
         * @static
11400 
         */
11401 
        public static function getQueryString()
11402 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11403 
                        /** @var \Illuminate\Http\Request $instance */
11404 
                        return $instance->getQueryString();
11405 
        }
11406 
                    /**
11407 
         * Checks whether the request is secure or not.
11408 
         *
11409 
         * This method can read the client protocol from the "X-Forwarded-Proto" header
11410 
         * when trusted proxies were set via "setTrustedProxies()".
11411 
         *
11412 
         * The "X-Forwarded-Proto" header must contain the protocol: "https" or "http".
11413 
         *
11414 
         * @static
11415 
         */
11416 
        public static function isSecure()
11417 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11418 
                        /** @var \Illuminate\Http\Request $instance */
11419 
                        return $instance->isSecure();
11420 
        }
11421 
                    /**
11422 
         * Returns the host name.
11423 
         *
11424 
         * This method can read the client host name from the "X-Forwarded-Host" header
11425 
         * when trusted proxies were set via "setTrustedProxies()".
11426 
         *
11427 
         * The "X-Forwarded-Host" header must contain the client host name.
11428 
         *
11429 
         * @throws SuspiciousOperationException when the host name is invalid or not trusted
11430 
         * @static
11431 
         */
11432 
        public static function getHost()
11433 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11434 
                        /** @var \Illuminate\Http\Request $instance */
11435 
                        return $instance->getHost();
11436 
        }
11437 
                    /**
11438 
         * Sets the request method.
11439 
         *
11440 
         * @return void
11441 
         * @static
11442 
         */
11443 
        public static function setMethod($method)
11444 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11445 
                        /** @var \Illuminate\Http\Request $instance */
11446 
                        $instance->setMethod($method);
11447 
        }
11448 
                    /**
11449 
         * Gets the request "intended" method.
11450 
         *
11451 
         * If the X-HTTP-Method-Override header is set, and if the method is a POST,
11452 
         * then it is used to determine the "real" intended HTTP method.
11453 
         *
11454 
         * The _method request parameter can also be used to determine the HTTP method,
11455 
         * but only if enableHttpMethodParameterOverride() has been called.
11456 
         *
11457 
         * The method is always an uppercased string.
11458 
         *
11459 
         * @see getRealMethod()
11460 
         * @static
11461 
         */
11462 
        public static function getMethod()
11463 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11464 
                        /** @var \Illuminate\Http\Request $instance */
11465 
                        return $instance->getMethod();
11466 
        }
11467 
                    /**
11468 
         * Gets the "real" request method.
11469 
         *
11470 
         * @see getMethod()
11471 
         * @static
11472 
         */
11473 
        public static function getRealMethod()
11474 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11475 
                        /** @var \Illuminate\Http\Request $instance */
11476 
                        return $instance->getRealMethod();
11477 
        }
11478 
                    /**
11479 
         * Gets the mime type associated with the format.
11480 
         *
11481 
         * @static
11482 
         */
11483 
        public static function getMimeType($format)
11484 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11485 
                        /** @var \Illuminate\Http\Request $instance */
11486 
                        return $instance->getMimeType($format);
11487 
        }
11488 
                    /**
11489 
         * Gets the mime types associated with the format.
11490 
         *
11491 
         * @return string[]
11492 
         * @static
11493 
         */
11494 
        public static function getMimeTypes($format)
11495 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11496 
                        return \Illuminate\Http\Request::getMimeTypes($format);
11497 
        }
11498 
                    /**
11499 
         * Gets the format associated with the mime type.
11500 
         *
11501 
         * @static
11502 
         */
11503 
        public static function getFormat($mimeType)
11504 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11505 
                        /** @var \Illuminate\Http\Request $instance */
11506 
                        return $instance->getFormat($mimeType);
11507 
        }
11508 
                    /**
11509 
         * Associates a format with mime types.
11510 
         *
11511 
         * @param string|string[] $mimeTypes The associated mime types (the preferred one must be the first as it will be used as the content type)
11512 
         * @return void
11513 
         * @static
11514 
         */
11515 
        public static function setFormat($format, $mimeTypes)
11516 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11517 
                        /** @var \Illuminate\Http\Request $instance */
11518 
                        $instance->setFormat($format, $mimeTypes);
11519 
        }
11520 
                    /**
11521 
         * Gets the request format.
11522 
         *
11523 
         * Here is the process to determine the format:
11524 
         *
11525 
         *  * format defined by the user (with setRequestFormat())
11526 
         *  * _format request attribute
11527 
         *  * $default
11528 
         *
11529 
         * @see getPreferredFormat
11530 
         * @static
11531 
         */
11532 
        public static function getRequestFormat($default = 'html')
11533 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11534 
                        /** @var \Illuminate\Http\Request $instance */
11535 
                        return $instance->getRequestFormat($default);
11536 
        }
11537 
                    /**
11538 
         * Sets the request format.
11539 
         *
11540 
         * @return void
11541 
         * @static
11542 
         */
11543 
        public static function setRequestFormat($format)
11544 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11545 
                        /** @var \Illuminate\Http\Request $instance */
11546 
                        $instance->setRequestFormat($format);
11547 
        }
11548 
                    /**
11549 
         * Gets the usual name of the format associated with the request's media type (provided in the Content-Type header).
11550 
         *
11551 
         * @deprecated since Symfony 6.2, use getContentTypeFormat() instead
11552 
         * @static
11553 
         */
11554 
        public static function getContentType()
11555 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11556 
                        /** @var \Illuminate\Http\Request $instance */
11557 
                        return $instance->getContentType();
11558 
        }
11559 
                    /**
11560 
         * Gets the usual name of the format associated with the request's media type (provided in the Content-Type header).
11561 
         *
11562 
         * @see Request::$formats
11563 
         * @static
11564 
         */
11565 
        public static function getContentTypeFormat()
11566 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11567 
                        /** @var \Illuminate\Http\Request $instance */
11568 
                        return $instance->getContentTypeFormat();
11569 
        }
11570 
                    /**
11571 
         * Sets the default locale.
11572 
         *
11573 
         * @return void
11574 
         * @static
11575 
         */
11576 
        public static function setDefaultLocale($locale)
11577 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11578 
                        /** @var \Illuminate\Http\Request $instance */
11579 
                        $instance->setDefaultLocale($locale);
11580 
        }
11581 
                    /**
11582 
         * Get the default locale.
11583 
         *
11584 
         * @static
11585 
         */
11586 
        public static function getDefaultLocale()
11587 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11588 
                        /** @var \Illuminate\Http\Request $instance */
11589 
                        return $instance->getDefaultLocale();
11590 
        }
11591 
                    /**
11592 
         * Sets the locale.
11593 
         *
11594 
         * @return void
11595 
         * @static
11596 
         */
11597 
        public static function setLocale($locale)
11598 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11599 
                        /** @var \Illuminate\Http\Request $instance */
11600 
                        $instance->setLocale($locale);
11601 
        }
11602 
                    /**
11603 
         * Get the locale.
11604 
         *
11605 
         * @static
11606 
         */
11607 
        public static function getLocale()
11608 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11609 
                        /** @var \Illuminate\Http\Request $instance */
11610 
                        return $instance->getLocale();
11611 
        }
11612 
                    /**
11613 
         * Checks if the request method is of specified type.
11614 
         *
11615 
         * @param string $method Uppercase request method (GET, POST etc)
11616 
         * @static
11617 
         */
11618 
        public static function isMethod($method)
11619 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11620 
                        /** @var \Illuminate\Http\Request $instance */
11621 
                        return $instance->isMethod($method);
11622 
        }
11623 
                    /**
11624 
         * Checks whether or not the method is safe.
11625 
         *
11626 
         * @see https://tools.ietf.org/html/rfc7231#section-4.2.1
11627 
         * @static
11628 
         */
11629 
        public static function isMethodSafe()
11630 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11631 
                        /** @var \Illuminate\Http\Request $instance */
11632 
                        return $instance->isMethodSafe();
11633 
        }
11634 
                    /**
11635 
         * Checks whether or not the method is idempotent.
11636 
         *
11637 
         * @static
11638 
         */
11639 
        public static function isMethodIdempotent()
11640 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11641 
                        /** @var \Illuminate\Http\Request $instance */
11642 
                        return $instance->isMethodIdempotent();
11643 
        }
11644 
                    /**
11645 
         * Checks whether the method is cacheable or not.
11646 
         *
11647 
         * @see https://tools.ietf.org/html/rfc7231#section-4.2.3
11648 
         * @static
11649 
         */
11650 
        public static function isMethodCacheable()
11651 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11652 
                        /** @var \Illuminate\Http\Request $instance */
11653 
                        return $instance->isMethodCacheable();
11654 
        }
11655 
                    /**
11656 
         * Returns the protocol version.
11657 
         *
11658 
         * If the application is behind a proxy, the protocol version used in the
11659 
         * requests between the client and the proxy and between the proxy and the
11660 
         * server might be different. This returns the former (from the "Via" header)
11661 
         * if the proxy is trusted (see "setTrustedProxies()"), otherwise it returns
11662 
         * the latter (from the "SERVER_PROTOCOL" server parameter).
11663 
         *
11664 
         * @static
11665 
         */
11666 
        public static function getProtocolVersion()
11667 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11668 
                        /** @var \Illuminate\Http\Request $instance */
11669 
                        return $instance->getProtocolVersion();
11670 
        }
11671 
                    /**
11672 
         * Returns the request body content.
11673 
         *
11674 
         * @param bool $asResource If true, a resource will be returned
11675 
         * @return string|resource
11676 
         * @psalm-return ($asResource is true ? resource : string)
11677 
         * @static
11678 
         */
11679 
        public static function getContent($asResource = false)
11680 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11681 
                        /** @var \Illuminate\Http\Request $instance */
11682 
                        return $instance->getContent($asResource);
11683 
        }
11684 
                    /**
11685 
         * Gets the decoded form or json request body.
11686 
         *
11687 
         * @throws JsonException When the body cannot be decoded to an array
11688 
         * @static
11689 
         */
11690 
        public static function getPayload()
11691 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11692 
                        /** @var \Illuminate\Http\Request $instance */
11693 
                        return $instance->getPayload();
11694 
        }
11695 
                    /**
11696 
         * Gets the Etags.
11697 
         *
11698 
         * @static
11699 
         */
11700 
        public static function getETags()
11701 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11702 
                        /** @var \Illuminate\Http\Request $instance */
11703 
                        return $instance->getETags();
11704 
        }
11705 
                    /**
11706 
         *
11707 
         *
11708 
         * @static
11709 
         */
11710 
        public static function isNoCache()
11711 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11712 
                        /** @var \Illuminate\Http\Request $instance */
11713 
                        return $instance->isNoCache();
11714 
        }
11715 
                    /**
11716 
         * Gets the preferred format for the response by inspecting, in the following order:
11717 
         *   * the request format set using setRequestFormat;
11718 
         *   * the values of the Accept HTTP header.
11719 
         *
11720 
         * Note that if you use this method, you should send the "Vary: Accept" header
11721 
         * in the response to prevent any issues with intermediary HTTP caches.
11722 
         *
11723 
         * @static
11724 
         */
11725 
        public static function getPreferredFormat($default = 'html')
11726 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11727 
                        /** @var \Illuminate\Http\Request $instance */
11728 
                        return $instance->getPreferredFormat($default);
11729 
        }
11730 
                    /**
11731 
         * Returns the preferred language.
11732 
         *
11733 
         * @param string[] $locales An array of ordered available locales
11734 
         * @static
11735 
         */
11736 
        public static function getPreferredLanguage($locales = null)
11737 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11738 
                        /** @var \Illuminate\Http\Request $instance */
11739 
                        return $instance->getPreferredLanguage($locales);
11740 
        }
11741 
                    /**
11742 
         * Gets a list of languages acceptable by the client browser ordered in the user browser preferences.
11743 
         *
11744 
         * @return string[]
11745 
         * @static
11746 
         */
11747 
        public static function getLanguages()
11748 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11749 
                        /** @var \Illuminate\Http\Request $instance */
11750 
                        return $instance->getLanguages();
11751 
        }
11752 
                    /**
11753 
         * Gets a list of charsets acceptable by the client browser in preferable order.
11754 
         *
11755 
         * @return string[]
11756 
         * @static
11757 
         */
11758 
        public static function getCharsets()
11759 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11760 
                        /** @var \Illuminate\Http\Request $instance */
11761 
                        return $instance->getCharsets();
11762 
        }
11763 
                    /**
11764 
         * Gets a list of encodings acceptable by the client browser in preferable order.
11765 
         *
11766 
         * @return string[]
11767 
         * @static
11768 
         */
11769 
        public static function getEncodings()
11770 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11771 
                        /** @var \Illuminate\Http\Request $instance */
11772 
                        return $instance->getEncodings();
11773 
        }
11774 
                    /**
11775 
         * Gets a list of content types acceptable by the client browser in preferable order.
11776 
         *
11777 
         * @return string[]
11778 
         * @static
11779 
         */
11780 
        public static function getAcceptableContentTypes()
11781 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11782 
                        /** @var \Illuminate\Http\Request $instance */
11783 
                        return $instance->getAcceptableContentTypes();
11784 
        }
11785 
                    /**
11786 
         * Returns true if the request is an XMLHttpRequest.
11787 
         *
11788 
         * It works if your JavaScript library sets an X-Requested-With HTTP header.
11789 
         * It is known to work with common JavaScript frameworks:
11790 
         *
11791 
         * @see https://wikipedia.org/wiki/List_of_Ajax_frameworks#JavaScript
11792 
         * @static
11793 
         */
11794 
        public static function isXmlHttpRequest()
11795 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11796 
                        /** @var \Illuminate\Http\Request $instance */
11797 
                        return $instance->isXmlHttpRequest();
11798 
        }
11799 
                    /**
11800 
         * Checks whether the client browser prefers safe content or not according to RFC8674.
11801 
         *
11802 
         * @see https://tools.ietf.org/html/rfc8674
11803 
         * @static
11804 
         */
11805 
        public static function preferSafeContent()
11806 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11807 
                        /** @var \Illuminate\Http\Request $instance */
11808 
                        return $instance->preferSafeContent();
11809 
        }
11810 
                    /**
11811 
         * Indicates whether this request originated from a trusted proxy.
11812 
         *
11813 
         * This can be useful to determine whether or not to trust the
11814 
         * contents of a proxy-specific header.
11815 
         *
11816 
         * @static
11817 
         */
11818 
        public static function isFromTrustedProxy()
11819 
        {            //Method inherited from \Symfony\Component\HttpFoundation\Request
11820 
                        /** @var \Illuminate\Http\Request $instance */
11821 
                        return $instance->isFromTrustedProxy();
11822 
        }
11823 
                    /**
11824 
         * Filter the given array of rules into an array of rules that are included in precognitive headers.
11825 
         *
11826 
         * @param array $rules
11827 
         * @return array
11828 
         * @static
11829 
         */
11830 
        public static function filterPrecognitiveRules($rules)
11831 
        {
11832 
                        /** @var \Illuminate\Http\Request $instance */
11833 
                        return $instance->filterPrecognitiveRules($rules);
11834 
        }
11835 
                    /**
11836 
         * Determine if the request is attempting to be precognitive.
11837 
         *
11838 
         * @return bool
11839 
         * @static
11840 
         */
11841 
        public static function isAttemptingPrecognition()
11842 
        {
11843 
                        /** @var \Illuminate\Http\Request $instance */
11844 
                        return $instance->isAttemptingPrecognition();
11845 
        }
11846 
                    /**
11847 
         * Determine if the request is precognitive.
11848 
         *
11849 
         * @return bool
11850 
         * @static
11851 
         */
11852 
        public static function isPrecognitive()
11853 
        {
11854 
                        /** @var \Illuminate\Http\Request $instance */
11855 
                        return $instance->isPrecognitive();
11856 
        }
11857 
                    /**
11858 
         * Determine if the request is sending JSON.
11859 
         *
11860 
         * @return bool
11861 
         * @static
11862 
         */
11863 
        public static function isJson()
11864 
        {
11865 
                        /** @var \Illuminate\Http\Request $instance */
11866 
                        return $instance->isJson();
11867 
        }
11868 
                    /**
11869 
         * Determine if the current request probably expects a JSON response.
11870 
         *
11871 
         * @return bool
11872 
         * @static
11873 
         */
11874 
        public static function expectsJson()
11875 
        {
11876 
                        /** @var \Illuminate\Http\Request $instance */
11877 
                        return $instance->expectsJson();
11878 
        }
11879 
                    /**
11880 
         * Determine if the current request is asking for JSON.
11881 
         *
11882 
         * @return bool
11883 
         * @static
11884 
         */
11885 
        public static function wantsJson()
11886 
        {
11887 
                        /** @var \Illuminate\Http\Request $instance */
11888 
                        return $instance->wantsJson();
11889 
        }
11890 
                    /**
11891 
         * Determines whether the current requests accepts a given content type.
11892 
         *
11893 
         * @param string|array $contentTypes
11894 
         * @return bool
11895 
         * @static
11896 
         */
11897 
        public static function accepts($contentTypes)
11898 
        {
11899 
                        /** @var \Illuminate\Http\Request $instance */
11900 
                        return $instance->accepts($contentTypes);
11901 
        }
11902 
                    /**
11903 
         * Return the most suitable content type from the given array based on content negotiation.
11904 
         *
11905 
         * @param string|array $contentTypes
11906 
         * @return string|null
11907 
         * @static
11908 
         */
11909 
        public static function prefers($contentTypes)
11910 
        {
11911 
                        /** @var \Illuminate\Http\Request $instance */
11912 
                        return $instance->prefers($contentTypes);
11913 
        }
11914 
                    /**
11915 
         * Determine if the current request accepts any content type.
11916 
         *
11917 
         * @return bool
11918 
         * @static
11919 
         */
11920 
        public static function acceptsAnyContentType()
11921 
        {
11922 
                        /** @var \Illuminate\Http\Request $instance */
11923 
                        return $instance->acceptsAnyContentType();
11924 
        }
11925 
                    /**
11926 
         * Determines whether a request accepts JSON.
11927 
         *
11928 
         * @return bool
11929 
         * @static
11930 
         */
11931 
        public static function acceptsJson()
11932 
        {
11933 
                        /** @var \Illuminate\Http\Request $instance */
11934 
                        return $instance->acceptsJson();
11935 
        }
11936 
                    /**
11937 
         * Determines whether a request accepts HTML.
11938 
         *
11939 
         * @return bool
11940 
         * @static
11941 
         */
11942 
        public static function acceptsHtml()
11943 
        {
11944 
                        /** @var \Illuminate\Http\Request $instance */
11945 
                        return $instance->acceptsHtml();
11946 
        }
11947 
                    /**
11948 
         * Determine if the given content types match.
11949 
         *
11950 
         * @param string $actual
11951 
         * @param string $type
11952 
         * @return bool
11953 
         * @static
11954 
         */
11955 
        public static function matchesType($actual, $type)
11956 
        {
11957 
                        return \Illuminate\Http\Request::matchesType($actual, $type);
11958 
        }
11959 
                    /**
11960 
         * Get the data format expected in the response.
11961 
         *
11962 
         * @param string $default
11963 
         * @return string
11964 
         * @static
11965 
         */
11966 
        public static function format($default = 'html')
11967 
        {
11968 
                        /** @var \Illuminate\Http\Request $instance */
11969 
                        return $instance->format($default);
11970 
        }
11971 
                    /**
11972 
         * Retrieve an old input item.
11973 
         *
11974 
         * @param string|null $key
11975 
         * @param \Illuminate\Database\Eloquent\Model|string|array|null $default
11976 
         * @return string|array|null
11977 
         * @static
11978 
         */
11979 
        public static function old($key = null, $default = null)
11980 
        {
11981 
                        /** @var \Illuminate\Http\Request $instance */
11982 
                        return $instance->old($key, $default);
11983 
        }
11984 
                    /**
11985 
         * Flash the input for the current request to the session.
11986 
         *
11987 
         * @return void
11988 
         * @static
11989 
         */
11990 
        public static function flash()
11991 
        {
11992 
                        /** @var \Illuminate\Http\Request $instance */
11993 
                        $instance->flash();
11994 
        }
11995 
                    /**
11996 
         * Flash only some of the input to the session.
11997 
         *
11998 
         * @param array|mixed $keys
11999 
         * @return void
12000 
         * @static
12001 
         */
12002 
        public static function flashOnly($keys)
12003 
        {
12004 
                        /** @var \Illuminate\Http\Request $instance */
12005 
                        $instance->flashOnly($keys);
12006 
        }
12007 
                    /**
12008 
         * Flash only some of the input to the session.
12009 
         *
12010 
         * @param array|mixed $keys
12011 
         * @return void
12012 
         * @static
12013 
         */
12014 
        public static function flashExcept($keys)
12015 
        {
12016 
                        /** @var \Illuminate\Http\Request $instance */
12017 
                        $instance->flashExcept($keys);
12018 
        }
12019 
                    /**
12020 
         * Flush all of the old input from the session.
12021 
         *
12022 
         * @return void
12023 
         * @static
12024 
         */
12025 
        public static function flush()
12026 
        {
12027 
                        /** @var \Illuminate\Http\Request $instance */
12028 
                        $instance->flush();
12029 
        }
12030 
                    /**
12031 
         * Retrieve a server variable from the request.
12032 
         *
12033 
         * @param string|null $key
12034 
         * @param string|array|null $default
12035 
         * @return string|array|null
12036 
         * @static
12037 
         */
12038 
        public static function server($key = null, $default = null)
12039 
        {
12040 
                        /** @var \Illuminate\Http\Request $instance */
12041 
                        return $instance->server($key, $default);
12042 
        }
12043 
                    /**
12044 
         * Determine if a header is set on the request.
12045 
         *
12046 
         * @param string $key
12047 
         * @return bool
12048 
         * @static
12049 
         */
12050 
        public static function hasHeader($key)
12051 
        {
12052 
                        /** @var \Illuminate\Http\Request $instance */
12053 
                        return $instance->hasHeader($key);
12054 
        }
12055 
                    /**
12056 
         * Retrieve a header from the request.
12057 
         *
12058 
         * @param string|null $key
12059 
         * @param string|array|null $default
12060 
         * @return string|array|null
12061 
         * @static
12062 
         */
12063 
        public static function header($key = null, $default = null)
12064 
        {
12065 
                        /** @var \Illuminate\Http\Request $instance */
12066 
                        return $instance->header($key, $default);
12067 
        }
12068 
                    /**
12069 
         * Get the bearer token from the request headers.
12070 
         *
12071 
         * @return string|null
12072 
         * @static
12073 
         */
12074 
        public static function bearerToken()
12075 
        {
12076 
                        /** @var \Illuminate\Http\Request $instance */
12077 
                        return $instance->bearerToken();
12078 
        }
12079 
                    /**
12080 
         * Determine if the request contains a given input item key.
12081 
         *
12082 
         * @param string|array $key
12083 
         * @return bool
12084 
         * @static
12085 
         */
12086 
        public static function exists($key)
12087 
        {
12088 
                        /** @var \Illuminate\Http\Request $instance */
12089 
                        return $instance->exists($key);
12090 
        }
12091 
                    /**
12092 
         * Determine if the request contains a given input item key.
12093 
         *
12094 
         * @param string|array $key
12095 
         * @return bool
12096 
         * @static
12097 
         */
12098 
        public static function has($key)
12099 
        {
12100 
                        /** @var \Illuminate\Http\Request $instance */
12101 
                        return $instance->has($key);
12102 
        }
12103 
                    /**
12104 
         * Determine if the request contains any of the given inputs.
12105 
         *
12106 
         * @param string|array $keys
12107 
         * @return bool
12108 
         * @static
12109 
         */
12110 
        public static function hasAny($keys)
12111 
        {
12112 
                        /** @var \Illuminate\Http\Request $instance */
12113 
                        return $instance->hasAny($keys);
12114 
        }
12115 
                    /**
12116 
         * Apply the callback if the request contains the given input item key.
12117 
         *
12118 
         * @param string $key
12119 
         * @param callable $callback
12120 
         * @param callable|null $default
12121 
         * @return $this|mixed
12122 
         * @static
12123 
         */
12124 
        public static function whenHas($key, $callback, $default = null)
12125 
        {
12126 
                        /** @var \Illuminate\Http\Request $instance */
12127 
                        return $instance->whenHas($key, $callback, $default);
12128 
        }
12129 
                    /**
12130 
         * Determine if the request contains a non-empty value for an input item.
12131 
         *
12132 
         * @param string|array $key
12133 
         * @return bool
12134 
         * @static
12135 
         */
12136 
        public static function filled($key)
12137 
        {
12138 
                        /** @var \Illuminate\Http\Request $instance */
12139 
                        return $instance->filled($key);
12140 
        }
12141 
                    /**
12142 
         * Determine if the request contains an empty value for an input item.
12143 
         *
12144 
         * @param string|array $key
12145 
         * @return bool
12146 
         * @static
12147 
         */
12148 
        public static function isNotFilled($key)
12149 
        {
12150 
                        /** @var \Illuminate\Http\Request $instance */
12151 
                        return $instance->isNotFilled($key);
12152 
        }
12153 
                    /**
12154 
         * Determine if the request contains a non-empty value for any of the given inputs.
12155 
         *
12156 
         * @param string|array $keys
12157 
         * @return bool
12158 
         * @static
12159 
         */
12160 
        public static function anyFilled($keys)
12161 
        {
12162 
                        /** @var \Illuminate\Http\Request $instance */
12163 
                        return $instance->anyFilled($keys);
12164 
        }
12165 
                    /**
12166 
         * Apply the callback if the request contains a non-empty value for the given input item key.
12167 
         *
12168 
         * @param string $key
12169 
         * @param callable $callback
12170 
         * @param callable|null $default
12171 
         * @return $this|mixed
12172 
         * @static
12173 
         */
12174 
        public static function whenFilled($key, $callback, $default = null)
12175 
        {
12176 
                        /** @var \Illuminate\Http\Request $instance */
12177 
                        return $instance->whenFilled($key, $callback, $default);
12178 
        }
12179 
                    /**
12180 
         * Determine if the request is missing a given input item key.
12181 
         *
12182 
         * @param string|array $key
12183 
         * @return bool
12184 
         * @static
12185 
         */
12186 
        public static function missing($key)
12187 
        {
12188 
                        /** @var \Illuminate\Http\Request $instance */
12189 
                        return $instance->missing($key);
12190 
        }
12191 
                    /**
12192 
         * Apply the callback if the request is missing the given input item key.
12193 
         *
12194 
         * @param string $key
12195 
         * @param callable $callback
12196 
         * @param callable|null $default
12197 
         * @return $this|mixed
12198 
         * @static
12199 
         */
12200 
        public static function whenMissing($key, $callback, $default = null)
12201 
        {
12202 
                        /** @var \Illuminate\Http\Request $instance */
12203 
                        return $instance->whenMissing($key, $callback, $default);
12204 
        }
12205 
                    /**
12206 
         * Get the keys for all of the input and files.
12207 
         *
12208 
         * @return array
12209 
         * @static
12210 
         */
12211 
        public static function keys()
12212 
        {
12213 
                        /** @var \Illuminate\Http\Request $instance */
12214 
                        return $instance->keys();
12215 
        }
12216 
                    /**
12217 
         * Get all of the input and files for the request.
12218 
         *
12219 
         * @param array|mixed|null $keys
12220 
         * @return array
12221 
         * @static
12222 
         */
12223 
        public static function all($keys = null)
12224 
        {
12225 
                        /** @var \Illuminate\Http\Request $instance */
12226 
                        return $instance->all($keys);
12227 
        }
12228 
                    /**
12229 
         * Retrieve an input item from the request.
12230 
         *
12231 
         * @param string|null $key
12232 
         * @param mixed $default
12233 
         * @return mixed
12234 
         * @static
12235 
         */
12236 
        public static function input($key = null, $default = null)
12237 
        {
12238 
                        /** @var \Illuminate\Http\Request $instance */
12239 
                        return $instance->input($key, $default);
12240 
        }
12241 
                    /**
12242 
         * Retrieve input from the request as a Stringable instance.
12243 
         *
12244 
         * @param string $key
12245 
         * @param mixed $default
12246 
         * @return \Illuminate\Support\Stringable
12247 
         * @static
12248 
         */
12249 
        public static function str($key, $default = null)
12250 
        {
12251 
                        /** @var \Illuminate\Http\Request $instance */
12252 
                        return $instance->str($key, $default);
12253 
        }
12254 
                    /**
12255 
         * Retrieve input from the request as a Stringable instance.
12256 
         *
12257 
         * @param string $key
12258 
         * @param mixed $default
12259 
         * @return \Illuminate\Support\Stringable
12260 
         * @static
12261 
         */
12262 
        public static function string($key, $default = null)
12263 
        {
12264 
                        /** @var \Illuminate\Http\Request $instance */
12265 
                        return $instance->string($key, $default);
12266 
        }
12267 
                    /**
12268 
         * Retrieve input as a boolean value.
12269 
         *
12270 
         * Returns true when value is "1", "true", "on", and "yes". Otherwise, returns false.
12271 
         *
12272 
         * @param string|null $key
12273 
         * @param bool $default
12274 
         * @return bool
12275 
         * @static
12276 
         */
12277 
        public static function boolean($key = null, $default = false)
12278 
        {
12279 
                        /** @var \Illuminate\Http\Request $instance */
12280 
                        return $instance->boolean($key, $default);
12281 
        }
12282 
                    /**
12283 
         * Retrieve input as an integer value.
12284 
         *
12285 
         * @param string $key
12286 
         * @param int $default
12287 
         * @return int
12288 
         * @static
12289 
         */
12290 
        public static function integer($key, $default = 0)
12291 
        {
12292 
                        /** @var \Illuminate\Http\Request $instance */
12293 
                        return $instance->integer($key, $default);
12294 
        }
12295 
                    /**
12296 
         * Retrieve input as a float value.
12297 
         *
12298 
         * @param string $key
12299 
         * @param float $default
12300 
         * @return float
12301 
         * @static
12302 
         */
12303 
        public static function float($key, $default = 0.0)
12304 
        {
12305 
                        /** @var \Illuminate\Http\Request $instance */
12306 
                        return $instance->float($key, $default);
12307 
        }
12308 
                    /**
12309 
         * Retrieve input from the request as a Carbon instance.
12310 
         *
12311 
         * @param string $key
12312 
         * @param string|null $format
12313 
         * @param string|null $tz
12314 
         * @return \Illuminate\Support\Carbon|null
12315 
         * @throws \Carbon\Exceptions\InvalidFormatException
12316 
         * @static
12317 
         */
12318 
        public static function date($key, $format = null, $tz = null)
12319 
        {
12320 
                        /** @var \Illuminate\Http\Request $instance */
12321 
                        return $instance->date($key, $format, $tz);
12322 
        }
12323 
                    /**
12324 
         * Retrieve input from the request as an enum.
12325 
         *
12326 
         * @template TEnum
12327 
         * @param string $key
12328 
         * @param \Illuminate\Http\class-string<TEnum> $enumClass
12329 
         * @return \Illuminate\Http\TEnum|null
12330 
         * @static
12331 
         */
12332 
        public static function enum($key, $enumClass)
12333 
        {
12334 
                        /** @var \Illuminate\Http\Request $instance */
12335 
                        return $instance->enum($key, $enumClass);
12336 
        }
12337 
                    /**
12338 
         * Retrieve input from the request as a collection.
12339 
         *
12340 
         * @param array|string|null $key
12341 
         * @return \Illuminate\Support\Collection
12342 
         * @static
12343 
         */
12344 
        public static function collect($key = null)
12345 
        {
12346 
                        /** @var \Illuminate\Http\Request $instance */
12347 
                        return $instance->collect($key);
12348 
        }
12349 
                    /**
12350 
         * Get a subset containing the provided keys with values from the input data.
12351 
         *
12352 
         * @param array|mixed $keys
12353 
         * @return array
12354 
         * @static
12355 
         */
12356 
        public static function only($keys)
12357 
        {
12358 
                        /** @var \Illuminate\Http\Request $instance */
12359 
                        return $instance->only($keys);
12360 
        }
12361 
                    /**
12362 
         * Get all of the input except for a specified array of items.
12363 
         *
12364 
         * @param array|mixed $keys
12365 
         * @return array
12366 
         * @static
12367 
         */
12368 
        public static function except($keys)
12369 
        {
12370 
                        /** @var \Illuminate\Http\Request $instance */
12371 
                        return $instance->except($keys);
12372 
        }
12373 
                    /**
12374 
         * Retrieve a query string item from the request.
12375 
         *
12376 
         * @param string|null $key
12377 
         * @param string|array|null $default
12378 
         * @return string|array|null
12379 
         * @static
12380 
         */
12381 
        public static function query($key = null, $default = null)
12382 
        {
12383 
                        /** @var \Illuminate\Http\Request $instance */
12384 
                        return $instance->query($key, $default);
12385 
        }
12386 
                    /**
12387 
         * Retrieve a request payload item from the request.
12388 
         *
12389 
         * @param string|null $key
12390 
         * @param string|array|null $default
12391 
         * @return string|array|null
12392 
         * @static
12393 
         */
12394 
        public static function post($key = null, $default = null)
12395 
        {
12396 
                        /** @var \Illuminate\Http\Request $instance */
12397 
                        return $instance->post($key, $default);
12398 
        }
12399 
                    /**
12400 
         * Determine if a cookie is set on the request.
12401 
         *
12402 
         * @param string $key
12403 
         * @return bool
12404 
         * @static
12405 
         */
12406 
        public static function hasCookie($key)
12407 
        {
12408 
                        /** @var \Illuminate\Http\Request $instance */
12409 
                        return $instance->hasCookie($key);
12410 
        }
12411 
                    /**
12412 
         * Retrieve a cookie from the request.
12413 
         *
12414 
         * @param string|null $key
12415 
         * @param string|array|null $default
12416 
         * @return string|array|null
12417 
         * @static
12418 
         */
12419 
        public static function cookie($key = null, $default = null)
12420 
        {
12421 
                        /** @var \Illuminate\Http\Request $instance */
12422 
                        return $instance->cookie($key, $default);
12423 
        }
12424 
                    /**
12425 
         * Get an array of all of the files on the request.
12426 
         *
12427 
         * @return array
12428 
         * @static
12429 
         */
12430 
        public static function allFiles()
12431 
        {
12432 
                        /** @var \Illuminate\Http\Request $instance */
12433 
                        return $instance->allFiles();
12434 
        }
12435 
                    /**
12436 
         * Determine if the uploaded data contains a file.
12437 
         *
12438 
         * @param string $key
12439 
         * @return bool
12440 
         * @static
12441 
         */
12442 
        public static function hasFile($key)
12443 
        {
12444 
                        /** @var \Illuminate\Http\Request $instance */
12445 
                        return $instance->hasFile($key);
12446 
        }
12447 
                    /**
12448 
         * Retrieve a file from the request.
12449 
         *
12450 
         * @param string|null $key
12451 
         * @param mixed $default
12452 
         * @return \Illuminate\Http\UploadedFile|\Illuminate\Http\UploadedFile[]|array|null
12453 
         * @static
12454 
         */
12455 
        public static function file($key = null, $default = null)
12456 
        {
12457 
                        /** @var \Illuminate\Http\Request $instance */
12458 
                        return $instance->file($key, $default);
12459 
        }
12460 
                    /**
12461 
         * Dump the request items and end the script.
12462 
         *
12463 
         * @param mixed $keys
12464 
         * @return \Illuminate\Http\never
12465 
         * @static
12466 
         */
12467 
        public static function dd(...$keys)
12468 
        {
12469 
                        /** @var \Illuminate\Http\Request $instance */
12470 
                        return $instance->dd(...$keys);
12471 
        }
12472 
                    /**
12473 
         * Dump the items.
12474 
         *
12475 
         * @param mixed $keys
12476 
         * @return \Illuminate\Http\Request
12477 
         * @static
12478 
         */
12479 
        public static function dump($keys = [])
12480 
        {
12481 
                        /** @var \Illuminate\Http\Request $instance */
12482 
                        return $instance->dump($keys);
12483 
        }
12484 
                    /**
12485 
         * Register a custom macro.
12486 
         *
12487 
         * @param string $name
12488 
         * @param object|callable $macro
12489 
         * @return void
12490 
         * @static
12491 
         */
12492 
        public static function macro($name, $macro)
12493 
        {
12494 
                        \Illuminate\Http\Request::macro($name, $macro);
12495 
        }
12496 
                    /**
12497 
         * Mix another object into the class.
12498 
         *
12499 
         * @param object $mixin
12500 
         * @param bool $replace
12501 
         * @return void
12502 
         * @throws \ReflectionException
12503 
         * @static
12504 
         */
12505 
        public static function mixin($mixin, $replace = true)
12506 
        {
12507 
                        \Illuminate\Http\Request::mixin($mixin, $replace);
12508 
        }
12509 
                    /**
12510 
         * Checks if macro is registered.
12511 
         *
12512 
         * @param string $name
12513 
         * @return bool
12514 
         * @static
12515 
         */
12516 
        public static function hasMacro($name)
12517 
        {
12518 
                        return \Illuminate\Http\Request::hasMacro($name);
12519 
        }
12520 
                    /**
12521 
         * Flush the existing macros.
12522 
         *
12523 
         * @return void
12524 
         * @static
12525 
         */
12526 
        public static function flushMacros()
12527 
        {
12528 
                        \Illuminate\Http\Request::flushMacros();
12529 
        }
12530 
                    /**
12531 
         *
12532 
         *
12533 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
12534 
         * @param array $rules
12535 
         * @param mixed $params
12536 
         * @static
12537 
         */
12538 
        public static function validate($rules, ...$params)
12539 
        {
12540 
                        return \Illuminate\Http\Request::validate($rules, ...$params);
12541 
        }
12542 
                    /**
12543 
         *
12544 
         *
12545 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
12546 
         * @param string $errorBag
12547 
         * @param array $rules
12548 
         * @param mixed $params
12549 
         * @static
12550 
         */
12551 
        public static function validateWithBag($errorBag, $rules, ...$params)
12552 
        {
12553 
                        return \Illuminate\Http\Request::validateWithBag($errorBag, $rules, ...$params);
12554 
        }
12555 
                    /**
12556 
         *
12557 
         *
12558 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
12559 
         * @param mixed $absolute
12560 
         * @static
12561 
         */
12562 
        public static function hasValidSignature($absolute = true)
12563 
        {
12564 
                        return \Illuminate\Http\Request::hasValidSignature($absolute);
12565 
        }
12566 
                    /**
12567 
         *
12568 
         *
12569 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
12570 
         * @static
12571 
         */
12572 
        public static function hasValidRelativeSignature()
12573 
        {
12574 
                        return \Illuminate\Http\Request::hasValidRelativeSignature();
12575 
        }
12576 
                    /**
12577 
         *
12578 
         *
12579 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
12580 
         * @param mixed $ignoreQuery
12581 
         * @param mixed $absolute
12582 
         * @static
12583 
         */
12584 
        public static function hasValidSignatureWhileIgnoring($ignoreQuery = [], $absolute = true)
12585 
        {
12586 
                        return \Illuminate\Http\Request::hasValidSignatureWhileIgnoring($ignoreQuery, $absolute);
12587 
        }
12588 
 
12589 
    }
12590 
            /**
12591 
     *
12592 
     *
12593 
     * @see \Illuminate\Routing\ResponseFactory
12594 
     */
12595 
        class Response {
12596 
                    /**
12597 
         * Create a new response instance.
12598 
         *
12599 
         * @param mixed $content
12600 
         * @param int $status
12601 
         * @param array $headers
12602 
         * @return \Illuminate\Http\Response
12603 
         * @static
12604 
         */
12605 
        public static function make($content = '', $status = 200, $headers = [])
12606 
        {
12607 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12608 
                        return $instance->make($content, $status, $headers);
12609 
        }
12610 
                    /**
12611 
         * Create a new "no content" response.
12612 
         *
12613 
         * @param int $status
12614 
         * @param array $headers
12615 
         * @return \Illuminate\Http\Response
12616 
         * @static
12617 
         */
12618 
        public static function noContent($status = 204, $headers = [])
12619 
        {
12620 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12621 
                        return $instance->noContent($status, $headers);
12622 
        }
12623 
                    /**
12624 
         * Create a new response for a given view.
12625 
         *
12626 
         * @param string|array $view
12627 
         * @param array $data
12628 
         * @param int $status
12629 
         * @param array $headers
12630 
         * @return \Illuminate\Http\Response
12631 
         * @static
12632 
         */
12633 
        public static function view($view, $data = [], $status = 200, $headers = [])
12634 
        {
12635 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12636 
                        return $instance->view($view, $data, $status, $headers);
12637 
        }
12638 
                    /**
12639 
         * Create a new JSON response instance.
12640 
         *
12641 
         * @param mixed $data
12642 
         * @param int $status
12643 
         * @param array $headers
12644 
         * @param int $options
12645 
         * @return \Illuminate\Http\JsonResponse
12646 
         * @static
12647 
         */
12648 
        public static function json($data = [], $status = 200, $headers = [], $options = 0)
12649 
        {
12650 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12651 
                        return $instance->json($data, $status, $headers, $options);
12652 
        }
12653 
                    /**
12654 
         * Create a new JSONP response instance.
12655 
         *
12656 
         * @param string $callback
12657 
         * @param mixed $data
12658 
         * @param int $status
12659 
         * @param array $headers
12660 
         * @param int $options
12661 
         * @return \Illuminate\Http\JsonResponse
12662 
         * @static
12663 
         */
12664 
        public static function jsonp($callback, $data = [], $status = 200, $headers = [], $options = 0)
12665 
        {
12666 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12667 
                        return $instance->jsonp($callback, $data, $status, $headers, $options);
12668 
        }
12669 
                    /**
12670 
         * Create a new streamed response instance.
12671 
         *
12672 
         * @param callable $callback
12673 
         * @param int $status
12674 
         * @param array $headers
12675 
         * @return \Symfony\Component\HttpFoundation\StreamedResponse
12676 
         * @static
12677 
         */
12678 
        public static function stream($callback, $status = 200, $headers = [])
12679 
        {
12680 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12681 
                        return $instance->stream($callback, $status, $headers);
12682 
        }
12683 
                    /**
12684 
         * Create a new streamed response instance as a file download.
12685 
         *
12686 
         * @param callable $callback
12687 
         * @param string|null $name
12688 
         * @param array $headers
12689 
         * @param string|null $disposition
12690 
         * @return \Symfony\Component\HttpFoundation\StreamedResponse
12691 
         * @static
12692 
         */
12693 
        public static function streamDownload($callback, $name = null, $headers = [], $disposition = 'attachment')
12694 
        {
12695 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12696 
                        return $instance->streamDownload($callback, $name, $headers, $disposition);
12697 
        }
12698 
                    /**
12699 
         * Create a new file download response.
12700 
         *
12701 
         * @param \SplFileInfo|string $file
12702 
         * @param string|null $name
12703 
         * @param array $headers
12704 
         * @param string|null $disposition
12705 
         * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
12706 
         * @static
12707 
         */
12708 
        public static function download($file, $name = null, $headers = [], $disposition = 'attachment')
12709 
        {
12710 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12711 
                        return $instance->download($file, $name, $headers, $disposition);
12712 
        }
12713 
                    /**
12714 
         * Return the raw contents of a binary file.
12715 
         *
12716 
         * @param \SplFileInfo|string $file
12717 
         * @param array $headers
12718 
         * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
12719 
         * @static
12720 
         */
12721 
        public static function file($file, $headers = [])
12722 
        {
12723 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12724 
                        return $instance->file($file, $headers);
12725 
        }
12726 
                    /**
12727 
         * Create a new redirect response to the given path.
12728 
         *
12729 
         * @param string $path
12730 
         * @param int $status
12731 
         * @param array $headers
12732 
         * @param bool|null $secure
12733 
         * @return \Illuminate\Http\RedirectResponse
12734 
         * @static
12735 
         */
12736 
        public static function redirectTo($path, $status = 302, $headers = [], $secure = null)
12737 
        {
12738 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12739 
                        return $instance->redirectTo($path, $status, $headers, $secure);
12740 
        }
12741 
                    /**
12742 
         * Create a new redirect response to a named route.
12743 
         *
12744 
         * @param string $route
12745 
         * @param mixed $parameters
12746 
         * @param int $status
12747 
         * @param array $headers
12748 
         * @return \Illuminate\Http\RedirectResponse
12749 
         * @static
12750 
         */
12751 
        public static function redirectToRoute($route, $parameters = [], $status = 302, $headers = [])
12752 
        {
12753 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12754 
                        return $instance->redirectToRoute($route, $parameters, $status, $headers);
12755 
        }
12756 
                    /**
12757 
         * Create a new redirect response to a controller action.
12758 
         *
12759 
         * @param string $action
12760 
         * @param mixed $parameters
12761 
         * @param int $status
12762 
         * @param array $headers
12763 
         * @return \Illuminate\Http\RedirectResponse
12764 
         * @static
12765 
         */
12766 
        public static function redirectToAction($action, $parameters = [], $status = 302, $headers = [])
12767 
        {
12768 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12769 
                        return $instance->redirectToAction($action, $parameters, $status, $headers);
12770 
        }
12771 
                    /**
12772 
         * Create a new redirect response, while putting the current URL in the session.
12773 
         *
12774 
         * @param string $path
12775 
         * @param int $status
12776 
         * @param array $headers
12777 
         * @param bool|null $secure
12778 
         * @return \Illuminate\Http\RedirectResponse
12779 
         * @static
12780 
         */
12781 
        public static function redirectGuest($path, $status = 302, $headers = [], $secure = null)
12782 
        {
12783 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12784 
                        return $instance->redirectGuest($path, $status, $headers, $secure);
12785 
        }
12786 
                    /**
12787 
         * Create a new redirect response to the previously intended location.
12788 
         *
12789 
         * @param string $default
12790 
         * @param int $status
12791 
         * @param array $headers
12792 
         * @param bool|null $secure
12793 
         * @return \Illuminate\Http\RedirectResponse
12794 
         * @static
12795 
         */
12796 
        public static function redirectToIntended($default = '/', $status = 302, $headers = [], $secure = null)
12797 
        {
12798 
                        /** @var \Illuminate\Routing\ResponseFactory $instance */
12799 
                        return $instance->redirectToIntended($default, $status, $headers, $secure);
12800 
        }
12801 
                    /**
12802 
         * Register a custom macro.
12803 
         *
12804 
         * @param string $name
12805 
         * @param object|callable $macro
12806 
         * @return void
12807 
         * @static
12808 
         */
12809 
        public static function macro($name, $macro)
12810 
        {
12811 
                        \Illuminate\Routing\ResponseFactory::macro($name, $macro);
12812 
        }
12813 
                    /**
12814 
         * Mix another object into the class.
12815 
         *
12816 
         * @param object $mixin
12817 
         * @param bool $replace
12818 
         * @return void
12819 
         * @throws \ReflectionException
12820 
         * @static
12821 
         */
12822 
        public static function mixin($mixin, $replace = true)
12823 
        {
12824 
                        \Illuminate\Routing\ResponseFactory::mixin($mixin, $replace);
12825 
        }
12826 
                    /**
12827 
         * Checks if macro is registered.
12828 
         *
12829 
         * @param string $name
12830 
         * @return bool
12831 
         * @static
12832 
         */
12833 
        public static function hasMacro($name)
12834 
        {
12835 
                        return \Illuminate\Routing\ResponseFactory::hasMacro($name);
12836 
        }
12837 
                    /**
12838 
         * Flush the existing macros.
12839 
         *
12840 
         * @return void
12841 
         * @static
12842 
         */
12843 
        public static function flushMacros()
12844 
        {
12845 
                        \Illuminate\Routing\ResponseFactory::flushMacros();
12846 
        }
12847 
 
12848 
    }
12849 
            /**
12850 
     *
12851 
     *
12852 
     * @method static \Illuminate\Routing\RouteRegistrar attribute(string $key, mixed $value)
12853 
     * @method static \Illuminate\Routing\RouteRegistrar whereAlpha(array|string $parameters)
12854 
     * @method static \Illuminate\Routing\RouteRegistrar whereAlphaNumeric(array|string $parameters)
12855 
     * @method static \Illuminate\Routing\RouteRegistrar whereNumber(array|string $parameters)
12856 
     * @method static \Illuminate\Routing\RouteRegistrar whereUlid(array|string $parameters)
12857 
     * @method static \Illuminate\Routing\RouteRegistrar whereUuid(array|string $parameters)
12858 
     * @method static \Illuminate\Routing\RouteRegistrar whereIn(array|string $parameters, array $values)
12859 
     * @method static \Illuminate\Routing\RouteRegistrar as(string $value)
12860 
     * @method static \Illuminate\Routing\RouteRegistrar controller(string $controller)
12861 
     * @method static \Illuminate\Routing\RouteRegistrar domain(string $value)
12862 
     * @method static \Illuminate\Routing\RouteRegistrar middleware(array|string|null $middleware)
12863 
     * @method static \Illuminate\Routing\RouteRegistrar name(string $value)
12864 
     * @method static \Illuminate\Routing\RouteRegistrar namespace(string|null $value)
12865 
     * @method static \Illuminate\Routing\RouteRegistrar prefix(string $prefix)
12866 
     * @method static \Illuminate\Routing\RouteRegistrar scopeBindings()
12867 
     * @method static \Illuminate\Routing\RouteRegistrar where(array $where)
12868 
     * @method static \Illuminate\Routing\RouteRegistrar withoutMiddleware(array|string $middleware)
12869 
     * @method static \Illuminate\Routing\RouteRegistrar withoutScopedBindings()
12870 
     * @see \Illuminate\Routing\Router
12871 
     */
12872 
        class Route {
12873 
                    /**
12874 
         * Register a new GET route with the router.
12875 
         *
12876 
         * @param string $uri
12877 
         * @param array|string|callable|null $action
12878 
         * @return \Illuminate\Routing\Route
12879 
         * @static
12880 
         */
12881 
        public static function get($uri, $action = null)
12882 
        {
12883 
                        /** @var \Illuminate\Routing\Router $instance */
12884 
                        return $instance->get($uri, $action);
12885 
        }
12886 
                    /**
12887 
         * Register a new POST route with the router.
12888 
         *
12889 
         * @param string $uri
12890 
         * @param array|string|callable|null $action
12891 
         * @return \Illuminate\Routing\Route
12892 
         * @static
12893 
         */
12894 
        public static function post($uri, $action = null)
12895 
        {
12896 
                        /** @var \Illuminate\Routing\Router $instance */
12897 
                        return $instance->post($uri, $action);
12898 
        }
12899 
                    /**
12900 
         * Register a new PUT route with the router.
12901 
         *
12902 
         * @param string $uri
12903 
         * @param array|string|callable|null $action
12904 
         * @return \Illuminate\Routing\Route
12905 
         * @static
12906 
         */
12907 
        public static function put($uri, $action = null)
12908 
        {
12909 
                        /** @var \Illuminate\Routing\Router $instance */
12910 
                        return $instance->put($uri, $action);
12911 
        }
12912 
                    /**
12913 
         * Register a new PATCH route with the router.
12914 
         *
12915 
         * @param string $uri
12916 
         * @param array|string|callable|null $action
12917 
         * @return \Illuminate\Routing\Route
12918 
         * @static
12919 
         */
12920 
        public static function patch($uri, $action = null)
12921 
        {
12922 
                        /** @var \Illuminate\Routing\Router $instance */
12923 
                        return $instance->patch($uri, $action);
12924 
        }
12925 
                    /**
12926 
         * Register a new DELETE route with the router.
12927 
         *
12928 
         * @param string $uri
12929 
         * @param array|string|callable|null $action
12930 
         * @return \Illuminate\Routing\Route
12931 
         * @static
12932 
         */
12933 
        public static function delete($uri, $action = null)
12934 
        {
12935 
                        /** @var \Illuminate\Routing\Router $instance */
12936 
                        return $instance->delete($uri, $action);
12937 
        }
12938 
                    /**
12939 
         * Register a new OPTIONS route with the router.
12940 
         *
12941 
         * @param string $uri
12942 
         * @param array|string|callable|null $action
12943 
         * @return \Illuminate\Routing\Route
12944 
         * @static
12945 
         */
12946 
        public static function options($uri, $action = null)
12947 
        {
12948 
                        /** @var \Illuminate\Routing\Router $instance */
12949 
                        return $instance->options($uri, $action);
12950 
        }
12951 
                    /**
12952 
         * Register a new route responding to all verbs.
12953 
         *
12954 
         * @param string $uri
12955 
         * @param array|string|callable|null $action
12956 
         * @return \Illuminate\Routing\Route
12957 
         * @static
12958 
         */
12959 
        public static function any($uri, $action = null)
12960 
        {
12961 
                        /** @var \Illuminate\Routing\Router $instance */
12962 
                        return $instance->any($uri, $action);
12963 
        }
12964 
                    /**
12965 
         * Register a new Fallback route with the router.
12966 
         *
12967 
         * @param array|string|callable|null $action
12968 
         * @return \Illuminate\Routing\Route
12969 
         * @static
12970 
         */
12971 
        public static function fallback($action)
12972 
        {
12973 
                        /** @var \Illuminate\Routing\Router $instance */
12974 
                        return $instance->fallback($action);
12975 
        }
12976 
                    /**
12977 
         * Create a redirect from one URI to another.
12978 
         *
12979 
         * @param string $uri
12980 
         * @param string $destination
12981 
         * @param int $status
12982 
         * @return \Illuminate\Routing\Route
12983 
         * @static
12984 
         */
12985 
        public static function redirect($uri, $destination, $status = 302)
12986 
        {
12987 
                        /** @var \Illuminate\Routing\Router $instance */
12988 
                        return $instance->redirect($uri, $destination, $status);
12989 
        }
12990 
                    /**
12991 
         * Create a permanent redirect from one URI to another.
12992 
         *
12993 
         * @param string $uri
12994 
         * @param string $destination
12995 
         * @return \Illuminate\Routing\Route
12996 
         * @static
12997 
         */
12998 
        public static function permanentRedirect($uri, $destination)
12999 
        {
13000 
                        /** @var \Illuminate\Routing\Router $instance */
13001 
                        return $instance->permanentRedirect($uri, $destination);
13002 
        }
13003 
                    /**
13004 
         * Register a new route that returns a view.
13005 
         *
13006 
         * @param string $uri
13007 
         * @param string $view
13008 
         * @param array $data
13009 
         * @param int|array $status
13010 
         * @param array $headers
13011 
         * @return \Illuminate\Routing\Route
13012 
         * @static
13013 
         */
13014 
        public static function view($uri, $view, $data = [], $status = 200, $headers = [])
13015 
        {
13016 
                        /** @var \Illuminate\Routing\Router $instance */
13017 
                        return $instance->view($uri, $view, $data, $status, $headers);
13018 
        }
13019 
                    /**
13020 
         * Register a new route with the given verbs.
13021 
         *
13022 
         * @param array|string $methods
13023 
         * @param string $uri
13024 
         * @param array|string|callable|null $action
13025 
         * @return \Illuminate\Routing\Route
13026 
         * @static
13027 
         */
13028 
        public static function match($methods, $uri, $action = null)
13029 
        {
13030 
                        /** @var \Illuminate\Routing\Router $instance */
13031 
                        return $instance->match($methods, $uri, $action);
13032 
        }
13033 
                    /**
13034 
         * Register an array of resource controllers.
13035 
         *
13036 
         * @param array $resources
13037 
         * @param array $options
13038 
         * @return void
13039 
         * @static
13040 
         */
13041 
        public static function resources($resources, $options = [])
13042 
        {
13043 
                        /** @var \Illuminate\Routing\Router $instance */
13044 
                        $instance->resources($resources, $options);
13045 
        }
13046 
                    /**
13047 
         * Route a resource to a controller.
13048 
         *
13049 
         * @param string $name
13050 
         * @param string $controller
13051 
         * @param array $options
13052 
         * @return \Illuminate\Routing\PendingResourceRegistration
13053 
         * @static
13054 
         */
13055 
        public static function resource($name, $controller, $options = [])
13056 
        {
13057 
                        /** @var \Illuminate\Routing\Router $instance */
13058 
                        return $instance->resource($name, $controller, $options);
13059 
        }
13060 
                    /**
13061 
         * Register an array of API resource controllers.
13062 
         *
13063 
         * @param array $resources
13064 
         * @param array $options
13065 
         * @return void
13066 
         * @static
13067 
         */
13068 
        public static function apiResources($resources, $options = [])
13069 
        {
13070 
                        /** @var \Illuminate\Routing\Router $instance */
13071 
                        $instance->apiResources($resources, $options);
13072 
        }
13073 
                    /**
13074 
         * Route an API resource to a controller.
13075 
         *
13076 
         * @param string $name
13077 
         * @param string $controller
13078 
         * @param array $options
13079 
         * @return \Illuminate\Routing\PendingResourceRegistration
13080 
         * @static
13081 
         */
13082 
        public static function apiResource($name, $controller, $options = [])
13083 
        {
13084 
                        /** @var \Illuminate\Routing\Router $instance */
13085 
                        return $instance->apiResource($name, $controller, $options);
13086 
        }
13087 
                    /**
13088 
         * Register an array of singleton resource controllers.
13089 
         *
13090 
         * @param array $singletons
13091 
         * @param array $options
13092 
         * @return void
13093 
         * @static
13094 
         */
13095 
        public static function singletons($singletons, $options = [])
13096 
        {
13097 
                        /** @var \Illuminate\Routing\Router $instance */
13098 
                        $instance->singletons($singletons, $options);
13099 
        }
13100 
                    /**
13101 
         * Route a singleton resource to a controller.
13102 
         *
13103 
         * @param string $name
13104 
         * @param string $controller
13105 
         * @param array $options
13106 
         * @return \Illuminate\Routing\PendingSingletonResourceRegistration
13107 
         * @static
13108 
         */
13109 
        public static function singleton($name, $controller, $options = [])
13110 
        {
13111 
                        /** @var \Illuminate\Routing\Router $instance */
13112 
                        return $instance->singleton($name, $controller, $options);
13113 
        }
13114 
                    /**
13115 
         * Register an array of API singleton resource controllers.
13116 
         *
13117 
         * @param array $singletons
13118 
         * @param array $options
13119 
         * @return void
13120 
         * @static
13121 
         */
13122 
        public static function apiSingletons($singletons, $options = [])
13123 
        {
13124 
                        /** @var \Illuminate\Routing\Router $instance */
13125 
                        $instance->apiSingletons($singletons, $options);
13126 
        }
13127 
                    /**
13128 
         * Route an API singleton resource to a controller.
13129 
         *
13130 
         * @param string $name
13131 
         * @param string $controller
13132 
         * @param array $options
13133 
         * @return \Illuminate\Routing\PendingSingletonResourceRegistration
13134 
         * @static
13135 
         */
13136 
        public static function apiSingleton($name, $controller, $options = [])
13137 
        {
13138 
                        /** @var \Illuminate\Routing\Router $instance */
13139 
                        return $instance->apiSingleton($name, $controller, $options);
13140 
        }
13141 
                    /**
13142 
         * Create a route group with shared attributes.
13143 
         *
13144 
         * @param array $attributes
13145 
         * @param \Closure|array|string $routes
13146 
         * @return \Illuminate\Routing\Router
13147 
         * @static
13148 
         */
13149 
        public static function group($attributes, $routes)
13150 
        {
13151 
                        /** @var \Illuminate\Routing\Router $instance */
13152 
                        return $instance->group($attributes, $routes);
13153 
        }
13154 
                    /**
13155 
         * Merge the given array with the last group stack.
13156 
         *
13157 
         * @param array $new
13158 
         * @param bool $prependExistingPrefix
13159 
         * @return array
13160 
         * @static
13161 
         */
13162 
        public static function mergeWithLastGroup($new, $prependExistingPrefix = true)
13163 
        {
13164 
                        /** @var \Illuminate\Routing\Router $instance */
13165 
                        return $instance->mergeWithLastGroup($new, $prependExistingPrefix);
13166 
        }
13167 
                    /**
13168 
         * Get the prefix from the last group on the stack.
13169 
         *
13170 
         * @return string
13171 
         * @static
13172 
         */
13173 
        public static function getLastGroupPrefix()
13174 
        {
13175 
                        /** @var \Illuminate\Routing\Router $instance */
13176 
                        return $instance->getLastGroupPrefix();
13177 
        }
13178 
                    /**
13179 
         * Add a route to the underlying route collection.
13180 
         *
13181 
         * @param array|string $methods
13182 
         * @param string $uri
13183 
         * @param array|string|callable|null $action
13184 
         * @return \Illuminate\Routing\Route
13185 
         * @static
13186 
         */
13187 
        public static function addRoute($methods, $uri, $action)
13188 
        {
13189 
                        /** @var \Illuminate\Routing\Router $instance */
13190 
                        return $instance->addRoute($methods, $uri, $action);
13191 
        }
13192 
                    /**
13193 
         * Create a new Route object.
13194 
         *
13195 
         * @param array|string $methods
13196 
         * @param string $uri
13197 
         * @param mixed $action
13198 
         * @return \Illuminate\Routing\Route
13199 
         * @static
13200 
         */
13201 
        public static function newRoute($methods, $uri, $action)
13202 
        {
13203 
                        /** @var \Illuminate\Routing\Router $instance */
13204 
                        return $instance->newRoute($methods, $uri, $action);
13205 
        }
13206 
                    /**
13207 
         * Return the response returned by the given route.
13208 
         *
13209 
         * @param string $name
13210 
         * @return \Symfony\Component\HttpFoundation\Response
13211 
         * @static
13212 
         */
13213 
        public static function respondWithRoute($name)
13214 
        {
13215 
                        /** @var \Illuminate\Routing\Router $instance */
13216 
                        return $instance->respondWithRoute($name);
13217 
        }
13218 
                    /**
13219 
         * Dispatch the request to the application.
13220 
         *
13221 
         * @param \Illuminate\Http\Request $request
13222 
         * @return \Symfony\Component\HttpFoundation\Response
13223 
         * @static
13224 
         */
13225 
        public static function dispatch($request)
13226 
        {
13227 
                        /** @var \Illuminate\Routing\Router $instance */
13228 
                        return $instance->dispatch($request);
13229 
        }
13230 
                    /**
13231 
         * Dispatch the request to a route and return the response.
13232 
         *
13233 
         * @param \Illuminate\Http\Request $request
13234 
         * @return \Symfony\Component\HttpFoundation\Response
13235 
         * @static
13236 
         */
13237 
        public static function dispatchToRoute($request)
13238 
        {
13239 
                        /** @var \Illuminate\Routing\Router $instance */
13240 
                        return $instance->dispatchToRoute($request);
13241 
        }
13242 
                    /**
13243 
         * Gather the middleware for the given route with resolved class names.
13244 
         *
13245 
         * @param \Illuminate\Routing\Route $route
13246 
         * @return array
13247 
         * @static
13248 
         */
13249 
        public static function gatherRouteMiddleware($route)
13250 
        {
13251 
                        /** @var \Illuminate\Routing\Router $instance */
13252 
                        return $instance->gatherRouteMiddleware($route);
13253 
        }
13254 
                    /**
13255 
         * Resolve a flat array of middleware classes from the provided array.
13256 
         *
13257 
         * @param array $middleware
13258 
         * @param array $excluded
13259 
         * @return array
13260 
         * @static
13261 
         */
13262 
        public static function resolveMiddleware($middleware, $excluded = [])
13263 
        {
13264 
                        /** @var \Illuminate\Routing\Router $instance */
13265 
                        return $instance->resolveMiddleware($middleware, $excluded);
13266 
        }
13267 
                    /**
13268 
         * Create a response instance from the given value.
13269 
         *
13270 
         * @param \Symfony\Component\HttpFoundation\Request $request
13271 
         * @param mixed $response
13272 
         * @return \Symfony\Component\HttpFoundation\Response
13273 
         * @static
13274 
         */
13275 
        public static function prepareResponse($request, $response)
13276 
        {
13277 
                        /** @var \Illuminate\Routing\Router $instance */
13278 
                        return $instance->prepareResponse($request, $response);
13279 
        }
13280 
                    /**
13281 
         * Static version of prepareResponse.
13282 
         *
13283 
         * @param \Symfony\Component\HttpFoundation\Request $request
13284 
         * @param mixed $response
13285 
         * @return \Symfony\Component\HttpFoundation\Response
13286 
         * @static
13287 
         */
13288 
        public static function toResponse($request, $response)
13289 
        {
13290 
                        return \Illuminate\Routing\Router::toResponse($request, $response);
13291 
        }
13292 
                    /**
13293 
         * Substitute the route bindings onto the route.
13294 
         *
13295 
         * @param \Illuminate\Routing\Route $route
13296 
         * @return \Illuminate\Routing\Route
13297 
         * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
13298 
         * @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException
13299 
         * @static
13300 
         */
13301 
        public static function substituteBindings($route)
13302 
        {
13303 
                        /** @var \Illuminate\Routing\Router $instance */
13304 
                        return $instance->substituteBindings($route);
13305 
        }
13306 
                    /**
13307 
         * Substitute the implicit route bindings for the given route.
13308 
         *
13309 
         * @param \Illuminate\Routing\Route $route
13310 
         * @return void
13311 
         * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
13312 
         * @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException
13313 
         * @static
13314 
         */
13315 
        public static function substituteImplicitBindings($route)
13316 
        {
13317 
                        /** @var \Illuminate\Routing\Router $instance */
13318 
                        $instance->substituteImplicitBindings($route);
13319 
        }
13320 
                    /**
13321 
         * Register a route matched event listener.
13322 
         *
13323 
         * @param string|callable $callback
13324 
         * @return void
13325 
         * @static
13326 
         */
13327 
        public static function matched($callback)
13328 
        {
13329 
                        /** @var \Illuminate\Routing\Router $instance */
13330 
                        $instance->matched($callback);
13331 
        }
13332 
                    /**
13333 
         * Get all of the defined middleware short-hand names.
13334 
         *
13335 
         * @return array
13336 
         * @static
13337 
         */
13338 
        public static function getMiddleware()
13339 
        {
13340 
                        /** @var \Illuminate\Routing\Router $instance */
13341 
                        return $instance->getMiddleware();
13342 
        }
13343 
                    /**
13344 
         * Register a short-hand name for a middleware.
13345 
         *
13346 
         * @param string $name
13347 
         * @param string $class
13348 
         * @return \Illuminate\Routing\Router
13349 
         * @static
13350 
         */
13351 
        public static function aliasMiddleware($name, $class)
13352 
        {
13353 
                        /** @var \Illuminate\Routing\Router $instance */
13354 
                        return $instance->aliasMiddleware($name, $class);
13355 
        }
13356 
                    /**
13357 
         * Check if a middlewareGroup with the given name exists.
13358 
         *
13359 
         * @param string $name
13360 
         * @return bool
13361 
         * @static
13362 
         */
13363 
        public static function hasMiddlewareGroup($name)
13364 
        {
13365 
                        /** @var \Illuminate\Routing\Router $instance */
13366 
                        return $instance->hasMiddlewareGroup($name);
13367 
        }
13368 
                    /**
13369 
         * Get all of the defined middleware groups.
13370 
         *
13371 
         * @return array
13372 
         * @static
13373 
         */
13374 
        public static function getMiddlewareGroups()
13375 
        {
13376 
                        /** @var \Illuminate\Routing\Router $instance */
13377 
                        return $instance->getMiddlewareGroups();
13378 
        }
13379 
                    /**
13380 
         * Register a group of middleware.
13381 
         *
13382 
         * @param string $name
13383 
         * @param array $middleware
13384 
         * @return \Illuminate\Routing\Router
13385 
         * @static
13386 
         */
13387 
        public static function middlewareGroup($name, $middleware)
13388 
        {
13389 
                        /** @var \Illuminate\Routing\Router $instance */
13390 
                        return $instance->middlewareGroup($name, $middleware);
13391 
        }
13392 
                    /**
13393 
         * Add a middleware to the beginning of a middleware group.
13394 
         *
13395 
         * If the middleware is already in the group, it will not be added again.
13396 
         *
13397 
         * @param string $group
13398 
         * @param string $middleware
13399 
         * @return \Illuminate\Routing\Router
13400 
         * @static
13401 
         */
13402 
        public static function prependMiddlewareToGroup($group, $middleware)
13403 
        {
13404 
                        /** @var \Illuminate\Routing\Router $instance */
13405 
                        return $instance->prependMiddlewareToGroup($group, $middleware);
13406 
        }
13407 
                    /**
13408 
         * Add a middleware to the end of a middleware group.
13409 
         *
13410 
         * If the middleware is already in the group, it will not be added again.
13411 
         *
13412 
         * @param string $group
13413 
         * @param string $middleware
13414 
         * @return \Illuminate\Routing\Router
13415 
         * @static
13416 
         */
13417 
        public static function pushMiddlewareToGroup($group, $middleware)
13418 
        {
13419 
                        /** @var \Illuminate\Routing\Router $instance */
13420 
                        return $instance->pushMiddlewareToGroup($group, $middleware);
13421 
        }
13422 
                    /**
13423 
         * Remove the given middleware from the specified group.
13424 
         *
13425 
         * @param string $group
13426 
         * @param string $middleware
13427 
         * @return \Illuminate\Routing\Router
13428 
         * @static
13429 
         */
13430 
        public static function removeMiddlewareFromGroup($group, $middleware)
13431 
        {
13432 
                        /** @var \Illuminate\Routing\Router $instance */
13433 
                        return $instance->removeMiddlewareFromGroup($group, $middleware);
13434 
        }
13435 
                    /**
13436 
         * Flush the router's middleware groups.
13437 
         *
13438 
         * @return \Illuminate\Routing\Router
13439 
         * @static
13440 
         */
13441 
        public static function flushMiddlewareGroups()
13442 
        {
13443 
                        /** @var \Illuminate\Routing\Router $instance */
13444 
                        return $instance->flushMiddlewareGroups();
13445 
        }
13446 
                    /**
13447 
         * Add a new route parameter binder.
13448 
         *
13449 
         * @param string $key
13450 
         * @param string|callable $binder
13451 
         * @return void
13452 
         * @static
13453 
         */
13454 
        public static function bind($key, $binder)
13455 
        {
13456 
                        /** @var \Illuminate\Routing\Router $instance */
13457 
                        $instance->bind($key, $binder);
13458 
        }
13459 
                    /**
13460 
         * Register a model binder for a wildcard.
13461 
         *
13462 
         * @param string $key
13463 
         * @param string $class
13464 
         * @param \Closure|null $callback
13465 
         * @return void
13466 
         * @static
13467 
         */
13468 
        public static function model($key, $class, $callback = null)
13469 
        {
13470 
                        /** @var \Illuminate\Routing\Router $instance */
13471 
                        $instance->model($key, $class, $callback);
13472 
        }
13473 
                    /**
13474 
         * Get the binding callback for a given binding.
13475 
         *
13476 
         * @param string $key
13477 
         * @return \Closure|null
13478 
         * @static
13479 
         */
13480 
        public static function getBindingCallback($key)
13481 
        {
13482 
                        /** @var \Illuminate\Routing\Router $instance */
13483 
                        return $instance->getBindingCallback($key);
13484 
        }
13485 
                    /**
13486 
         * Get the global "where" patterns.
13487 
         *
13488 
         * @return array
13489 
         * @static
13490 
         */
13491 
        public static function getPatterns()
13492 
        {
13493 
                        /** @var \Illuminate\Routing\Router $instance */
13494 
                        return $instance->getPatterns();
13495 
        }
13496 
                    /**
13497 
         * Set a global where pattern on all routes.
13498 
         *
13499 
         * @param string $key
13500 
         * @param string $pattern
13501 
         * @return void
13502 
         * @static
13503 
         */
13504 
        public static function pattern($key, $pattern)
13505 
        {
13506 
                        /** @var \Illuminate\Routing\Router $instance */
13507 
                        $instance->pattern($key, $pattern);
13508 
        }
13509 
                    /**
13510 
         * Set a group of global where patterns on all routes.
13511 
         *
13512 
         * @param array $patterns
13513 
         * @return void
13514 
         * @static
13515 
         */
13516 
        public static function patterns($patterns)
13517 
        {
13518 
                        /** @var \Illuminate\Routing\Router $instance */
13519 
                        $instance->patterns($patterns);
13520 
        }
13521 
                    /**
13522 
         * Determine if the router currently has a group stack.
13523 
         *
13524 
         * @return bool
13525 
         * @static
13526 
         */
13527 
        public static function hasGroupStack()
13528 
        {
13529 
                        /** @var \Illuminate\Routing\Router $instance */
13530 
                        return $instance->hasGroupStack();
13531 
        }
13532 
                    /**
13533 
         * Get the current group stack for the router.
13534 
         *
13535 
         * @return array
13536 
         * @static
13537 
         */
13538 
        public static function getGroupStack()
13539 
        {
13540 
                        /** @var \Illuminate\Routing\Router $instance */
13541 
                        return $instance->getGroupStack();
13542 
        }
13543 
                    /**
13544 
         * Get a route parameter for the current route.
13545 
         *
13546 
         * @param string $key
13547 
         * @param string|null $default
13548 
         * @return mixed
13549 
         * @static
13550 
         */
13551 
        public static function input($key, $default = null)
13552 
        {
13553 
                        /** @var \Illuminate\Routing\Router $instance */
13554 
                        return $instance->input($key, $default);
13555 
        }
13556 
                    /**
13557 
         * Get the request currently being dispatched.
13558 
         *
13559 
         * @return \Illuminate\Http\Request
13560 
         * @static
13561 
         */
13562 
        public static function getCurrentRequest()
13563 
        {
13564 
                        /** @var \Illuminate\Routing\Router $instance */
13565 
                        return $instance->getCurrentRequest();
13566 
        }
13567 
                    /**
13568 
         * Get the currently dispatched route instance.
13569 
         *
13570 
         * @return \Illuminate\Routing\Route|null
13571 
         * @static
13572 
         */
13573 
        public static function getCurrentRoute()
13574 
        {
13575 
                        /** @var \Illuminate\Routing\Router $instance */
13576 
                        return $instance->getCurrentRoute();
13577 
        }
13578 
                    /**
13579 
         * Get the currently dispatched route instance.
13580 
         *
13581 
         * @return \Illuminate\Routing\Route|null
13582 
         * @static
13583 
         */
13584 
        public static function current()
13585 
        {
13586 
                        /** @var \Illuminate\Routing\Router $instance */
13587 
                        return $instance->current();
13588 
        }
13589 
                    /**
13590 
         * Check if a route with the given name exists.
13591 
         *
13592 
         * @param string|array $name
13593 
         * @return bool
13594 
         * @static
13595 
         */
13596 
        public static function has($name)
13597 
        {
13598 
                        /** @var \Illuminate\Routing\Router $instance */
13599 
                        return $instance->has($name);
13600 
        }
13601 
                    /**
13602 
         * Get the current route name.
13603 
         *
13604 
         * @return string|null
13605 
         * @static
13606 
         */
13607 
        public static function currentRouteName()
13608 
        {
13609 
                        /** @var \Illuminate\Routing\Router $instance */
13610 
                        return $instance->currentRouteName();
13611 
        }
13612 
                    /**
13613 
         * Alias for the "currentRouteNamed" method.
13614 
         *
13615 
         * @param mixed $patterns
13616 
         * @return bool
13617 
         * @static
13618 
         */
13619 
        public static function is(...$patterns)
13620 
        {
13621 
                        /** @var \Illuminate\Routing\Router $instance */
13622 
                        return $instance->is(...$patterns);
13623 
        }
13624 
                    /**
13625 
         * Determine if the current route matches a pattern.
13626 
         *
13627 
         * @param mixed $patterns
13628 
         * @return bool
13629 
         * @static
13630 
         */
13631 
        public static function currentRouteNamed(...$patterns)
13632 
        {
13633 
                        /** @var \Illuminate\Routing\Router $instance */
13634 
                        return $instance->currentRouteNamed(...$patterns);
13635 
        }
13636 
                    /**
13637 
         * Get the current route action.
13638 
         *
13639 
         * @return string|null
13640 
         * @static
13641 
         */
13642 
        public static function currentRouteAction()
13643 
        {
13644 
                        /** @var \Illuminate\Routing\Router $instance */
13645 
                        return $instance->currentRouteAction();
13646 
        }
13647 
                    /**
13648 
         * Alias for the "currentRouteUses" method.
13649 
         *
13650 
         * @param array $patterns
13651 
         * @return bool
13652 
         * @static
13653 
         */
13654 
        public static function uses(...$patterns)
13655 
        {
13656 
                        /** @var \Illuminate\Routing\Router $instance */
13657 
                        return $instance->uses(...$patterns);
13658 
        }
13659 
                    /**
13660 
         * Determine if the current route action matches a given action.
13661 
         *
13662 
         * @param string $action
13663 
         * @return bool
13664 
         * @static
13665 
         */
13666 
        public static function currentRouteUses($action)
13667 
        {
13668 
                        /** @var \Illuminate\Routing\Router $instance */
13669 
                        return $instance->currentRouteUses($action);
13670 
        }
13671 
                    /**
13672 
         * Set the unmapped global resource parameters to singular.
13673 
         *
13674 
         * @param bool $singular
13675 
         * @return void
13676 
         * @static
13677 
         */
13678 
        public static function singularResourceParameters($singular = true)
13679 
        {
13680 
                        /** @var \Illuminate\Routing\Router $instance */
13681 
                        $instance->singularResourceParameters($singular);
13682 
        }
13683 
                    /**
13684 
         * Set the global resource parameter mapping.
13685 
         *
13686 
         * @param array $parameters
13687 
         * @return void
13688 
         * @static
13689 
         */
13690 
        public static function resourceParameters($parameters = [])
13691 
        {
13692 
                        /** @var \Illuminate\Routing\Router $instance */
13693 
                        $instance->resourceParameters($parameters);
13694 
        }
13695 
                    /**
13696 
         * Get or set the verbs used in the resource URIs.
13697 
         *
13698 
         * @param array $verbs
13699 
         * @return array|null
13700 
         * @static
13701 
         */
13702 
        public static function resourceVerbs($verbs = [])
13703 
        {
13704 
                        /** @var \Illuminate\Routing\Router $instance */
13705 
                        return $instance->resourceVerbs($verbs);
13706 
        }
13707 
                    /**
13708 
         * Get the underlying route collection.
13709 
         *
13710 
         * @return \Illuminate\Routing\RouteCollectionInterface
13711 
         * @static
13712 
         */
13713 
        public static function getRoutes()
13714 
        {
13715 
                        /** @var \Illuminate\Routing\Router $instance */
13716 
                        return $instance->getRoutes();
13717 
        }
13718 
                    /**
13719 
         * Set the route collection instance.
13720 
         *
13721 
         * @param \Illuminate\Routing\RouteCollection $routes
13722 
         * @return void
13723 
         * @static
13724 
         */
13725 
        public static function setRoutes($routes)
13726 
        {
13727 
                        /** @var \Illuminate\Routing\Router $instance */
13728 
                        $instance->setRoutes($routes);
13729 
        }
13730 
                    /**
13731 
         * Set the compiled route collection instance.
13732 
         *
13733 
         * @param array $routes
13734 
         * @return void
13735 
         * @static
13736 
         */
13737 
        public static function setCompiledRoutes($routes)
13738 
        {
13739 
                        /** @var \Illuminate\Routing\Router $instance */
13740 
                        $instance->setCompiledRoutes($routes);
13741 
        }
13742 
                    /**
13743 
         * Remove any duplicate middleware from the given array.
13744 
         *
13745 
         * @param array $middleware
13746 
         * @return array
13747 
         * @static
13748 
         */
13749 
        public static function uniqueMiddleware($middleware)
13750 
        {
13751 
                        return \Illuminate\Routing\Router::uniqueMiddleware($middleware);
13752 
        }
13753 
                    /**
13754 
         * Set the container instance used by the router.
13755 
         *
13756 
         * @param \Illuminate\Container\Container $container
13757 
         * @return \Illuminate\Routing\Router
13758 
         * @static
13759 
         */
13760 
        public static function setContainer($container)
13761 
        {
13762 
                        /** @var \Illuminate\Routing\Router $instance */
13763 
                        return $instance->setContainer($container);
13764 
        }
13765 
                    /**
13766 
         * Register a custom macro.
13767 
         *
13768 
         * @param string $name
13769 
         * @param object|callable $macro
13770 
         * @return void
13771 
         * @static
13772 
         */
13773 
        public static function macro($name, $macro)
13774 
        {
13775 
                        \Illuminate\Routing\Router::macro($name, $macro);
13776 
        }
13777 
                    /**
13778 
         * Mix another object into the class.
13779 
         *
13780 
         * @param object $mixin
13781 
         * @param bool $replace
13782 
         * @return void
13783 
         * @throws \ReflectionException
13784 
         * @static
13785 
         */
13786 
        public static function mixin($mixin, $replace = true)
13787 
        {
13788 
                        \Illuminate\Routing\Router::mixin($mixin, $replace);
13789 
        }
13790 
                    /**
13791 
         * Checks if macro is registered.
13792 
         *
13793 
         * @param string $name
13794 
         * @return bool
13795 
         * @static
13796 
         */
13797 
        public static function hasMacro($name)
13798 
        {
13799 
                        return \Illuminate\Routing\Router::hasMacro($name);
13800 
        }
13801 
                    /**
13802 
         * Flush the existing macros.
13803 
         *
13804 
         * @return void
13805 
         * @static
13806 
         */
13807 
        public static function flushMacros()
13808 
        {
13809 
                        \Illuminate\Routing\Router::flushMacros();
13810 
        }
13811 
                    /**
13812 
         * Dynamically handle calls to the class.
13813 
         *
13814 
         * @param string $method
13815 
         * @param array $parameters
13816 
         * @return mixed
13817 
         * @throws \BadMethodCallException
13818 
         * @static
13819 
         */
13820 
        public static function macroCall($method, $parameters)
13821 
        {
13822 
                        /** @var \Illuminate\Routing\Router $instance */
13823 
                        return $instance->macroCall($method, $parameters);
13824 
        }
13825 
 
13826 
    }
13827 
            /**
13828 
     *
13829 
     *
13830 
     * @see \Illuminate\Database\Schema\Builder
13831 
     */
13832 
        class Schema {
13833 
                    /**
13834 
         * Create a database in the schema.
13835 
         *
13836 
         * @param string $name
13837 
         * @return bool
13838 
         * @static
13839 
         */
13840 
        public static function createDatabase($name)
13841 
        {
13842 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13843 
                        return $instance->createDatabase($name);
13844 
        }
13845 
                    /**
13846 
         * Drop a database from the schema if the database exists.
13847 
         *
13848 
         * @param string $name
13849 
         * @return bool
13850 
         * @static
13851 
         */
13852 
        public static function dropDatabaseIfExists($name)
13853 
        {
13854 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13855 
                        return $instance->dropDatabaseIfExists($name);
13856 
        }
13857 
                    /**
13858 
         * Determine if the given table exists.
13859 
         *
13860 
         * @param string $table
13861 
         * @return bool
13862 
         * @static
13863 
         */
13864 
        public static function hasTable($table)
13865 
        {
13866 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13867 
                        return $instance->hasTable($table);
13868 
        }
13869 
                    /**
13870 
         * Get the column listing for a given table.
13871 
         *
13872 
         * @param string $table
13873 
         * @return array
13874 
         * @static
13875 
         */
13876 
        public static function getColumnListing($table)
13877 
        {
13878 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13879 
                        return $instance->getColumnListing($table);
13880 
        }
13881 
                    /**
13882 
         * Drop all tables from the database.
13883 
         *
13884 
         * @return void
13885 
         * @static
13886 
         */
13887 
        public static function dropAllTables()
13888 
        {
13889 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13890 
                        $instance->dropAllTables();
13891 
        }
13892 
                    /**
13893 
         * Drop all views from the database.
13894 
         *
13895 
         * @return void
13896 
         * @static
13897 
         */
13898 
        public static function dropAllViews()
13899 
        {
13900 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13901 
                        $instance->dropAllViews();
13902 
        }
13903 
                    /**
13904 
         * Get all of the table names for the database.
13905 
         *
13906 
         * @return array
13907 
         * @static
13908 
         */
13909 
        public static function getAllTables()
13910 
        {
13911 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13912 
                        return $instance->getAllTables();
13913 
        }
13914 
                    /**
13915 
         * Get all of the view names for the database.
13916 
         *
13917 
         * @return array
13918 
         * @static
13919 
         */
13920 
        public static function getAllViews()
13921 
        {
13922 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13923 
                        return $instance->getAllViews();
13924 
        }
13925 
                    /**
13926 
         * Set the default string length for migrations.
13927 
         *
13928 
         * @param int $length
13929 
         * @return void
13930 
         * @static
13931 
         */
13932 
        public static function defaultStringLength($length)
13933 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13934 
                        \Illuminate\Database\Schema\MySqlBuilder::defaultStringLength($length);
13935 
        }
13936 
                    /**
13937 
         * Set the default morph key type for migrations.
13938 
         *
13939 
         * @param string $type
13940 
         * @return void
13941 
         * @throws \InvalidArgumentException
13942 
         * @static
13943 
         */
13944 
        public static function defaultMorphKeyType($type)
13945 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13946 
                        \Illuminate\Database\Schema\MySqlBuilder::defaultMorphKeyType($type);
13947 
        }
13948 
                    /**
13949 
         * Set the default morph key type for migrations to UUIDs.
13950 
         *
13951 
         * @return void
13952 
         * @static
13953 
         */
13954 
        public static function morphUsingUuids()
13955 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13956 
                        \Illuminate\Database\Schema\MySqlBuilder::morphUsingUuids();
13957 
        }
13958 
                    /**
13959 
         * Set the default morph key type for migrations to ULIDs.
13960 
         *
13961 
         * @return void
13962 
         * @static
13963 
         */
13964 
        public static function morphUsingUlids()
13965 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13966 
                        \Illuminate\Database\Schema\MySqlBuilder::morphUsingUlids();
13967 
        }
13968 
                    /**
13969 
         * Attempt to use native schema operations for dropping and renaming columns, even if Doctrine DBAL is installed.
13970 
         *
13971 
         * @param bool $value
13972 
         * @return void
13973 
         * @static
13974 
         */
13975 
        public static function useNativeSchemaOperationsIfPossible($value = true)
13976 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13977 
                        \Illuminate\Database\Schema\MySqlBuilder::useNativeSchemaOperationsIfPossible($value);
13978 
        }
13979 
                    /**
13980 
         * Determine if the given table has a given column.
13981 
         *
13982 
         * @param string $table
13983 
         * @param string $column
13984 
         * @return bool
13985 
         * @static
13986 
         */
13987 
        public static function hasColumn($table, $column)
13988 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
13989 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13990 
                        return $instance->hasColumn($table, $column);
13991 
        }
13992 
                    /**
13993 
         * Determine if the given table has given columns.
13994 
         *
13995 
         * @param string $table
13996 
         * @param array $columns
13997 
         * @return bool
13998 
         * @static
13999 
         */
14000 
        public static function hasColumns($table, $columns)
14001 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14002 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14003 
                        return $instance->hasColumns($table, $columns);
14004 
        }
14005 
                    /**
14006 
         * Execute a table builder callback if the given table has a given column.
14007 
         *
14008 
         * @param string $table
14009 
         * @param string $column
14010 
         * @param \Closure $callback
14011 
         * @return void
14012 
         * @static
14013 
         */
14014 
        public static function whenTableHasColumn($table, $column, $callback)
14015 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14016 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14017 
                        $instance->whenTableHasColumn($table, $column, $callback);
14018 
        }
14019 
                    /**
14020 
         * Execute a table builder callback if the given table doesn't have a given column.
14021 
         *
14022 
         * @param string $table
14023 
         * @param string $column
14024 
         * @param \Closure $callback
14025 
         * @return void
14026 
         * @static
14027 
         */
14028 
        public static function whenTableDoesntHaveColumn($table, $column, $callback)
14029 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14030 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14031 
                        $instance->whenTableDoesntHaveColumn($table, $column, $callback);
14032 
        }
14033 
                    /**
14034 
         * Get the data type for the given column name.
14035 
         *
14036 
         * @param string $table
14037 
         * @param string $column
14038 
         * @return string
14039 
         * @static
14040 
         */
14041 
        public static function getColumnType($table, $column)
14042 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14043 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14044 
                        return $instance->getColumnType($table, $column);
14045 
        }
14046 
                    /**
14047 
         * Modify a table on the schema.
14048 
         *
14049 
         * @param string $table
14050 
         * @param \Closure $callback
14051 
         * @return void
14052 
         * @static
14053 
         */
14054 
        public static function table($table, $callback)
14055 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14056 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14057 
                        $instance->table($table, $callback);
14058 
        }
14059 
                    /**
14060 
         * Create a new table on the schema.
14061 
         *
14062 
         * @param string $table
14063 
         * @param \Closure $callback
14064 
         * @return void
14065 
         * @static
14066 
         */
14067 
        public static function create($table, $callback)
14068 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14069 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14070 
                        $instance->create($table, $callback);
14071 
        }
14072 
                    /**
14073 
         * Drop a table from the schema.
14074 
         *
14075 
         * @param string $table
14076 
         * @return void
14077 
         * @static
14078 
         */
14079 
        public static function drop($table)
14080 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14081 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14082 
                        $instance->drop($table);
14083 
        }
14084 
                    /**
14085 
         * Drop a table from the schema if it exists.
14086 
         *
14087 
         * @param string $table
14088 
         * @return void
14089 
         * @static
14090 
         */
14091 
        public static function dropIfExists($table)
14092 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14093 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14094 
                        $instance->dropIfExists($table);
14095 
        }
14096 
                    /**
14097 
         * Drop columns from a table schema.
14098 
         *
14099 
         * @param string $table
14100 
         * @param string|array $columns
14101 
         * @return void
14102 
         * @static
14103 
         */
14104 
        public static function dropColumns($table, $columns)
14105 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14106 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14107 
                        $instance->dropColumns($table, $columns);
14108 
        }
14109 
                    /**
14110 
         * Drop all types from the database.
14111 
         *
14112 
         * @return void
14113 
         * @throws \LogicException
14114 
         * @static
14115 
         */
14116 
        public static function dropAllTypes()
14117 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14118 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14119 
                        $instance->dropAllTypes();
14120 
        }
14121 
                    /**
14122 
         * Rename a table on the schema.
14123 
         *
14124 
         * @param string $from
14125 
         * @param string $to
14126 
         * @return void
14127 
         * @static
14128 
         */
14129 
        public static function rename($from, $to)
14130 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14131 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14132 
                        $instance->rename($from, $to);
14133 
        }
14134 
                    /**
14135 
         * Enable foreign key constraints.
14136 
         *
14137 
         * @return bool
14138 
         * @static
14139 
         */
14140 
        public static function enableForeignKeyConstraints()
14141 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14142 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14143 
                        return $instance->enableForeignKeyConstraints();
14144 
        }
14145 
                    /**
14146 
         * Disable foreign key constraints.
14147 
         *
14148 
         * @return bool
14149 
         * @static
14150 
         */
14151 
        public static function disableForeignKeyConstraints()
14152 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14153 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14154 
                        return $instance->disableForeignKeyConstraints();
14155 
        }
14156 
                    /**
14157 
         * Disable foreign key constraints during the execution of a callback.
14158 
         *
14159 
         * @param \Closure $callback
14160 
         * @return mixed
14161 
         * @static
14162 
         */
14163 
        public static function withoutForeignKeyConstraints($callback)
14164 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14165 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14166 
                        return $instance->withoutForeignKeyConstraints($callback);
14167 
        }
14168 
                    /**
14169 
         * Get the database connection instance.
14170 
         *
14171 
         * @return \Illuminate\Database\Connection
14172 
         * @static
14173 
         */
14174 
        public static function getConnection()
14175 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14176 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14177 
                        return $instance->getConnection();
14178 
        }
14179 
                    /**
14180 
         * Set the database connection instance.
14181 
         *
14182 
         * @param \Illuminate\Database\Connection $connection
14183 
         * @return \Illuminate\Database\Schema\MySqlBuilder
14184 
         * @static
14185 
         */
14186 
        public static function setConnection($connection)
14187 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14188 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14189 
                        return $instance->setConnection($connection);
14190 
        }
14191 
                    /**
14192 
         * Set the Schema Blueprint resolver callback.
14193 
         *
14194 
         * @param \Closure $resolver
14195 
         * @return void
14196 
         * @static
14197 
         */
14198 
        public static function blueprintResolver($resolver)
14199 
        {            //Method inherited from \Illuminate\Database\Schema\Builder
14200 
                        /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
14201 
                        $instance->blueprintResolver($resolver);
14202 
        }
14203 
 
14204 
    }
14205 
            /**
14206 
     *
14207 
     *
14208 
     * @see \Illuminate\Session\SessionManager
14209 
     */
14210 
        class Session {
14211 
                    /**
14212 
         * Determine if requests for the same session should wait for each to finish before executing.
14213 
         *
14214 
         * @return bool
14215 
         * @static
14216 
         */
14217 
        public static function shouldBlock()
14218 
        {
14219 
                        /** @var \Illuminate\Session\SessionManager $instance */
14220 
                        return $instance->shouldBlock();
14221 
        }
14222 
                    /**
14223 
         * Get the name of the cache store / driver that should be used to acquire session locks.
14224 
         *
14225 
         * @return string|null
14226 
         * @static
14227 
         */
14228 
        public static function blockDriver()
14229 
        {
14230 
                        /** @var \Illuminate\Session\SessionManager $instance */
14231 
                        return $instance->blockDriver();
14232 
        }
14233 
                    /**
14234 
         * Get the session configuration.
14235 
         *
14236 
         * @return array
14237 
         * @static
14238 
         */
14239 
        public static function getSessionConfig()
14240 
        {
14241 
                        /** @var \Illuminate\Session\SessionManager $instance */
14242 
                        return $instance->getSessionConfig();
14243 
        }
14244 
                    /**
14245 
         * Get the default session driver name.
14246 
         *
14247 
         * @return string
14248 
         * @static
14249 
         */
14250 
        public static function getDefaultDriver()
14251 
        {
14252 
                        /** @var \Illuminate\Session\SessionManager $instance */
14253 
                        return $instance->getDefaultDriver();
14254 
        }
14255 
                    /**
14256 
         * Set the default session driver name.
14257 
         *
14258 
         * @param string $name
14259 
         * @return void
14260 
         * @static
14261 
         */
14262 
        public static function setDefaultDriver($name)
14263 
        {
14264 
                        /** @var \Illuminate\Session\SessionManager $instance */
14265 
                        $instance->setDefaultDriver($name);
14266 
        }
14267 
                    /**
14268 
         * Get a driver instance.
14269 
         *
14270 
         * @param string|null $driver
14271 
         * @return mixed
14272 
         * @throws \InvalidArgumentException
14273 
         * @static
14274 
         */
14275 
        public static function driver($driver = null)
14276 
        {            //Method inherited from \Illuminate\Support\Manager
14277 
                        /** @var \Illuminate\Session\SessionManager $instance */
14278 
                        return $instance->driver($driver);
14279 
        }
14280 
                    /**
14281 
         * Register a custom driver creator Closure.
14282 
         *
14283 
         * @param string $driver
14284 
         * @param \Closure $callback
14285 
         * @return \Illuminate\Session\SessionManager
14286 
         * @static
14287 
         */
14288 
        public static function extend($driver, $callback)
14289 
        {            //Method inherited from \Illuminate\Support\Manager
14290 
                        /** @var \Illuminate\Session\SessionManager $instance */
14291 
                        return $instance->extend($driver, $callback);
14292 
        }
14293 
                    /**
14294 
         * Get all of the created "drivers".
14295 
         *
14296 
         * @return array
14297 
         * @static
14298 
         */
14299 
        public static function getDrivers()
14300 
        {            //Method inherited from \Illuminate\Support\Manager
14301 
                        /** @var \Illuminate\Session\SessionManager $instance */
14302 
                        return $instance->getDrivers();
14303 
        }
14304 
                    /**
14305 
         * Get the container instance used by the manager.
14306 
         *
14307 
         * @return \Illuminate\Contracts\Container\Container
14308 
         * @static
14309 
         */
14310 
        public static function getContainer()
14311 
        {            //Method inherited from \Illuminate\Support\Manager
14312 
                        /** @var \Illuminate\Session\SessionManager $instance */
14313 
                        return $instance->getContainer();
14314 
        }
14315 
                    /**
14316 
         * Set the container instance used by the manager.
14317 
         *
14318 
         * @param \Illuminate\Contracts\Container\Container $container
14319 
         * @return \Illuminate\Session\SessionManager
14320 
         * @static
14321 
         */
14322 
        public static function setContainer($container)
14323 
        {            //Method inherited from \Illuminate\Support\Manager
14324 
                        /** @var \Illuminate\Session\SessionManager $instance */
14325 
                        return $instance->setContainer($container);
14326 
        }
14327 
                    /**
14328 
         * Forget all of the resolved driver instances.
14329 
         *
14330 
         * @return \Illuminate\Session\SessionManager
14331 
         * @static
14332 
         */
14333 
        public static function forgetDrivers()
14334 
        {            //Method inherited from \Illuminate\Support\Manager
14335 
                        /** @var \Illuminate\Session\SessionManager $instance */
14336 
                        return $instance->forgetDrivers();
14337 
        }
14338 
                    /**
14339 
         * Start the session, reading the data from a handler.
14340 
         *
14341 
         * @return bool
14342 
         * @static
14343 
         */
14344 
        public static function start()
14345 
        {
14346 
                        /** @var \Illuminate\Session\Store $instance */
14347 
                        return $instance->start();
14348 
        }
14349 
                    /**
14350 
         * Save the session data to storage.
14351 
         *
14352 
         * @return void
14353 
         * @static
14354 
         */
14355 
        public static function save()
14356 
        {
14357 
                        /** @var \Illuminate\Session\Store $instance */
14358 
                        $instance->save();
14359 
        }
14360 
                    /**
14361 
         * Age the flash data for the session.
14362 
         *
14363 
         * @return void
14364 
         * @static
14365 
         */
14366 
        public static function ageFlashData()
14367 
        {
14368 
                        /** @var \Illuminate\Session\Store $instance */
14369 
                        $instance->ageFlashData();
14370 
        }
14371 
                    /**
14372 
         * Get all of the session data.
14373 
         *
14374 
         * @return array
14375 
         * @static
14376 
         */
14377 
        public static function all()
14378 
        {
14379 
                        /** @var \Illuminate\Session\Store $instance */
14380 
                        return $instance->all();
14381 
        }
14382 
                    /**
14383 
         * Get a subset of the session data.
14384 
         *
14385 
         * @param array $keys
14386 
         * @return array
14387 
         * @static
14388 
         */
14389 
        public static function only($keys)
14390 
        {
14391 
                        /** @var \Illuminate\Session\Store $instance */
14392 
                        return $instance->only($keys);
14393 
        }
14394 
                    /**
14395 
         * Checks if a key exists.
14396 
         *
14397 
         * @param string|array $key
14398 
         * @return bool
14399 
         * @static
14400 
         */
14401 
        public static function exists($key)
14402 
        {
14403 
                        /** @var \Illuminate\Session\Store $instance */
14404 
                        return $instance->exists($key);
14405 
        }
14406 
                    /**
14407 
         * Determine if the given key is missing from the session data.
14408 
         *
14409 
         * @param string|array $key
14410 
         * @return bool
14411 
         * @static
14412 
         */
14413 
        public static function missing($key)
14414 
        {
14415 
                        /** @var \Illuminate\Session\Store $instance */
14416 
                        return $instance->missing($key);
14417 
        }
14418 
                    /**
14419 
         * Checks if a key is present and not null.
14420 
         *
14421 
         * @param string|array $key
14422 
         * @return bool
14423 
         * @static
14424 
         */
14425 
        public static function has($key)
14426 
        {
14427 
                        /** @var \Illuminate\Session\Store $instance */
14428 
                        return $instance->has($key);
14429 
        }
14430 
                    /**
14431 
         * Get an item from the session.
14432 
         *
14433 
         * @param string $key
14434 
         * @param mixed $default
14435 
         * @return mixed
14436 
         * @static
14437 
         */
14438 
        public static function get($key, $default = null)
14439 
        {
14440 
                        /** @var \Illuminate\Session\Store $instance */
14441 
                        return $instance->get($key, $default);
14442 
        }
14443 
                    /**
14444 
         * Get the value of a given key and then forget it.
14445 
         *
14446 
         * @param string $key
14447 
         * @param mixed $default
14448 
         * @return mixed
14449 
         * @static
14450 
         */
14451 
        public static function pull($key, $default = null)
14452 
        {
14453 
                        /** @var \Illuminate\Session\Store $instance */
14454 
                        return $instance->pull($key, $default);
14455 
        }
14456 
                    /**
14457 
         * Determine if the session contains old input.
14458 
         *
14459 
         * @param string|null $key
14460 
         * @return bool
14461 
         * @static
14462 
         */
14463 
        public static function hasOldInput($key = null)
14464 
        {
14465 
                        /** @var \Illuminate\Session\Store $instance */
14466 
                        return $instance->hasOldInput($key);
14467 
        }
14468 
                    /**
14469 
         * Get the requested item from the flashed input array.
14470 
         *
14471 
         * @param string|null $key
14472 
         * @param mixed $default
14473 
         * @return mixed
14474 
         * @static
14475 
         */
14476 
        public static function getOldInput($key = null, $default = null)
14477 
        {
14478 
                        /** @var \Illuminate\Session\Store $instance */
14479 
                        return $instance->getOldInput($key, $default);
14480 
        }
14481 
                    /**
14482 
         * Replace the given session attributes entirely.
14483 
         *
14484 
         * @param array $attributes
14485 
         * @return void
14486 
         * @static
14487 
         */
14488 
        public static function replace($attributes)
14489 
        {
14490 
                        /** @var \Illuminate\Session\Store $instance */
14491 
                        $instance->replace($attributes);
14492 
        }
14493 
                    /**
14494 
         * Put a key / value pair or array of key / value pairs in the session.
14495 
         *
14496 
         * @param string|array $key
14497 
         * @param mixed $value
14498 
         * @return void
14499 
         * @static
14500 
         */
14501 
        public static function put($key, $value = null)
14502 
        {
14503 
                        /** @var \Illuminate\Session\Store $instance */
14504 
                        $instance->put($key, $value);
14505 
        }
14506 
                    /**
14507 
         * Get an item from the session, or store the default value.
14508 
         *
14509 
         * @param string $key
14510 
         * @param \Closure $callback
14511 
         * @return mixed
14512 
         * @static
14513 
         */
14514 
        public static function remember($key, $callback)
14515 
        {
14516 
                        /** @var \Illuminate\Session\Store $instance */
14517 
                        return $instance->remember($key, $callback);
14518 
        }
14519 
                    /**
14520 
         * Push a value onto a session array.
14521 
         *
14522 
         * @param string $key
14523 
         * @param mixed $value
14524 
         * @return void
14525 
         * @static
14526 
         */
14527 
        public static function push($key, $value)
14528 
        {
14529 
                        /** @var \Illuminate\Session\Store $instance */
14530 
                        $instance->push($key, $value);
14531 
        }
14532 
                    /**
14533 
         * Increment the value of an item in the session.
14534 
         *
14535 
         * @param string $key
14536 
         * @param int $amount
14537 
         * @return mixed
14538 
         * @static
14539 
         */
14540 
        public static function increment($key, $amount = 1)
14541 
        {
14542 
                        /** @var \Illuminate\Session\Store $instance */
14543 
                        return $instance->increment($key, $amount);
14544 
        }
14545 
                    /**
14546 
         * Decrement the value of an item in the session.
14547 
         *
14548 
         * @param string $key
14549 
         * @param int $amount
14550 
         * @return int
14551 
         * @static
14552 
         */
14553 
        public static function decrement($key, $amount = 1)
14554 
        {
14555 
                        /** @var \Illuminate\Session\Store $instance */
14556 
                        return $instance->decrement($key, $amount);
14557 
        }
14558 
                    /**
14559 
         * Flash a key / value pair to the session.
14560 
         *
14561 
         * @param string $key
14562 
         * @param mixed $value
14563 
         * @return void
14564 
         * @static
14565 
         */
14566 
        public static function flash($key, $value = true)
14567 
        {
14568 
                        /** @var \Illuminate\Session\Store $instance */
14569 
                        $instance->flash($key, $value);
14570 
        }
14571 
                    /**
14572 
         * Flash a key / value pair to the session for immediate use.
14573 
         *
14574 
         * @param string $key
14575 
         * @param mixed $value
14576 
         * @return void
14577 
         * @static
14578 
         */
14579 
        public static function now($key, $value)
14580 
        {
14581 
                        /** @var \Illuminate\Session\Store $instance */
14582 
                        $instance->now($key, $value);
14583 
        }
14584 
                    /**
14585 
         * Reflash all of the session flash data.
14586 
         *
14587 
         * @return void
14588 
         * @static
14589 
         */
14590 
        public static function reflash()
14591 
        {
14592 
                        /** @var \Illuminate\Session\Store $instance */
14593 
                        $instance->reflash();
14594 
        }
14595 
                    /**
14596 
         * Reflash a subset of the current flash data.
14597 
         *
14598 
         * @param array|mixed $keys
14599 
         * @return void
14600 
         * @static
14601 
         */
14602 
        public static function keep($keys = null)
14603 
        {
14604 
                        /** @var \Illuminate\Session\Store $instance */
14605 
                        $instance->keep($keys);
14606 
        }
14607 
                    /**
14608 
         * Flash an input array to the session.
14609 
         *
14610 
         * @param array $value
14611 
         * @return void
14612 
         * @static
14613 
         */
14614 
        public static function flashInput($value)
14615 
        {
14616 
                        /** @var \Illuminate\Session\Store $instance */
14617 
                        $instance->flashInput($value);
14618 
        }
14619 
                    /**
14620 
         * Remove an item from the session, returning its value.
14621 
         *
14622 
         * @param string $key
14623 
         * @return mixed
14624 
         * @static
14625 
         */
14626 
        public static function remove($key)
14627 
        {
14628 
                        /** @var \Illuminate\Session\Store $instance */
14629 
                        return $instance->remove($key);
14630 
        }
14631 
                    /**
14632 
         * Remove one or many items from the session.
14633 
         *
14634 
         * @param string|array $keys
14635 
         * @return void
14636 
         * @static
14637 
         */
14638 
        public static function forget($keys)
14639 
        {
14640 
                        /** @var \Illuminate\Session\Store $instance */
14641 
                        $instance->forget($keys);
14642 
        }
14643 
                    /**
14644 
         * Remove all of the items from the session.
14645 
         *
14646 
         * @return void
14647 
         * @static
14648 
         */
14649 
        public static function flush()
14650 
        {
14651 
                        /** @var \Illuminate\Session\Store $instance */
14652 
                        $instance->flush();
14653 
        }
14654 
                    /**
14655 
         * Flush the session data and regenerate the ID.
14656 
         *
14657 
         * @return bool
14658 
         * @static
14659 
         */
14660 
        public static function invalidate()
14661 
        {
14662 
                        /** @var \Illuminate\Session\Store $instance */
14663 
                        return $instance->invalidate();
14664 
        }
14665 
                    /**
14666 
         * Generate a new session identifier.
14667 
         *
14668 
         * @param bool $destroy
14669 
         * @return bool
14670 
         * @static
14671 
         */
14672 
        public static function regenerate($destroy = false)
14673 
        {
14674 
                        /** @var \Illuminate\Session\Store $instance */
14675 
                        return $instance->regenerate($destroy);
14676 
        }
14677 
                    /**
14678 
         * Generate a new session ID for the session.
14679 
         *
14680 
         * @param bool $destroy
14681 
         * @return bool
14682 
         * @static
14683 
         */
14684 
        public static function migrate($destroy = false)
14685 
        {
14686 
                        /** @var \Illuminate\Session\Store $instance */
14687 
                        return $instance->migrate($destroy);
14688 
        }
14689 
                    /**
14690 
         * Determine if the session has been started.
14691 
         *
14692 
         * @return bool
14693 
         * @static
14694 
         */
14695 
        public static function isStarted()
14696 
        {
14697 
                        /** @var \Illuminate\Session\Store $instance */
14698 
                        return $instance->isStarted();
14699 
        }
14700 
                    /**
14701 
         * Get the name of the session.
14702 
         *
14703 
         * @return string
14704 
         * @static
14705 
         */
14706 
        public static function getName()
14707 
        {
14708 
                        /** @var \Illuminate\Session\Store $instance */
14709 
                        return $instance->getName();
14710 
        }
14711 
                    /**
14712 
         * Set the name of the session.
14713 
         *
14714 
         * @param string $name
14715 
         * @return void
14716 
         * @static
14717 
         */
14718 
        public static function setName($name)
14719 
        {
14720 
                        /** @var \Illuminate\Session\Store $instance */
14721 
                        $instance->setName($name);
14722 
        }
14723 
                    /**
14724 
         * Get the current session ID.
14725 
         *
14726 
         * @return string
14727 
         * @static
14728 
         */
14729 
        public static function getId()
14730 
        {
14731 
                        /** @var \Illuminate\Session\Store $instance */
14732 
                        return $instance->getId();
14733 
        }
14734 
                    /**
14735 
         * Set the session ID.
14736 
         *
14737 
         * @param string|null $id
14738 
         * @return void
14739 
         * @static
14740 
         */
14741 
        public static function setId($id)
14742 
        {
14743 
                        /** @var \Illuminate\Session\Store $instance */
14744 
                        $instance->setId($id);
14745 
        }
14746 
                    /**
14747 
         * Determine if this is a valid session ID.
14748 
         *
14749 
         * @param string|null $id
14750 
         * @return bool
14751 
         * @static
14752 
         */
14753 
        public static function isValidId($id)
14754 
        {
14755 
                        /** @var \Illuminate\Session\Store $instance */
14756 
                        return $instance->isValidId($id);
14757 
        }
14758 
                    /**
14759 
         * Set the existence of the session on the handler if applicable.
14760 
         *
14761 
         * @param bool $value
14762 
         * @return void
14763 
         * @static
14764 
         */
14765 
        public static function setExists($value)
14766 
        {
14767 
                        /** @var \Illuminate\Session\Store $instance */
14768 
                        $instance->setExists($value);
14769 
        }
14770 
                    /**
14771 
         * Get the CSRF token value.
14772 
         *
14773 
         * @return string
14774 
         * @static
14775 
         */
14776 
        public static function token()
14777 
        {
14778 
                        /** @var \Illuminate\Session\Store $instance */
14779 
                        return $instance->token();
14780 
        }
14781 
                    /**
14782 
         * Regenerate the CSRF token value.
14783 
         *
14784 
         * @return void
14785 
         * @static
14786 
         */
14787 
        public static function regenerateToken()
14788 
        {
14789 
                        /** @var \Illuminate\Session\Store $instance */
14790 
                        $instance->regenerateToken();
14791 
        }
14792 
                    /**
14793 
         * Get the previous URL from the session.
14794 
         *
14795 
         * @return string|null
14796 
         * @static
14797 
         */
14798 
        public static function previousUrl()
14799 
        {
14800 
                        /** @var \Illuminate\Session\Store $instance */
14801 
                        return $instance->previousUrl();
14802 
        }
14803 
                    /**
14804 
         * Set the "previous" URL in the session.
14805 
         *
14806 
         * @param string $url
14807 
         * @return void
14808 
         * @static
14809 
         */
14810 
        public static function setPreviousUrl($url)
14811 
        {
14812 
                        /** @var \Illuminate\Session\Store $instance */
14813 
                        $instance->setPreviousUrl($url);
14814 
        }
14815 
                    /**
14816 
         * Specify that the user has confirmed their password.
14817 
         *
14818 
         * @return void
14819 
         * @static
14820 
         */
14821 
        public static function passwordConfirmed()
14822 
        {
14823 
                        /** @var \Illuminate\Session\Store $instance */
14824 
                        $instance->passwordConfirmed();
14825 
        }
14826 
                    /**
14827 
         * Get the underlying session handler implementation.
14828 
         *
14829 
         * @return \SessionHandlerInterface
14830 
         * @static
14831 
         */
14832 
        public static function getHandler()
14833 
        {
14834 
                        /** @var \Illuminate\Session\Store $instance */
14835 
                        return $instance->getHandler();
14836 
        }
14837 
                    /**
14838 
         * Set the underlying session handler implementation.
14839 
         *
14840 
         * @param \SessionHandlerInterface $handler
14841 
         * @return \SessionHandlerInterface
14842 
         * @static
14843 
         */
14844 
        public static function setHandler($handler)
14845 
        {
14846 
                        /** @var \Illuminate\Session\Store $instance */
14847 
                        return $instance->setHandler($handler);
14848 
        }
14849 
                    /**
14850 
         * Determine if the session handler needs a request.
14851 
         *
14852 
         * @return bool
14853 
         * @static
14854 
         */
14855 
        public static function handlerNeedsRequest()
14856 
        {
14857 
                        /** @var \Illuminate\Session\Store $instance */
14858 
                        return $instance->handlerNeedsRequest();
14859 
        }
14860 
                    /**
14861 
         * Set the request on the handler instance.
14862 
         *
14863 
         * @param \Illuminate\Http\Request $request
14864 
         * @return void
14865 
         * @static
14866 
         */
14867 
        public static function setRequestOnHandler($request)
14868 
        {
14869 
                        /** @var \Illuminate\Session\Store $instance */
14870 
                        $instance->setRequestOnHandler($request);
14871 
        }
14872 
                    /**
14873 
         * Register a custom macro.
14874 
         *
14875 
         * @param string $name
14876 
         * @param object|callable $macro
14877 
         * @return void
14878 
         * @static
14879 
         */
14880 
        public static function macro($name, $macro)
14881 
        {
14882 
                        \Illuminate\Session\Store::macro($name, $macro);
14883 
        }
14884 
                    /**
14885 
         * Mix another object into the class.
14886 
         *
14887 
         * @param object $mixin
14888 
         * @param bool $replace
14889 
         * @return void
14890 
         * @throws \ReflectionException
14891 
         * @static
14892 
         */
14893 
        public static function mixin($mixin, $replace = true)
14894 
        {
14895 
                        \Illuminate\Session\Store::mixin($mixin, $replace);
14896 
        }
14897 
                    /**
14898 
         * Checks if macro is registered.
14899 
         *
14900 
         * @param string $name
14901 
         * @return bool
14902 
         * @static
14903 
         */
14904 
        public static function hasMacro($name)
14905 
        {
14906 
                        return \Illuminate\Session\Store::hasMacro($name);
14907 
        }
14908 
                    /**
14909 
         * Flush the existing macros.
14910 
         *
14911 
         * @return void
14912 
         * @static
14913 
         */
14914 
        public static function flushMacros()
14915 
        {
14916 
                        \Illuminate\Session\Store::flushMacros();
14917 
        }
14918 
 
14919 
    }
14920 
            /**
14921 
     *
14922 
     *
14923 
     * @method static bool has(string $location)
14924 
     * @method static string read(string $location)
14925 
     * @method static \League\Flysystem\DirectoryListing listContents(string $location, bool $deep = false)
14926 
     * @method static int fileSize(string $path)
14927 
     * @method static string visibility(string $path)
14928 
     * @method static void write(string $location, string $contents, array $config = [])
14929 
     * @method static void createDirectory(string $location, array $config = [])
14930 
     * @see \Illuminate\Filesystem\FilesystemManager
14931 
     */
14932 
        class Storage {
14933 
                    /**
14934 
         * Get a filesystem instance.
14935 
         *
14936 
         * @param string|null $name
14937 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14938 
         * @static
14939 
         */
14940 
        public static function drive($name = null)
14941 
        {
14942 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14943 
                        return $instance->drive($name);
14944 
        }
14945 
                    /**
14946 
         * Get a filesystem instance.
14947 
         *
14948 
         * @param string|null $name
14949 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14950 
         * @static
14951 
         */
14952 
        public static function disk($name = null)
14953 
        {
14954 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14955 
                        return $instance->disk($name);
14956 
        }
14957 
                    /**
14958 
         * Get a default cloud filesystem instance.
14959 
         *
14960 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14961 
         * @static
14962 
         */
14963 
        public static function cloud()
14964 
        {
14965 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14966 
                        return $instance->cloud();
14967 
        }
14968 
                    /**
14969 
         * Build an on-demand disk.
14970 
         *
14971 
         * @param string|array $config
14972 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14973 
         * @static
14974 
         */
14975 
        public static function build($config)
14976 
        {
14977 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14978 
                        return $instance->build($config);
14979 
        }
14980 
                    /**
14981 
         * Create an instance of the local driver.
14982 
         *
14983 
         * @param array $config
14984 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14985 
         * @static
14986 
         */
14987 
        public static function createLocalDriver($config)
14988 
        {
14989 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14990 
                        return $instance->createLocalDriver($config);
14991 
        }
14992 
                    /**
14993 
         * Create an instance of the ftp driver.
14994 
         *
14995 
         * @param array $config
14996 
         * @return \Illuminate\Filesystem\FilesystemAdapter
14997 
         * @static
14998 
         */
14999 
        public static function createFtpDriver($config)
15000 
        {
15001 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15002 
                        return $instance->createFtpDriver($config);
15003 
        }
15004 
                    /**
15005 
         * Create an instance of the sftp driver.
15006 
         *
15007 
         * @param array $config
15008 
         * @return \Illuminate\Filesystem\FilesystemAdapter
15009 
         * @static
15010 
         */
15011 
        public static function createSftpDriver($config)
15012 
        {
15013 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15014 
                        return $instance->createSftpDriver($config);
15015 
        }
15016 
                    /**
15017 
         * Create an instance of the Amazon S3 driver.
15018 
         *
15019 
         * @param array $config
15020 
         * @return \Illuminate\Contracts\Filesystem\Cloud
15021 
         * @static
15022 
         */
15023 
        public static function createS3Driver($config)
15024 
        {
15025 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15026 
                        return $instance->createS3Driver($config);
15027 
        }
15028 
                    /**
15029 
         * Create a scoped driver.
15030 
         *
15031 
         * @param array $config
15032 
         * @return \Illuminate\Filesystem\FilesystemAdapter
15033 
         * @static
15034 
         */
15035 
        public static function createScopedDriver($config)
15036 
        {
15037 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15038 
                        return $instance->createScopedDriver($config);
15039 
        }
15040 
                    /**
15041 
         * Set the given disk instance.
15042 
         *
15043 
         * @param string $name
15044 
         * @param mixed $disk
15045 
         * @return \Illuminate\Filesystem\FilesystemManager
15046 
         * @static
15047 
         */
15048 
        public static function set($name, $disk)
15049 
        {
15050 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15051 
                        return $instance->set($name, $disk);
15052 
        }
15053 
                    /**
15054 
         * Get the default driver name.
15055 
         *
15056 
         * @return string
15057 
         * @static
15058 
         */
15059 
        public static function getDefaultDriver()
15060 
        {
15061 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15062 
                        return $instance->getDefaultDriver();
15063 
        }
15064 
                    /**
15065 
         * Get the default cloud driver name.
15066 
         *
15067 
         * @return string
15068 
         * @static
15069 
         */
15070 
        public static function getDefaultCloudDriver()
15071 
        {
15072 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15073 
                        return $instance->getDefaultCloudDriver();
15074 
        }
15075 
                    /**
15076 
         * Unset the given disk instances.
15077 
         *
15078 
         * @param array|string $disk
15079 
         * @return \Illuminate\Filesystem\FilesystemManager
15080 
         * @static
15081 
         */
15082 
        public static function forgetDisk($disk)
15083 
        {
15084 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15085 
                        return $instance->forgetDisk($disk);
15086 
        }
15087 
                    /**
15088 
         * Disconnect the given disk and remove from local cache.
15089 
         *
15090 
         * @param string|null $name
15091 
         * @return void
15092 
         * @static
15093 
         */
15094 
        public static function purge($name = null)
15095 
        {
15096 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15097 
                        $instance->purge($name);
15098 
        }
15099 
                    /**
15100 
         * Register a custom driver creator Closure.
15101 
         *
15102 
         * @param string $driver
15103 
         * @param \Closure $callback
15104 
         * @return \Illuminate\Filesystem\FilesystemManager
15105 
         * @static
15106 
         */
15107 
        public static function extend($driver, $callback)
15108 
        {
15109 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15110 
                        return $instance->extend($driver, $callback);
15111 
        }
15112 
                    /**
15113 
         * Set the application instance used by the manager.
15114 
         *
15115 
         * @param \Illuminate\Contracts\Foundation\Application $app
15116 
         * @return \Illuminate\Filesystem\FilesystemManager
15117 
         * @static
15118 
         */
15119 
        public static function setApplication($app)
15120 
        {
15121 
                        /** @var \Illuminate\Filesystem\FilesystemManager $instance */
15122 
                        return $instance->setApplication($app);
15123 
        }
15124 
                    /**
15125 
         * Assert that the given file or directory exists.
15126 
         *
15127 
         * @param string|array $path
15128 
         * @param string|null $content
15129 
         * @return \Illuminate\Filesystem\FilesystemAdapter
15130 
         * @static
15131 
         */
15132 
        public static function assertExists($path, $content = null)
15133 
        {
15134 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15135 
                        return $instance->assertExists($path, $content);
15136 
        }
15137 
                    /**
15138 
         * Assert that the given file or directory does not exist.
15139 
         *
15140 
         * @param string|array $path
15141 
         * @return \Illuminate\Filesystem\FilesystemAdapter
15142 
         * @static
15143 
         */
15144 
        public static function assertMissing($path)
15145 
        {
15146 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15147 
                        return $instance->assertMissing($path);
15148 
        }
15149 
                    /**
15150 
         * Assert that the given directory is empty.
15151 
         *
15152 
         * @param string $path
15153 
         * @return \Illuminate\Filesystem\FilesystemAdapter
15154 
         * @static
15155 
         */
15156 
        public static function assertDirectoryEmpty($path)
15157 
        {
15158 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15159 
                        return $instance->assertDirectoryEmpty($path);
15160 
        }
15161 
                    /**
15162 
         * Determine if a file or directory exists.
15163 
         *
15164 
         * @param string $path
15165 
         * @return bool
15166 
         * @static
15167 
         */
15168 
        public static function exists($path)
15169 
        {
15170 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15171 
                        return $instance->exists($path);
15172 
        }
15173 
                    /**
15174 
         * Determine if a file or directory is missing.
15175 
         *
15176 
         * @param string $path
15177 
         * @return bool
15178 
         * @static
15179 
         */
15180 
        public static function missing($path)
15181 
        {
15182 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15183 
                        return $instance->missing($path);
15184 
        }
15185 
                    /**
15186 
         * Determine if a file exists.
15187 
         *
15188 
         * @param string $path
15189 
         * @return bool
15190 
         * @static
15191 
         */
15192 
        public static function fileExists($path)
15193 
        {
15194 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15195 
                        return $instance->fileExists($path);
15196 
        }
15197 
                    /**
15198 
         * Determine if a file is missing.
15199 
         *
15200 
         * @param string $path
15201 
         * @return bool
15202 
         * @static
15203 
         */
15204 
        public static function fileMissing($path)
15205 
        {
15206 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15207 
                        return $instance->fileMissing($path);
15208 
        }
15209 
                    /**
15210 
         * Determine if a directory exists.
15211 
         *
15212 
         * @param string $path
15213 
         * @return bool
15214 
         * @static
15215 
         */
15216 
        public static function directoryExists($path)
15217 
        {
15218 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15219 
                        return $instance->directoryExists($path);
15220 
        }
15221 
                    /**
15222 
         * Determine if a directory is missing.
15223 
         *
15224 
         * @param string $path
15225 
         * @return bool
15226 
         * @static
15227 
         */
15228 
        public static function directoryMissing($path)
15229 
        {
15230 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15231 
                        return $instance->directoryMissing($path);
15232 
        }
15233 
                    /**
15234 
         * Get the full path for the file at the given "short" path.
15235 
         *
15236 
         * @param string $path
15237 
         * @return string
15238 
         * @static
15239 
         */
15240 
        public static function path($path)
15241 
        {
15242 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15243 
                        return $instance->path($path);
15244 
        }
15245 
                    /**
15246 
         * Get the contents of a file.
15247 
         *
15248 
         * @param string $path
15249 
         * @return string|null
15250 
         * @static
15251 
         */
15252 
        public static function get($path)
15253 
        {
15254 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15255 
                        return $instance->get($path);
15256 
        }
15257 
                    /**
15258 
         * Create a streamed response for a given file.
15259 
         *
15260 
         * @param string $path
15261 
         * @param string|null $name
15262 
         * @param array $headers
15263 
         * @param string|null $disposition
15264 
         * @return \Symfony\Component\HttpFoundation\StreamedResponse
15265 
         * @static
15266 
         */
15267 
        public static function response($path, $name = null, $headers = [], $disposition = 'inline')
15268 
        {
15269 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15270 
                        return $instance->response($path, $name, $headers, $disposition);
15271 
        }
15272 
                    /**
15273 
         * Create a streamed download response for a given file.
15274 
         *
15275 
         * @param string $path
15276 
         * @param string|null $name
15277 
         * @return \Symfony\Component\HttpFoundation\StreamedResponse
15278 
         * @static
15279 
         */
15280 
        public static function download($path, $name = null, $headers = [])
15281 
        {
15282 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15283 
                        return $instance->download($path, $name, $headers);
15284 
        }
15285 
                    /**
15286 
         * Write the contents of a file.
15287 
         *
15288 
         * @param string $path
15289 
         * @param \Psr\Http\Message\StreamInterface|\Illuminate\Http\File|\Illuminate\Http\UploadedFile|string|resource $contents
15290 
         * @param mixed $options
15291 
         * @return string|bool
15292 
         * @static
15293 
         */
15294 
        public static function put($path, $contents, $options = [])
15295 
        {
15296 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15297 
                        return $instance->put($path, $contents, $options);
15298 
        }
15299 
                    /**
15300 
         * Store the uploaded file on the disk.
15301 
         *
15302 
         * @param string $path
15303 
         * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile|string $file
15304 
         * @param mixed $options
15305 
         * @return string|false
15306 
         * @static
15307 
         */
15308 
        public static function putFile($path, $file, $options = [])
15309 
        {
15310 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15311 
                        return $instance->putFile($path, $file, $options);
15312 
        }
15313 
                    /**
15314 
         * Store the uploaded file on the disk with a given name.
15315 
         *
15316 
         * @param string $path
15317 
         * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile|string $file
15318 
         * @param string $name
15319 
         * @param mixed $options
15320 
         * @return string|false
15321 
         * @static
15322 
         */
15323 
        public static function putFileAs($path, $file, $name, $options = [])
15324 
        {
15325 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15326 
                        return $instance->putFileAs($path, $file, $name, $options);
15327 
        }
15328 
                    /**
15329 
         * Get the visibility for the given path.
15330 
         *
15331 
         * @param string $path
15332 
         * @return string
15333 
         * @static
15334 
         */
15335 
        public static function getVisibility($path)
15336 
        {
15337 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15338 
                        return $instance->getVisibility($path);
15339 
        }
15340 
                    /**
15341 
         * Set the visibility for the given path.
15342 
         *
15343 
         * @param string $path
15344 
         * @param string $visibility
15345 
         * @return bool
15346 
         * @static
15347 
         */
15348 
        public static function setVisibility($path, $visibility)
15349 
        {
15350 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15351 
                        return $instance->setVisibility($path, $visibility);
15352 
        }
15353 
                    /**
15354 
         * Prepend to a file.
15355 
         *
15356 
         * @param string $path
15357 
         * @param string $data
15358 
         * @param string $separator
15359 
         * @return bool
15360 
         * @static
15361 
         */
15362 
        public static function prepend($path, $data, $separator = '
15363 
')
15364 
        {
15365 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15366 
                        return $instance->prepend($path, $data, $separator);
15367 
        }
15368 
                    /**
15369 
         * Append to a file.
15370 
         *
15371 
         * @param string $path
15372 
         * @param string $data
15373 
         * @param string $separator
15374 
         * @return bool
15375 
         * @static
15376 
         */
15377 
        public static function append($path, $data, $separator = '
15378 
')
15379 
        {
15380 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15381 
                        return $instance->append($path, $data, $separator);
15382 
        }
15383 
                    /**
15384 
         * Delete the file at a given path.
15385 
         *
15386 
         * @param string|array $paths
15387 
         * @return bool
15388 
         * @static
15389 
         */
15390 
        public static function delete($paths)
15391 
        {
15392 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15393 
                        return $instance->delete($paths);
15394 
        }
15395 
                    /**
15396 
         * Copy a file to a new location.
15397 
         *
15398 
         * @param string $from
15399 
         * @param string $to
15400 
         * @return bool
15401 
         * @static
15402 
         */
15403 
        public static function copy($from, $to)
15404 
        {
15405 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15406 
                        return $instance->copy($from, $to);
15407 
        }
15408 
                    /**
15409 
         * Move a file to a new location.
15410 
         *
15411 
         * @param string $from
15412 
         * @param string $to
15413 
         * @return bool
15414 
         * @static
15415 
         */
15416 
        public static function move($from, $to)
15417 
        {
15418 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15419 
                        return $instance->move($from, $to);
15420 
        }
15421 
                    /**
15422 
         * Get the file size of a given file.
15423 
         *
15424 
         * @param string $path
15425 
         * @return int
15426 
         * @static
15427 
         */
15428 
        public static function size($path)
15429 
        {
15430 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15431 
                        return $instance->size($path);
15432 
        }
15433 
                    /**
15434 
         * Get the checksum for a file.
15435 
         *
15436 
         * @return string|false
15437 
         * @throws UnableToProvideChecksum
15438 
         * @static
15439 
         */
15440 
        public static function checksum($path, $options = [])
15441 
        {
15442 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15443 
                        return $instance->checksum($path, $options);
15444 
        }
15445 
                    /**
15446 
         * Get the mime-type of a given file.
15447 
         *
15448 
         * @param string $path
15449 
         * @return string|false
15450 
         * @static
15451 
         */
15452 
        public static function mimeType($path)
15453 
        {
15454 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15455 
                        return $instance->mimeType($path);
15456 
        }
15457 
                    /**
15458 
         * Get the file's last modification time.
15459 
         *
15460 
         * @param string $path
15461 
         * @return int
15462 
         * @static
15463 
         */
15464 
        public static function lastModified($path)
15465 
        {
15466 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15467 
                        return $instance->lastModified($path);
15468 
        }
15469 
                    /**
15470 
         * Get a resource to read the file.
15471 
         *
15472 
         * @param string $path
15473 
         * @return resource|null The path resource or null on failure.
15474 
         * @static
15475 
         */
15476 
        public static function readStream($path)
15477 
        {
15478 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15479 
                        return $instance->readStream($path);
15480 
        }
15481 
                    /**
15482 
         * Write a new file using a stream.
15483 
         *
15484 
         * @param string $path
15485 
         * @param resource $resource
15486 
         * @param array $options
15487 
         * @return bool
15488 
         * @static
15489 
         */
15490 
        public static function writeStream($path, $resource, $options = [])
15491 
        {
15492 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15493 
                        return $instance->writeStream($path, $resource, $options);
15494 
        }
15495 
                    /**
15496 
         * Get the URL for the file at the given path.
15497 
         *
15498 
         * @param string $path
15499 
         * @return string
15500 
         * @throws \RuntimeException
15501 
         * @static
15502 
         */
15503 
        public static function url($path)
15504 
        {
15505 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15506 
                        return $instance->url($path);
15507 
        }
15508 
                    /**
15509 
         * Determine if temporary URLs can be generated.
15510 
         *
15511 
         * @return bool
15512 
         * @static
15513 
         */
15514 
        public static function providesTemporaryUrls()
15515 
        {
15516 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15517 
                        return $instance->providesTemporaryUrls();
15518 
        }
15519 
                    /**
15520 
         * Get a temporary URL for the file at the given path.
15521 
         *
15522 
         * @param string $path
15523 
         * @param \DateTimeInterface $expiration
15524 
         * @param array $options
15525 
         * @return string
15526 
         * @throws \RuntimeException
15527 
         * @static
15528 
         */
15529 
        public static function temporaryUrl($path, $expiration, $options = [])
15530 
        {
15531 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15532 
                        return $instance->temporaryUrl($path, $expiration, $options);
15533 
        }
15534 
                    /**
15535 
         * Get a temporary upload URL for the file at the given path.
15536 
         *
15537 
         * @param string $path
15538 
         * @param \DateTimeInterface $expiration
15539 
         * @param array $options
15540 
         * @return array
15541 
         * @throws \RuntimeException
15542 
         * @static
15543 
         */
15544 
        public static function temporaryUploadUrl($path, $expiration, $options = [])
15545 
        {
15546 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15547 
                        return $instance->temporaryUploadUrl($path, $expiration, $options);
15548 
        }
15549 
                    /**
15550 
         * Get an array of all files in a directory.
15551 
         *
15552 
         * @param string|null $directory
15553 
         * @param bool $recursive
15554 
         * @return array
15555 
         * @static
15556 
         */
15557 
        public static function files($directory = null, $recursive = false)
15558 
        {
15559 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15560 
                        return $instance->files($directory, $recursive);
15561 
        }
15562 
                    /**
15563 
         * Get all of the files from the given directory (recursive).
15564 
         *
15565 
         * @param string|null $directory
15566 
         * @return array
15567 
         * @static
15568 
         */
15569 
        public static function allFiles($directory = null)
15570 
        {
15571 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15572 
                        return $instance->allFiles($directory);
15573 
        }
15574 
                    /**
15575 
         * Get all of the directories within a given directory.
15576 
         *
15577 
         * @param string|null $directory
15578 
         * @param bool $recursive
15579 
         * @return array
15580 
         * @static
15581 
         */
15582 
        public static function directories($directory = null, $recursive = false)
15583 
        {
15584 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15585 
                        return $instance->directories($directory, $recursive);
15586 
        }
15587 
                    /**
15588 
         * Get all the directories within a given directory (recursive).
15589 
         *
15590 
         * @param string|null $directory
15591 
         * @return array
15592 
         * @static
15593 
         */
15594 
        public static function allDirectories($directory = null)
15595 
        {
15596 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15597 
                        return $instance->allDirectories($directory);
15598 
        }
15599 
                    /**
15600 
         * Create a directory.
15601 
         *
15602 
         * @param string $path
15603 
         * @return bool
15604 
         * @static
15605 
         */
15606 
        public static function makeDirectory($path)
15607 
        {
15608 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15609 
                        return $instance->makeDirectory($path);
15610 
        }
15611 
                    /**
15612 
         * Recursively delete a directory.
15613 
         *
15614 
         * @param string $directory
15615 
         * @return bool
15616 
         * @static
15617 
         */
15618 
        public static function deleteDirectory($directory)
15619 
        {
15620 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15621 
                        return $instance->deleteDirectory($directory);
15622 
        }
15623 
                    /**
15624 
         * Get the Flysystem driver.
15625 
         *
15626 
         * @return \League\Flysystem\FilesystemOperator
15627 
         * @static
15628 
         */
15629 
        public static function getDriver()
15630 
        {
15631 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15632 
                        return $instance->getDriver();
15633 
        }
15634 
                    /**
15635 
         * Get the Flysystem adapter.
15636 
         *
15637 
         * @return \League\Flysystem\FilesystemAdapter
15638 
         * @static
15639 
         */
15640 
        public static function getAdapter()
15641 
        {
15642 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15643 
                        return $instance->getAdapter();
15644 
        }
15645 
                    /**
15646 
         * Get the configuration values.
15647 
         *
15648 
         * @return array
15649 
         * @static
15650 
         */
15651 
        public static function getConfig()
15652 
        {
15653 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15654 
                        return $instance->getConfig();
15655 
        }
15656 
                    /**
15657 
         * Define a custom temporary URL builder callback.
15658 
         *
15659 
         * @param \Closure $callback
15660 
         * @return void
15661 
         * @static
15662 
         */
15663 
        public static function buildTemporaryUrlsUsing($callback)
15664 
        {
15665 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15666 
                        $instance->buildTemporaryUrlsUsing($callback);
15667 
        }
15668 
                    /**
15669 
         * Apply the callback if the given "value" is (or resolves to) truthy.
15670 
         *
15671 
         * @template TWhenParameter
15672 
         * @template TWhenReturnType
15673 
         * @param \Illuminate\Filesystem\(\Closure($this):  TWhenParameter)|TWhenParameter|null  $value
15674 
         * @param \Illuminate\Filesystem\(callable($this,  TWhenParameter): TWhenReturnType)|null  $callback
15675 
         * @param \Illuminate\Filesystem\(callable($this,  TWhenParameter): TWhenReturnType)|null  $default
15676 
         * @return $this|\Illuminate\Filesystem\TWhenReturnType
15677 
         * @static
15678 
         */
15679 
        public static function when($value = null, $callback = null, $default = null)
15680 
        {
15681 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15682 
                        return $instance->when($value, $callback, $default);
15683 
        }
15684 
                    /**
15685 
         * Apply the callback if the given "value" is (or resolves to) falsy.
15686 
         *
15687 
         * @template TUnlessParameter
15688 
         * @template TUnlessReturnType
15689 
         * @param \Illuminate\Filesystem\(\Closure($this):  TUnlessParameter)|TUnlessParameter|null  $value
15690 
         * @param \Illuminate\Filesystem\(callable($this,  TUnlessParameter): TUnlessReturnType)|null  $callback
15691 
         * @param \Illuminate\Filesystem\(callable($this,  TUnlessParameter): TUnlessReturnType)|null  $default
15692 
         * @return $this|\Illuminate\Filesystem\TUnlessReturnType
15693 
         * @static
15694 
         */
15695 
        public static function unless($value = null, $callback = null, $default = null)
15696 
        {
15697 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15698 
                        return $instance->unless($value, $callback, $default);
15699 
        }
15700 
                    /**
15701 
         * Register a custom macro.
15702 
         *
15703 
         * @param string $name
15704 
         * @param object|callable $macro
15705 
         * @return void
15706 
         * @static
15707 
         */
15708 
        public static function macro($name, $macro)
15709 
        {
15710 
                        \Illuminate\Filesystem\FilesystemAdapter::macro($name, $macro);
15711 
        }
15712 
                    /**
15713 
         * Mix another object into the class.
15714 
         *
15715 
         * @param object $mixin
15716 
         * @param bool $replace
15717 
         * @return void
15718 
         * @throws \ReflectionException
15719 
         * @static
15720 
         */
15721 
        public static function mixin($mixin, $replace = true)
15722 
        {
15723 
                        \Illuminate\Filesystem\FilesystemAdapter::mixin($mixin, $replace);
15724 
        }
15725 
                    /**
15726 
         * Checks if macro is registered.
15727 
         *
15728 
         * @param string $name
15729 
         * @return bool
15730 
         * @static
15731 
         */
15732 
        public static function hasMacro($name)
15733 
        {
15734 
                        return \Illuminate\Filesystem\FilesystemAdapter::hasMacro($name);
15735 
        }
15736 
                    /**
15737 
         * Flush the existing macros.
15738 
         *
15739 
         * @return void
15740 
         * @static
15741 
         */
15742 
        public static function flushMacros()
15743 
        {
15744 
                        \Illuminate\Filesystem\FilesystemAdapter::flushMacros();
15745 
        }
15746 
                    /**
15747 
         * Dynamically handle calls to the class.
15748 
         *
15749 
         * @param string $method
15750 
         * @param array $parameters
15751 
         * @return mixed
15752 
         * @throws \BadMethodCallException
15753 
         * @static
15754 
         */
15755 
        public static function macroCall($method, $parameters)
15756 
        {
15757 
                        /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15758 
                        return $instance->macroCall($method, $parameters);
15759 
        }
15760 
 
15761 
    }
15762 
            /**
15763 
     *
15764 
     *
15765 
     * @see \Illuminate\Routing\UrlGenerator
15766 
     */
15767 
        class URL {
15768 
                    /**
15769 
         * Get the full URL for the current request.
15770 
         *
15771 
         * @return string
15772 
         * @static
15773 
         */
15774 
        public static function full()
15775 
        {
15776 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15777 
                        return $instance->full();
15778 
        }
15779 
                    /**
15780 
         * Get the current URL for the request.
15781 
         *
15782 
         * @return string
15783 
         * @static
15784 
         */
15785 
        public static function current()
15786 
        {
15787 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15788 
                        return $instance->current();
15789 
        }
15790 
                    /**
15791 
         * Get the URL for the previous request.
15792 
         *
15793 
         * @param mixed $fallback
15794 
         * @return string
15795 
         * @static
15796 
         */
15797 
        public static function previous($fallback = false)
15798 
        {
15799 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15800 
                        return $instance->previous($fallback);
15801 
        }
15802 
                    /**
15803 
         * Get the previous path info for the request.
15804 
         *
15805 
         * @param mixed $fallback
15806 
         * @return string
15807 
         * @static
15808 
         */
15809 
        public static function previousPath($fallback = false)
15810 
        {
15811 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15812 
                        return $instance->previousPath($fallback);
15813 
        }
15814 
                    /**
15815 
         * Generate an absolute URL to the given path.
15816 
         *
15817 
         * @param string $path
15818 
         * @param mixed $extra
15819 
         * @param bool|null $secure
15820 
         * @return string
15821 
         * @static
15822 
         */
15823 
        public static function to($path, $extra = [], $secure = null)
15824 
        {
15825 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15826 
                        return $instance->to($path, $extra, $secure);
15827 
        }
15828 
                    /**
15829 
         * Generate a secure, absolute URL to the given path.
15830 
         *
15831 
         * @param string $path
15832 
         * @param array $parameters
15833 
         * @return string
15834 
         * @static
15835 
         */
15836 
        public static function secure($path, $parameters = [])
15837 
        {
15838 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15839 
                        return $instance->secure($path, $parameters);
15840 
        }
15841 
                    /**
15842 
         * Generate the URL to an application asset.
15843 
         *
15844 
         * @param string $path
15845 
         * @param bool|null $secure
15846 
         * @return string
15847 
         * @static
15848 
         */
15849 
        public static function asset($path, $secure = null)
15850 
        {
15851 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15852 
                        return $instance->asset($path, $secure);
15853 
        }
15854 
                    /**
15855 
         * Generate the URL to a secure asset.
15856 
         *
15857 
         * @param string $path
15858 
         * @return string
15859 
         * @static
15860 
         */
15861 
        public static function secureAsset($path)
15862 
        {
15863 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15864 
                        return $instance->secureAsset($path);
15865 
        }
15866 
                    /**
15867 
         * Generate the URL to an asset from a custom root domain such as CDN, etc.
15868 
         *
15869 
         * @param string $root
15870 
         * @param string $path
15871 
         * @param bool|null $secure
15872 
         * @return string
15873 
         * @static
15874 
         */
15875 
        public static function assetFrom($root, $path, $secure = null)
15876 
        {
15877 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15878 
                        return $instance->assetFrom($root, $path, $secure);
15879 
        }
15880 
                    /**
15881 
         * Get the default scheme for a raw URL.
15882 
         *
15883 
         * @param bool|null $secure
15884 
         * @return string
15885 
         * @static
15886 
         */
15887 
        public static function formatScheme($secure = null)
15888 
        {
15889 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15890 
                        return $instance->formatScheme($secure);
15891 
        }
15892 
                    /**
15893 
         * Create a signed route URL for a named route.
15894 
         *
15895 
         * @param string $name
15896 
         * @param mixed $parameters
15897 
         * @param \DateTimeInterface|\DateInterval|int|null $expiration
15898 
         * @param bool $absolute
15899 
         * @return string
15900 
         * @throws \InvalidArgumentException
15901 
         * @static
15902 
         */
15903 
        public static function signedRoute($name, $parameters = [], $expiration = null, $absolute = true)
15904 
        {
15905 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15906 
                        return $instance->signedRoute($name, $parameters, $expiration, $absolute);
15907 
        }
15908 
                    /**
15909 
         * Create a temporary signed route URL for a named route.
15910 
         *
15911 
         * @param string $name
15912 
         * @param \DateTimeInterface|\DateInterval|int $expiration
15913 
         * @param array $parameters
15914 
         * @param bool $absolute
15915 
         * @return string
15916 
         * @static
15917 
         */
15918 
        public static function temporarySignedRoute($name, $expiration, $parameters = [], $absolute = true)
15919 
        {
15920 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15921 
                        return $instance->temporarySignedRoute($name, $expiration, $parameters, $absolute);
15922 
        }
15923 
                    /**
15924 
         * Determine if the given request has a valid signature.
15925 
         *
15926 
         * @param \Illuminate\Http\Request $request
15927 
         * @param bool $absolute
15928 
         * @param array $ignoreQuery
15929 
         * @return bool
15930 
         * @static
15931 
         */
15932 
        public static function hasValidSignature($request, $absolute = true, $ignoreQuery = [])
15933 
        {
15934 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15935 
                        return $instance->hasValidSignature($request, $absolute, $ignoreQuery);
15936 
        }
15937 
                    /**
15938 
         * Determine if the given request has a valid signature for a relative URL.
15939 
         *
15940 
         * @param \Illuminate\Http\Request $request
15941 
         * @param array $ignoreQuery
15942 
         * @return bool
15943 
         * @static
15944 
         */
15945 
        public static function hasValidRelativeSignature($request, $ignoreQuery = [])
15946 
        {
15947 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15948 
                        return $instance->hasValidRelativeSignature($request, $ignoreQuery);
15949 
        }
15950 
                    /**
15951 
         * Determine if the signature from the given request matches the URL.
15952 
         *
15953 
         * @param \Illuminate\Http\Request $request
15954 
         * @param bool $absolute
15955 
         * @param array $ignoreQuery
15956 
         * @return bool
15957 
         * @static
15958 
         */
15959 
        public static function hasCorrectSignature($request, $absolute = true, $ignoreQuery = [])
15960 
        {
15961 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15962 
                        return $instance->hasCorrectSignature($request, $absolute, $ignoreQuery);
15963 
        }
15964 
                    /**
15965 
         * Determine if the expires timestamp from the given request is not from the past.
15966 
         *
15967 
         * @param \Illuminate\Http\Request $request
15968 
         * @return bool
15969 
         * @static
15970 
         */
15971 
        public static function signatureHasNotExpired($request)
15972 
        {
15973 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15974 
                        return $instance->signatureHasNotExpired($request);
15975 
        }
15976 
                    /**
15977 
         * Get the URL to a named route.
15978 
         *
15979 
         * @param string $name
15980 
         * @param mixed $parameters
15981 
         * @param bool $absolute
15982 
         * @return string
15983 
         * @throws \Symfony\Component\Routing\Exception\RouteNotFoundException
15984 
         * @static
15985 
         */
15986 
        public static function route($name, $parameters = [], $absolute = true)
15987 
        {
15988 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
15989 
                        return $instance->route($name, $parameters, $absolute);
15990 
        }
15991 
                    /**
15992 
         * Get the URL for a given route instance.
15993 
         *
15994 
         * @param \Illuminate\Routing\Route $route
15995 
         * @param mixed $parameters
15996 
         * @param bool $absolute
15997 
         * @return string
15998 
         * @throws \Illuminate\Routing\Exceptions\UrlGenerationException
15999 
         * @static
16000 
         */
16001 
        public static function toRoute($route, $parameters, $absolute)
16002 
        {
16003 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16004 
                        return $instance->toRoute($route, $parameters, $absolute);
16005 
        }
16006 
                    /**
16007 
         * Get the URL to a controller action.
16008 
         *
16009 
         * @param string|array $action
16010 
         * @param mixed $parameters
16011 
         * @param bool $absolute
16012 
         * @return string
16013 
         * @throws \InvalidArgumentException
16014 
         * @static
16015 
         */
16016 
        public static function action($action, $parameters = [], $absolute = true)
16017 
        {
16018 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16019 
                        return $instance->action($action, $parameters, $absolute);
16020 
        }
16021 
                    /**
16022 
         * Format the array of URL parameters.
16023 
         *
16024 
         * @param mixed|array $parameters
16025 
         * @return array
16026 
         * @static
16027 
         */
16028 
        public static function formatParameters($parameters)
16029 
        {
16030 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16031 
                        return $instance->formatParameters($parameters);
16032 
        }
16033 
                    /**
16034 
         * Get the base URL for the request.
16035 
         *
16036 
         * @param string $scheme
16037 
         * @param string|null $root
16038 
         * @return string
16039 
         * @static
16040 
         */
16041 
        public static function formatRoot($scheme, $root = null)
16042 
        {
16043 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16044 
                        return $instance->formatRoot($scheme, $root);
16045 
        }
16046 
                    /**
16047 
         * Format the given URL segments into a single URL.
16048 
         *
16049 
         * @param string $root
16050 
         * @param string $path
16051 
         * @param \Illuminate\Routing\Route|null $route
16052 
         * @return string
16053 
         * @static
16054 
         */
16055 
        public static function format($root, $path, $route = null)
16056 
        {
16057 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16058 
                        return $instance->format($root, $path, $route);
16059 
        }
16060 
                    /**
16061 
         * Determine if the given path is a valid URL.
16062 
         *
16063 
         * @param string $path
16064 
         * @return bool
16065 
         * @static
16066 
         */
16067 
        public static function isValidUrl($path)
16068 
        {
16069 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16070 
                        return $instance->isValidUrl($path);
16071 
        }
16072 
                    /**
16073 
         * Set the default named parameters used by the URL generator.
16074 
         *
16075 
         * @param array $defaults
16076 
         * @return void
16077 
         * @static
16078 
         */
16079 
        public static function defaults($defaults)
16080 
        {
16081 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16082 
                        $instance->defaults($defaults);
16083 
        }
16084 
                    /**
16085 
         * Get the default named parameters used by the URL generator.
16086 
         *
16087 
         * @return array
16088 
         * @static
16089 
         */
16090 
        public static function getDefaultParameters()
16091 
        {
16092 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16093 
                        return $instance->getDefaultParameters();
16094 
        }
16095 
                    /**
16096 
         * Force the scheme for URLs.
16097 
         *
16098 
         * @param string|null $scheme
16099 
         * @return void
16100 
         * @static
16101 
         */
16102 
        public static function forceScheme($scheme)
16103 
        {
16104 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16105 
                        $instance->forceScheme($scheme);
16106 
        }
16107 
                    /**
16108 
         * Set the forced root URL.
16109 
         *
16110 
         * @param string|null $root
16111 
         * @return void
16112 
         * @static
16113 
         */
16114 
        public static function forceRootUrl($root)
16115 
        {
16116 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16117 
                        $instance->forceRootUrl($root);
16118 
        }
16119 
                    /**
16120 
         * Set a callback to be used to format the host of generated URLs.
16121 
         *
16122 
         * @param \Closure $callback
16123 
         * @return \Illuminate\Routing\UrlGenerator
16124 
         * @static
16125 
         */
16126 
        public static function formatHostUsing($callback)
16127 
        {
16128 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16129 
                        return $instance->formatHostUsing($callback);
16130 
        }
16131 
                    /**
16132 
         * Set a callback to be used to format the path of generated URLs.
16133 
         *
16134 
         * @param \Closure $callback
16135 
         * @return \Illuminate\Routing\UrlGenerator
16136 
         * @static
16137 
         */
16138 
        public static function formatPathUsing($callback)
16139 
        {
16140 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16141 
                        return $instance->formatPathUsing($callback);
16142 
        }
16143 
                    /**
16144 
         * Get the path formatter being used by the URL generator.
16145 
         *
16146 
         * @return \Closure
16147 
         * @static
16148 
         */
16149 
        public static function pathFormatter()
16150 
        {
16151 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16152 
                        return $instance->pathFormatter();
16153 
        }
16154 
                    /**
16155 
         * Get the request instance.
16156 
         *
16157 
         * @return \Illuminate\Http\Request
16158 
         * @static
16159 
         */
16160 
        public static function getRequest()
16161 
        {
16162 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16163 
                        return $instance->getRequest();
16164 
        }
16165 
                    /**
16166 
         * Set the current request instance.
16167 
         *
16168 
         * @param \Illuminate\Http\Request $request
16169 
         * @return void
16170 
         * @static
16171 
         */
16172 
        public static function setRequest($request)
16173 
        {
16174 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16175 
                        $instance->setRequest($request);
16176 
        }
16177 
                    /**
16178 
         * Set the route collection.
16179 
         *
16180 
         * @param \Illuminate\Routing\RouteCollectionInterface $routes
16181 
         * @return \Illuminate\Routing\UrlGenerator
16182 
         * @static
16183 
         */
16184 
        public static function setRoutes($routes)
16185 
        {
16186 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16187 
                        return $instance->setRoutes($routes);
16188 
        }
16189 
                    /**
16190 
         * Set the session resolver for the generator.
16191 
         *
16192 
         * @param callable $sessionResolver
16193 
         * @return \Illuminate\Routing\UrlGenerator
16194 
         * @static
16195 
         */
16196 
        public static function setSessionResolver($sessionResolver)
16197 
        {
16198 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16199 
                        return $instance->setSessionResolver($sessionResolver);
16200 
        }
16201 
                    /**
16202 
         * Set the encryption key resolver.
16203 
         *
16204 
         * @param callable $keyResolver
16205 
         * @return \Illuminate\Routing\UrlGenerator
16206 
         * @static
16207 
         */
16208 
        public static function setKeyResolver($keyResolver)
16209 
        {
16210 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16211 
                        return $instance->setKeyResolver($keyResolver);
16212 
        }
16213 
                    /**
16214 
         * Clone a new instance of the URL generator with a different encryption key resolver.
16215 
         *
16216 
         * @param callable $keyResolver
16217 
         * @return \Illuminate\Routing\UrlGenerator
16218 
         * @static
16219 
         */
16220 
        public static function withKeyResolver($keyResolver)
16221 
        {
16222 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16223 
                        return $instance->withKeyResolver($keyResolver);
16224 
        }
16225 
                    /**
16226 
         * Get the root controller namespace.
16227 
         *
16228 
         * @return string
16229 
         * @static
16230 
         */
16231 
        public static function getRootControllerNamespace()
16232 
        {
16233 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16234 
                        return $instance->getRootControllerNamespace();
16235 
        }
16236 
                    /**
16237 
         * Set the root controller namespace.
16238 
         *
16239 
         * @param string $rootNamespace
16240 
         * @return \Illuminate\Routing\UrlGenerator
16241 
         * @static
16242 
         */
16243 
        public static function setRootControllerNamespace($rootNamespace)
16244 
        {
16245 
                        /** @var \Illuminate\Routing\UrlGenerator $instance */
16246 
                        return $instance->setRootControllerNamespace($rootNamespace);
16247 
        }
16248 
                    /**
16249 
         * Register a custom macro.
16250 
         *
16251 
         * @param string $name
16252 
         * @param object|callable $macro
16253 
         * @return void
16254 
         * @static
16255 
         */
16256 
        public static function macro($name, $macro)
16257 
        {
16258 
                        \Illuminate\Routing\UrlGenerator::macro($name, $macro);
16259 
        }
16260 
                    /**
16261 
         * Mix another object into the class.
16262 
         *
16263 
         * @param object $mixin
16264 
         * @param bool $replace
16265 
         * @return void
16266 
         * @throws \ReflectionException
16267 
         * @static
16268 
         */
16269 
        public static function mixin($mixin, $replace = true)
16270 
        {
16271 
                        \Illuminate\Routing\UrlGenerator::mixin($mixin, $replace);
16272 
        }
16273 
                    /**
16274 
         * Checks if macro is registered.
16275 
         *
16276 
         * @param string $name
16277 
         * @return bool
16278 
         * @static
16279 
         */
16280 
        public static function hasMacro($name)
16281 
        {
16282 
                        return \Illuminate\Routing\UrlGenerator::hasMacro($name);
16283 
        }
16284 
                    /**
16285 
         * Flush the existing macros.
16286 
         *
16287 
         * @return void
16288 
         * @static
16289 
         */
16290 
        public static function flushMacros()
16291 
        {
16292 
                        \Illuminate\Routing\UrlGenerator::flushMacros();
16293 
        }
16294 
 
16295 
    }
16296 
            /**
16297 
     *
16298 
     *
16299 
     * @see \Illuminate\Validation\Factory
16300 
     */
16301 
        class Validator {
16302 
                    /**
16303 
         * Create a new Validator instance.
16304 
         *
16305 
         * @param array $data
16306 
         * @param array $rules
16307 
         * @param array $messages
16308 
         * @param array $customAttributes
16309 
         * @return \Illuminate\Validation\Validator
16310 
         * @static
16311 
         */
16312 
        public static function make($data, $rules, $messages = [], $customAttributes = [])
16313 
        {
16314 
                        /** @var \Illuminate\Validation\Factory $instance */
16315 
                        return $instance->make($data, $rules, $messages, $customAttributes);
16316 
        }
16317 
                    /**
16318 
         * Validate the given data against the provided rules.
16319 
         *
16320 
         * @param array $data
16321 
         * @param array $rules
16322 
         * @param array $messages
16323 
         * @param array $customAttributes
16324 
         * @return array
16325 
         * @throws \Illuminate\Validation\ValidationException
16326 
         * @static
16327 
         */
16328 
        public static function validate($data, $rules, $messages = [], $customAttributes = [])
16329 
        {
16330 
                        /** @var \Illuminate\Validation\Factory $instance */
16331 
                        return $instance->validate($data, $rules, $messages, $customAttributes);
16332 
        }
16333 
                    /**
16334 
         * Register a custom validator extension.
16335 
         *
16336 
         * @param string $rule
16337 
         * @param \Closure|string $extension
16338 
         * @param string|null $message
16339 
         * @return void
16340 
         * @static
16341 
         */
16342 
        public static function extend($rule, $extension, $message = null)
16343 
        {
16344 
                        /** @var \Illuminate\Validation\Factory $instance */
16345 
                        $instance->extend($rule, $extension, $message);
16346 
        }
16347 
                    /**
16348 
         * Register a custom implicit validator extension.
16349 
         *
16350 
         * @param string $rule
16351 
         * @param \Closure|string $extension
16352 
         * @param string|null $message
16353 
         * @return void
16354 
         * @static
16355 
         */
16356 
        public static function extendImplicit($rule, $extension, $message = null)
16357 
        {
16358 
                        /** @var \Illuminate\Validation\Factory $instance */
16359 
                        $instance->extendImplicit($rule, $extension, $message);
16360 
        }
16361 
                    /**
16362 
         * Register a custom dependent validator extension.
16363 
         *
16364 
         * @param string $rule
16365 
         * @param \Closure|string $extension
16366 
         * @param string|null $message
16367 
         * @return void
16368 
         * @static
16369 
         */
16370 
        public static function extendDependent($rule, $extension, $message = null)
16371 
        {
16372 
                        /** @var \Illuminate\Validation\Factory $instance */
16373 
                        $instance->extendDependent($rule, $extension, $message);
16374 
        }
16375 
                    /**
16376 
         * Register a custom validator message replacer.
16377 
         *
16378 
         * @param string $rule
16379 
         * @param \Closure|string $replacer
16380 
         * @return void
16381 
         * @static
16382 
         */
16383 
        public static function replacer($rule, $replacer)
16384 
        {
16385 
                        /** @var \Illuminate\Validation\Factory $instance */
16386 
                        $instance->replacer($rule, $replacer);
16387 
        }
16388 
                    /**
16389 
         * Indicate that unvalidated array keys should be included in validated data when the parent array is validated.
16390 
         *
16391 
         * @return void
16392 
         * @static
16393 
         */
16394 
        public static function includeUnvalidatedArrayKeys()
16395 
        {
16396 
                        /** @var \Illuminate\Validation\Factory $instance */
16397 
                        $instance->includeUnvalidatedArrayKeys();
16398 
        }
16399 
                    /**
16400 
         * Indicate that unvalidated array keys should be excluded from the validated data, even if the parent array was validated.
16401 
         *
16402 
         * @return void
16403 
         * @static
16404 
         */
16405 
        public static function excludeUnvalidatedArrayKeys()
16406 
        {
16407 
                        /** @var \Illuminate\Validation\Factory $instance */
16408 
                        $instance->excludeUnvalidatedArrayKeys();
16409 
        }
16410 
                    /**
16411 
         * Set the Validator instance resolver.
16412 
         *
16413 
         * @param \Closure $resolver
16414 
         * @return void
16415 
         * @static
16416 
         */
16417 
        public static function resolver($resolver)
16418 
        {
16419 
                        /** @var \Illuminate\Validation\Factory $instance */
16420 
                        $instance->resolver($resolver);
16421 
        }
16422 
                    /**
16423 
         * Get the Translator implementation.
16424 
         *
16425 
         * @return \Illuminate\Contracts\Translation\Translator
16426 
         * @static
16427 
         */
16428 
        public static function getTranslator()
16429 
        {
16430 
                        /** @var \Illuminate\Validation\Factory $instance */
16431 
                        return $instance->getTranslator();
16432 
        }
16433 
                    /**
16434 
         * Get the Presence Verifier implementation.
16435 
         *
16436 
         * @return \Illuminate\Validation\PresenceVerifierInterface
16437 
         * @static
16438 
         */
16439 
        public static function getPresenceVerifier()
16440 
        {
16441 
                        /** @var \Illuminate\Validation\Factory $instance */
16442 
                        return $instance->getPresenceVerifier();
16443 
        }
16444 
                    /**
16445 
         * Set the Presence Verifier implementation.
16446 
         *
16447 
         * @param \Illuminate\Validation\PresenceVerifierInterface $presenceVerifier
16448 
         * @return void
16449 
         * @static
16450 
         */
16451 
        public static function setPresenceVerifier($presenceVerifier)
16452 
        {
16453 
                        /** @var \Illuminate\Validation\Factory $instance */
16454 
                        $instance->setPresenceVerifier($presenceVerifier);
16455 
        }
16456 
                    /**
16457 
         * Get the container instance used by the validation factory.
16458 
         *
16459 
         * @return \Illuminate\Contracts\Container\Container|null
16460 
         * @static
16461 
         */
16462 
        public static function getContainer()
16463 
        {
16464 
                        /** @var \Illuminate\Validation\Factory $instance */
16465 
                        return $instance->getContainer();
16466 
        }
16467 
                    /**
16468 
         * Set the container instance used by the validation factory.
16469 
         *
16470 
         * @param \Illuminate\Contracts\Container\Container $container
16471 
         * @return \Illuminate\Validation\Factory
16472 
         * @static
16473 
         */
16474 
        public static function setContainer($container)
16475 
        {
16476 
                        /** @var \Illuminate\Validation\Factory $instance */
16477 
                        return $instance->setContainer($container);
16478 
        }
16479 
 
16480 
    }
16481 
            /**
16482 
     *
16483 
     *
16484 
     * @see \Illuminate\View\Factory
16485 
     */
16486 
        class View {
16487 
                    /**
16488 
         * Get the evaluated view contents for the given view.
16489 
         *
16490 
         * @param string $path
16491 
         * @param \Illuminate\Contracts\Support\Arrayable|array $data
16492 
         * @param array $mergeData
16493 
         * @return \Illuminate\Contracts\View\View
16494 
         * @static
16495 
         */
16496 
        public static function file($path, $data = [], $mergeData = [])
16497 
        {
16498 
                        /** @var \Illuminate\View\Factory $instance */
16499 
                        return $instance->file($path, $data, $mergeData);
16500 
        }
16501 
                    /**
16502 
         * Get the evaluated view contents for the given view.
16503 
         *
16504 
         * @param string $view
16505 
         * @param \Illuminate\Contracts\Support\Arrayable|array $data
16506 
         * @param array $mergeData
16507 
         * @return \Illuminate\Contracts\View\View
16508 
         * @static
16509 
         */
16510 
        public static function make($view, $data = [], $mergeData = [])
16511 
        {
16512 
                        /** @var \Illuminate\View\Factory $instance */
16513 
                        return $instance->make($view, $data, $mergeData);
16514 
        }
16515 
                    /**
16516 
         * Get the first view that actually exists from the given list.
16517 
         *
16518 
         * @param array $views
16519 
         * @param \Illuminate\Contracts\Support\Arrayable|array $data
16520 
         * @param array $mergeData
16521 
         * @return \Illuminate\Contracts\View\View
16522 
         * @throws \InvalidArgumentException
16523 
         * @static
16524 
         */
16525 
        public static function first($views, $data = [], $mergeData = [])
16526 
        {
16527 
                        /** @var \Illuminate\View\Factory $instance */
16528 
                        return $instance->first($views, $data, $mergeData);
16529 
        }
16530 
                    /**
16531 
         * Get the rendered content of the view based on a given condition.
16532 
         *
16533 
         * @param bool $condition
16534 
         * @param string $view
16535 
         * @param \Illuminate\Contracts\Support\Arrayable|array $data
16536 
         * @param array $mergeData
16537 
         * @return string
16538 
         * @static
16539 
         */
16540 
        public static function renderWhen($condition, $view, $data = [], $mergeData = [])
16541 
        {
16542 
                        /** @var \Illuminate\View\Factory $instance */
16543 
                        return $instance->renderWhen($condition, $view, $data, $mergeData);
16544 
        }
16545 
                    /**
16546 
         * Get the rendered content of the view based on the negation of a given condition.
16547 
         *
16548 
         * @param bool $condition
16549 
         * @param string $view
16550 
         * @param \Illuminate\Contracts\Support\Arrayable|array $data
16551 
         * @param array $mergeData
16552 
         * @return string
16553 
         * @static
16554 
         */
16555 
        public static function renderUnless($condition, $view, $data = [], $mergeData = [])
16556 
        {
16557 
                        /** @var \Illuminate\View\Factory $instance */
16558 
                        return $instance->renderUnless($condition, $view, $data, $mergeData);
16559 
        }
16560 
                    /**
16561 
         * Get the rendered contents of a partial from a loop.
16562 
         *
16563 
         * @param string $view
16564 
         * @param array $data
16565 
         * @param string $iterator
16566 
         * @param string $empty
16567 
         * @return string
16568 
         * @static
16569 
         */
16570 
        public static function renderEach($view, $data, $iterator, $empty = 'raw|')
16571 
        {
16572 
                        /** @var \Illuminate\View\Factory $instance */
16573 
                        return $instance->renderEach($view, $data, $iterator, $empty);
16574 
        }
16575 
                    /**
16576 
         * Determine if a given view exists.
16577 
         *
16578 
         * @param string $view
16579 
         * @return bool
16580 
         * @static
16581 
         */
16582 
        public static function exists($view)
16583 
        {
16584 
                        /** @var \Illuminate\View\Factory $instance */
16585 
                        return $instance->exists($view);
16586 
        }
16587 
                    /**
16588 
         * Get the appropriate view engine for the given path.
16589 
         *
16590 
         * @param string $path
16591 
         * @return \Illuminate\Contracts\View\Engine
16592 
         * @throws \InvalidArgumentException
16593 
         * @static
16594 
         */
16595 
        public static function getEngineFromPath($path)
16596 
        {
16597 
                        /** @var \Illuminate\View\Factory $instance */
16598 
                        return $instance->getEngineFromPath($path);
16599 
        }
16600 
                    /**
16601 
         * Add a piece of shared data to the environment.
16602 
         *
16603 
         * @param array|string $key
16604 
         * @param mixed|null $value
16605 
         * @return mixed
16606 
         * @static
16607 
         */
16608 
        public static function share($key, $value = null)
16609 
        {
16610 
                        /** @var \Illuminate\View\Factory $instance */
16611 
                        return $instance->share($key, $value);
16612 
        }
16613 
                    /**
16614 
         * Increment the rendering counter.
16615 
         *
16616 
         * @return void
16617 
         * @static
16618 
         */
16619 
        public static function incrementRender()
16620 
        {
16621 
                        /** @var \Illuminate\View\Factory $instance */
16622 
                        $instance->incrementRender();
16623 
        }
16624 
                    /**
16625 
         * Decrement the rendering counter.
16626 
         *
16627 
         * @return void
16628 
         * @static
16629 
         */
16630 
        public static function decrementRender()
16631 
        {
16632 
                        /** @var \Illuminate\View\Factory $instance */
16633 
                        $instance->decrementRender();
16634 
        }
16635 
                    /**
16636 
         * Check if there are no active render operations.
16637 
         *
16638 
         * @return bool
16639 
         * @static
16640 
         */
16641 
        public static function doneRendering()
16642 
        {
16643 
                        /** @var \Illuminate\View\Factory $instance */
16644 
                        return $instance->doneRendering();
16645 
        }
16646 
                    /**
16647 
         * Determine if the given once token has been rendered.
16648 
         *
16649 
         * @param string $id
16650 
         * @return bool
16651 
         * @static
16652 
         */
16653 
        public static function hasRenderedOnce($id)
16654 
        {
16655 
                        /** @var \Illuminate\View\Factory $instance */
16656 
                        return $instance->hasRenderedOnce($id);
16657 
        }
16658 
                    /**
16659 
         * Mark the given once token as having been rendered.
16660 
         *
16661 
         * @param string $id
16662 
         * @return void
16663 
         * @static
16664 
         */
16665 
        public static function markAsRenderedOnce($id)
16666 
        {
16667 
                        /** @var \Illuminate\View\Factory $instance */
16668 
                        $instance->markAsRenderedOnce($id);
16669 
        }
16670 
                    /**
16671 
         * Add a location to the array of view locations.
16672 
         *
16673 
         * @param string $location
16674 
         * @return void
16675 
         * @static
16676 
         */
16677 
        public static function addLocation($location)
16678 
        {
16679 
                        /** @var \Illuminate\View\Factory $instance */
16680 
                        $instance->addLocation($location);
16681 
        }
16682 
                    /**
16683 
         * Add a new namespace to the loader.
16684 
         *
16685 
         * @param string $namespace
16686 
         * @param string|array $hints
16687 
         * @return \Illuminate\View\Factory
16688 
         * @static
16689 
         */
16690 
        public static function addNamespace($namespace, $hints)
16691 
        {
16692 
                        /** @var \Illuminate\View\Factory $instance */
16693 
                        return $instance->addNamespace($namespace, $hints);
16694 
        }
16695 
                    /**
16696 
         * Prepend a new namespace to the loader.
16697 
         *
16698 
         * @param string $namespace
16699 
         * @param string|array $hints
16700 
         * @return \Illuminate\View\Factory
16701 
         * @static
16702 
         */
16703 
        public static function prependNamespace($namespace, $hints)
16704 
        {
16705 
                        /** @var \Illuminate\View\Factory $instance */
16706 
                        return $instance->prependNamespace($namespace, $hints);
16707 
        }
16708 
                    /**
16709 
         * Replace the namespace hints for the given namespace.
16710 
         *
16711 
         * @param string $namespace
16712 
         * @param string|array $hints
16713 
         * @return \Illuminate\View\Factory
16714 
         * @static
16715 
         */
16716 
        public static function replaceNamespace($namespace, $hints)
16717 
        {
16718 
                        /** @var \Illuminate\View\Factory $instance */
16719 
                        return $instance->replaceNamespace($namespace, $hints);
16720 
        }
16721 
                    /**
16722 
         * Register a valid view extension and its engine.
16723 
         *
16724 
         * @param string $extension
16725 
         * @param string $engine
16726 
         * @param \Closure|null $resolver
16727 
         * @return void
16728 
         * @static
16729 
         */
16730 
        public static function addExtension($extension, $engine, $resolver = null)
16731 
        {
16732 
                        /** @var \Illuminate\View\Factory $instance */
16733 
                        $instance->addExtension($extension, $engine, $resolver);
16734 
        }
16735 
                    /**
16736 
         * Flush all of the factory state like sections and stacks.
16737 
         *
16738 
         * @return void
16739 
         * @static
16740 
         */
16741 
        public static function flushState()
16742 
        {
16743 
                        /** @var \Illuminate\View\Factory $instance */
16744 
                        $instance->flushState();
16745 
        }
16746 
                    /**
16747 
         * Flush all of the section contents if done rendering.
16748 
         *
16749 
         * @return void
16750 
         * @static
16751 
         */
16752 
        public static function flushStateIfDoneRendering()
16753 
        {
16754 
                        /** @var \Illuminate\View\Factory $instance */
16755 
                        $instance->flushStateIfDoneRendering();
16756 
        }
16757 
                    /**
16758 
         * Get the extension to engine bindings.
16759 
         *
16760 
         * @return array
16761 
         * @static
16762 
         */
16763 
        public static function getExtensions()
16764 
        {
16765 
                        /** @var \Illuminate\View\Factory $instance */
16766 
                        return $instance->getExtensions();
16767 
        }
16768 
                    /**
16769 
         * Get the engine resolver instance.
16770 
         *
16771 
         * @return \Illuminate\View\Engines\EngineResolver
16772 
         * @static
16773 
         */
16774 
        public static function getEngineResolver()
16775 
        {
16776 
                        /** @var \Illuminate\View\Factory $instance */
16777 
                        return $instance->getEngineResolver();
16778 
        }
16779 
                    /**
16780 
         * Get the view finder instance.
16781 
         *
16782 
         * @return \Illuminate\View\ViewFinderInterface
16783 
         * @static
16784 
         */
16785 
        public static function getFinder()
16786 
        {
16787 
                        /** @var \Illuminate\View\Factory $instance */
16788 
                        return $instance->getFinder();
16789 
        }
16790 
                    /**
16791 
         * Set the view finder instance.
16792 
         *
16793 
         * @param \Illuminate\View\ViewFinderInterface $finder
16794 
         * @return void
16795 
         * @static
16796 
         */
16797 
        public static function setFinder($finder)
16798 
        {
16799 
                        /** @var \Illuminate\View\Factory $instance */
16800 
                        $instance->setFinder($finder);
16801 
        }
16802 
                    /**
16803 
         * Flush the cache of views located by the finder.
16804 
         *
16805 
         * @return void
16806 
         * @static
16807 
         */
16808 
        public static function flushFinderCache()
16809 
        {
16810 
                        /** @var \Illuminate\View\Factory $instance */
16811 
                        $instance->flushFinderCache();
16812 
        }
16813 
                    /**
16814 
         * Get the event dispatcher instance.
16815 
         *
16816 
         * @return \Illuminate\Contracts\Events\Dispatcher
16817 
         * @static
16818 
         */
16819 
        public static function getDispatcher()
16820 
        {
16821 
                        /** @var \Illuminate\View\Factory $instance */
16822 
                        return $instance->getDispatcher();
16823 
        }
16824 
                    /**
16825 
         * Set the event dispatcher instance.
16826 
         *
16827 
         * @param \Illuminate\Contracts\Events\Dispatcher $events
16828 
         * @return void
16829 
         * @static
16830 
         */
16831 
        public static function setDispatcher($events)
16832 
        {
16833 
                        /** @var \Illuminate\View\Factory $instance */
16834 
                        $instance->setDispatcher($events);
16835 
        }
16836 
                    /**
16837 
         * Get the IoC container instance.
16838 
         *
16839 
         * @return \Illuminate\Contracts\Container\Container
16840 
         * @static
16841 
         */
16842 
        public static function getContainer()
16843 
        {
16844 
                        /** @var \Illuminate\View\Factory $instance */
16845 
                        return $instance->getContainer();
16846 
        }
16847 
                    /**
16848 
         * Set the IoC container instance.
16849 
         *
16850 
         * @param \Illuminate\Contracts\Container\Container $container
16851 
         * @return void
16852 
         * @static
16853 
         */
16854 
        public static function setContainer($container)
16855 
        {
16856 
                        /** @var \Illuminate\View\Factory $instance */
16857 
                        $instance->setContainer($container);
16858 
        }
16859 
                    /**
16860 
         * Get an item from the shared data.
16861 
         *
16862 
         * @param string $key
16863 
         * @param mixed $default
16864 
         * @return mixed
16865 
         * @static
16866 
         */
16867 
        public static function shared($key, $default = null)
16868 
        {
16869 
                        /** @var \Illuminate\View\Factory $instance */
16870 
                        return $instance->shared($key, $default);
16871 
        }
16872 
                    /**
16873 
         * Get all of the shared data for the environment.
16874 
         *
16875 
         * @return array
16876 
         * @static
16877 
         */
16878 
        public static function getShared()
16879 
        {
16880 
                        /** @var \Illuminate\View\Factory $instance */
16881 
                        return $instance->getShared();
16882 
        }
16883 
                    /**
16884 
         * Register a custom macro.
16885 
         *
16886 
         * @param string $name
16887 
         * @param object|callable $macro
16888 
         * @return void
16889 
         * @static
16890 
         */
16891 
        public static function macro($name, $macro)
16892 
        {
16893 
                        \Illuminate\View\Factory::macro($name, $macro);
16894 
        }
16895 
                    /**
16896 
         * Mix another object into the class.
16897 
         *
16898 
         * @param object $mixin
16899 
         * @param bool $replace
16900 
         * @return void
16901 
         * @throws \ReflectionException
16902 
         * @static
16903 
         */
16904 
        public static function mixin($mixin, $replace = true)
16905 
        {
16906 
                        \Illuminate\View\Factory::mixin($mixin, $replace);
16907 
        }
16908 
                    /**
16909 
         * Checks if macro is registered.
16910 
         *
16911 
         * @param string $name
16912 
         * @return bool
16913 
         * @static
16914 
         */
16915 
        public static function hasMacro($name)
16916 
        {
16917 
                        return \Illuminate\View\Factory::hasMacro($name);
16918 
        }
16919 
                    /**
16920 
         * Flush the existing macros.
16921 
         *
16922 
         * @return void
16923 
         * @static
16924 
         */
16925 
        public static function flushMacros()
16926 
        {
16927 
                        \Illuminate\View\Factory::flushMacros();
16928 
        }
16929 
                    /**
16930 
         * Start a component rendering process.
16931 
         *
16932 
         * @param \Illuminate\Contracts\View\View|\Illuminate\Contracts\Support\Htmlable|\Closure|string $view
16933 
         * @param array $data
16934 
         * @return void
16935 
         * @static
16936 
         */
16937 
        public static function startComponent($view, $data = [])
16938 
        {
16939 
                        /** @var \Illuminate\View\Factory $instance */
16940 
                        $instance->startComponent($view, $data);
16941 
        }
16942 
                    /**
16943 
         * Get the first view that actually exists from the given list, and start a component.
16944 
         *
16945 
         * @param array $names
16946 
         * @param array $data
16947 
         * @return void
16948 
         * @static
16949 
         */
16950 
        public static function startComponentFirst($names, $data = [])
16951 
        {
16952 
                        /** @var \Illuminate\View\Factory $instance */
16953 
                        $instance->startComponentFirst($names, $data);
16954 
        }
16955 
                    /**
16956 
         * Render the current component.
16957 
         *
16958 
         * @return string
16959 
         * @static
16960 
         */
16961 
        public static function renderComponent()
16962 
        {
16963 
                        /** @var \Illuminate\View\Factory $instance */
16964 
                        return $instance->renderComponent();
16965 
        }
16966 
                    /**
16967 
         * Get an item from the component data that exists above the current component.
16968 
         *
16969 
         * @param string $key
16970 
         * @param mixed $default
16971 
         * @return mixed|null
16972 
         * @static
16973 
         */
16974 
        public static function getConsumableComponentData($key, $default = null)
16975 
        {
16976 
                        /** @var \Illuminate\View\Factory $instance */
16977 
                        return $instance->getConsumableComponentData($key, $default);
16978 
        }
16979 
                    /**
16980 
         * Start the slot rendering process.
16981 
         *
16982 
         * @param string $name
16983 
         * @param string|null $content
16984 
         * @param array $attributes
16985 
         * @return void
16986 
         * @static
16987 
         */
16988 
        public static function slot($name, $content = null, $attributes = [])
16989 
        {
16990 
                        /** @var \Illuminate\View\Factory $instance */
16991 
                        $instance->slot($name, $content, $attributes);
16992 
        }
16993 
                    /**
16994 
         * Save the slot content for rendering.
16995 
         *
16996 
         * @return void
16997 
         * @static
16998 
         */
16999 
        public static function endSlot()
17000 
        {
17001 
                        /** @var \Illuminate\View\Factory $instance */
17002 
                        $instance->endSlot();
17003 
        }
17004 
                    /**
17005 
         * Register a view creator event.
17006 
         *
17007 
         * @param array|string $views
17008 
         * @param \Closure|string $callback
17009 
         * @return array
17010 
         * @static
17011 
         */
17012 
        public static function creator($views, $callback)
17013 
        {
17014 
                        /** @var \Illuminate\View\Factory $instance */
17015 
                        return $instance->creator($views, $callback);
17016 
        }
17017 
                    /**
17018 
         * Register multiple view composers via an array.
17019 
         *
17020 
         * @param array $composers
17021 
         * @return array
17022 
         * @static
17023 
         */
17024 
        public static function composers($composers)
17025 
        {
17026 
                        /** @var \Illuminate\View\Factory $instance */
17027 
                        return $instance->composers($composers);
17028 
        }
17029 
                    /**
17030 
         * Register a view composer event.
17031 
         *
17032 
         * @param array|string $views
17033 
         * @param \Closure|string $callback
17034 
         * @return array
17035 
         * @static
17036 
         */
17037 
        public static function composer($views, $callback)
17038 
        {
17039 
                        /** @var \Illuminate\View\Factory $instance */
17040 
                        return $instance->composer($views, $callback);
17041 
        }
17042 
                    /**
17043 
         * Call the composer for a given view.
17044 
         *
17045 
         * @param \Illuminate\Contracts\View\View $view
17046 
         * @return void
17047 
         * @static
17048 
         */
17049 
        public static function callComposer($view)
17050 
        {
17051 
                        /** @var \Illuminate\View\Factory $instance */
17052 
                        $instance->callComposer($view);
17053 
        }
17054 
                    /**
17055 
         * Call the creator for a given view.
17056 
         *
17057 
         * @param \Illuminate\Contracts\View\View $view
17058 
         * @return void
17059 
         * @static
17060 
         */
17061 
        public static function callCreator($view)
17062 
        {
17063 
                        /** @var \Illuminate\View\Factory $instance */
17064 
                        $instance->callCreator($view);
17065 
        }
17066 
                    /**
17067 
         * Start injecting content into a fragment.
17068 
         *
17069 
         * @param string $fragment
17070 
         * @return void
17071 
         * @static
17072 
         */
17073 
        public static function startFragment($fragment)
17074 
        {
17075 
                        /** @var \Illuminate\View\Factory $instance */
17076 
                        $instance->startFragment($fragment);
17077 
        }
17078 
                    /**
17079 
         * Stop injecting content into a fragment.
17080 
         *
17081 
         * @return string
17082 
         * @throws \InvalidArgumentException
17083 
         * @static
17084 
         */
17085 
        public static function stopFragment()
17086 
        {
17087 
                        /** @var \Illuminate\View\Factory $instance */
17088 
                        return $instance->stopFragment();
17089 
        }
17090 
                    /**
17091 
         * Get the contents of a fragment.
17092 
         *
17093 
         * @param string $name
17094 
         * @param string|null $default
17095 
         * @return mixed
17096 
         * @static
17097 
         */
17098 
        public static function getFragment($name, $default = null)
17099 
        {
17100 
                        /** @var \Illuminate\View\Factory $instance */
17101 
                        return $instance->getFragment($name, $default);
17102 
        }
17103 
                    /**
17104 
         * Get the entire array of rendered fragments.
17105 
         *
17106 
         * @return array
17107 
         * @static
17108 
         */
17109 
        public static function getFragments()
17110 
        {
17111 
                        /** @var \Illuminate\View\Factory $instance */
17112 
                        return $instance->getFragments();
17113 
        }
17114 
                    /**
17115 
         * Flush all of the fragments.
17116 
         *
17117 
         * @return void
17118 
         * @static
17119 
         */
17120 
        public static function flushFragments()
17121 
        {
17122 
                        /** @var \Illuminate\View\Factory $instance */
17123 
                        $instance->flushFragments();
17124 
        }
17125 
                    /**
17126 
         * Start injecting content into a section.
17127 
         *
17128 
         * @param string $section
17129 
         * @param string|null $content
17130 
         * @return void
17131 
         * @static
17132 
         */
17133 
        public static function startSection($section, $content = null)
17134 
        {
17135 
                        /** @var \Illuminate\View\Factory $instance */
17136 
                        $instance->startSection($section, $content);
17137 
        }
17138 
                    /**
17139 
         * Inject inline content into a section.
17140 
         *
17141 
         * @param string $section
17142 
         * @param string $content
17143 
         * @return void
17144 
         * @static
17145 
         */
17146 
        public static function inject($section, $content)
17147 
        {
17148 
                        /** @var \Illuminate\View\Factory $instance */
17149 
                        $instance->inject($section, $content);
17150 
        }
17151 
                    /**
17152 
         * Stop injecting content into a section and return its contents.
17153 
         *
17154 
         * @return string
17155 
         * @static
17156 
         */
17157 
        public static function yieldSection()
17158 
        {
17159 
                        /** @var \Illuminate\View\Factory $instance */
17160 
                        return $instance->yieldSection();
17161 
        }
17162 
                    /**
17163 
         * Stop injecting content into a section.
17164 
         *
17165 
         * @param bool $overwrite
17166 
         * @return string
17167 
         * @throws \InvalidArgumentException
17168 
         * @static
17169 
         */
17170 
        public static function stopSection($overwrite = false)
17171 
        {
17172 
                        /** @var \Illuminate\View\Factory $instance */
17173 
                        return $instance->stopSection($overwrite);
17174 
        }
17175 
                    /**
17176 
         * Stop injecting content into a section and append it.
17177 
         *
17178 
         * @return string
17179 
         * @throws \InvalidArgumentException
17180 
         * @static
17181 
         */
17182 
        public static function appendSection()
17183 
        {
17184 
                        /** @var \Illuminate\View\Factory $instance */
17185 
                        return $instance->appendSection();
17186 
        }
17187 
                    /**
17188 
         * Get the string contents of a section.
17189 
         *
17190 
         * @param string $section
17191 
         * @param string $default
17192 
         * @return string
17193 
         * @static
17194 
         */
17195 
        public static function yieldContent($section, $default = '')
17196 
        {
17197 
                        /** @var \Illuminate\View\Factory $instance */
17198 
                        return $instance->yieldContent($section, $default);
17199 
        }
17200 
                    /**
17201 
         * Get the parent placeholder for the current request.
17202 
         *
17203 
         * @param string $section
17204 
         * @return string
17205 
         * @static
17206 
         */
17207 
        public static function parentPlaceholder($section = '')
17208 
        {
17209 
                        return \Illuminate\View\Factory::parentPlaceholder($section);
17210 
        }
17211 
                    /**
17212 
         * Check if section exists.
17213 
         *
17214 
         * @param string $name
17215 
         * @return bool
17216 
         * @static
17217 
         */
17218 
        public static function hasSection($name)
17219 
        {
17220 
                        /** @var \Illuminate\View\Factory $instance */
17221 
                        return $instance->hasSection($name);
17222 
        }
17223 
                    /**
17224 
         * Check if section does not exist.
17225 
         *
17226 
         * @param string $name
17227 
         * @return bool
17228 
         * @static
17229 
         */
17230 
        public static function sectionMissing($name)
17231 
        {
17232 
                        /** @var \Illuminate\View\Factory $instance */
17233 
                        return $instance->sectionMissing($name);
17234 
        }
17235 
                    /**
17236 
         * Get the contents of a section.
17237 
         *
17238 
         * @param string $name
17239 
         * @param string|null $default
17240 
         * @return mixed
17241 
         * @static
17242 
         */
17243 
        public static function getSection($name, $default = null)
17244 
        {
17245 
                        /** @var \Illuminate\View\Factory $instance */
17246 
                        return $instance->getSection($name, $default);
17247 
        }
17248 
                    /**
17249 
         * Get the entire array of sections.
17250 
         *
17251 
         * @return array
17252 
         * @static
17253 
         */
17254 
        public static function getSections()
17255 
        {
17256 
                        /** @var \Illuminate\View\Factory $instance */
17257 
                        return $instance->getSections();
17258 
        }
17259 
                    /**
17260 
         * Flush all of the sections.
17261 
         *
17262 
         * @return void
17263 
         * @static
17264 
         */
17265 
        public static function flushSections()
17266 
        {
17267 
                        /** @var \Illuminate\View\Factory $instance */
17268 
                        $instance->flushSections();
17269 
        }
17270 
                    /**
17271 
         * Add new loop to the stack.
17272 
         *
17273 
         * @param \Countable|array $data
17274 
         * @return void
17275 
         * @static
17276 
         */
17277 
        public static function addLoop($data)
17278 
        {
17279 
                        /** @var \Illuminate\View\Factory $instance */
17280 
                        $instance->addLoop($data);
17281 
        }
17282 
                    /**
17283 
         * Increment the top loop's indices.
17284 
         *
17285 
         * @return void
17286 
         * @static
17287 
         */
17288 
        public static function incrementLoopIndices()
17289 
        {
17290 
                        /** @var \Illuminate\View\Factory $instance */
17291 
                        $instance->incrementLoopIndices();
17292 
        }
17293 
                    /**
17294 
         * Pop a loop from the top of the loop stack.
17295 
         *
17296 
         * @return void
17297 
         * @static
17298 
         */
17299 
        public static function popLoop()
17300 
        {
17301 
                        /** @var \Illuminate\View\Factory $instance */
17302 
                        $instance->popLoop();
17303 
        }
17304 
                    /**
17305 
         * Get an instance of the last loop in the stack.
17306 
         *
17307 
         * @return \stdClass|null
17308 
         * @static
17309 
         */
17310 
        public static function getLastLoop()
17311 
        {
17312 
                        /** @var \Illuminate\View\Factory $instance */
17313 
                        return $instance->getLastLoop();
17314 
        }
17315 
                    /**
17316 
         * Get the entire loop stack.
17317 
         *
17318 
         * @return array
17319 
         * @static
17320 
         */
17321 
        public static function getLoopStack()
17322 
        {
17323 
                        /** @var \Illuminate\View\Factory $instance */
17324 
                        return $instance->getLoopStack();
17325 
        }
17326 
                    /**
17327 
         * Start injecting content into a push section.
17328 
         *
17329 
         * @param string $section
17330 
         * @param string $content
17331 
         * @return void
17332 
         * @static
17333 
         */
17334 
        public static function startPush($section, $content = '')
17335 
        {
17336 
                        /** @var \Illuminate\View\Factory $instance */
17337 
                        $instance->startPush($section, $content);
17338 
        }
17339 
                    /**
17340 
         * Stop injecting content into a push section.
17341 
         *
17342 
         * @return string
17343 
         * @throws \InvalidArgumentException
17344 
         * @static
17345 
         */
17346 
        public static function stopPush()
17347 
        {
17348 
                        /** @var \Illuminate\View\Factory $instance */
17349 
                        return $instance->stopPush();
17350 
        }
17351 
                    /**
17352 
         * Start prepending content into a push section.
17353 
         *
17354 
         * @param string $section
17355 
         * @param string $content
17356 
         * @return void
17357 
         * @static
17358 
         */
17359 
        public static function startPrepend($section, $content = '')
17360 
        {
17361 
                        /** @var \Illuminate\View\Factory $instance */
17362 
                        $instance->startPrepend($section, $content);
17363 
        }
17364 
                    /**
17365 
         * Stop prepending content into a push section.
17366 
         *
17367 
         * @return string
17368 
         * @throws \InvalidArgumentException
17369 
         * @static
17370 
         */
17371 
        public static function stopPrepend()
17372 
        {
17373 
                        /** @var \Illuminate\View\Factory $instance */
17374 
                        return $instance->stopPrepend();
17375 
        }
17376 
                    /**
17377 
         * Get the string contents of a push section.
17378 
         *
17379 
         * @param string $section
17380 
         * @param string $default
17381 
         * @return string
17382 
         * @static
17383 
         */
17384 
        public static function yieldPushContent($section, $default = '')
17385 
        {
17386 
                        /** @var \Illuminate\View\Factory $instance */
17387 
                        return $instance->yieldPushContent($section, $default);
17388 
        }
17389 
                    /**
17390 
         * Flush all of the stacks.
17391 
         *
17392 
         * @return void
17393 
         * @static
17394 
         */
17395 
        public static function flushStacks()
17396 
        {
17397 
                        /** @var \Illuminate\View\Factory $instance */
17398 
                        $instance->flushStacks();
17399 
        }
17400 
                    /**
17401 
         * Start a translation block.
17402 
         *
17403 
         * @param array $replacements
17404 
         * @return void
17405 
         * @static
17406 
         */
17407 
        public static function startTranslation($replacements = [])
17408 
        {
17409 
                        /** @var \Illuminate\View\Factory $instance */
17410 
                        $instance->startTranslation($replacements);
17411 
        }
17412 
                    /**
17413 
         * Render the current translation.
17414 
         *
17415 
         * @return string
17416 
         * @static
17417 
         */
17418 
        public static function renderTranslation()
17419 
        {
17420 
                        /** @var \Illuminate\View\Factory $instance */
17421 
                        return $instance->renderTranslation();
17422 
        }
17423 
 
17424 
    }
17425 
            /**
17426 
     *
17427 
     *
17428 
     * @see \Illuminate\Foundation\Vite
17429 
     */
17430 
        class Vite {
17431 
                    /**
17432 
         * Get the preloaded assets.
17433 
         *
17434 
         * @return array
17435 
         * @static
17436 
         */
17437 
        public static function preloadedAssets()
17438 
        {
17439 
                        /** @var \Illuminate\Foundation\Vite $instance */
17440 
                        return $instance->preloadedAssets();
17441 
        }
17442 
                    /**
17443 
         * Get the Content Security Policy nonce applied to all generated tags.
17444 
         *
17445 
         * @return string|null
17446 
         * @static
17447 
         */
17448 
        public static function cspNonce()
17449 
        {
17450 
                        /** @var \Illuminate\Foundation\Vite $instance */
17451 
                        return $instance->cspNonce();
17452 
        }
17453 
                    /**
17454 
         * Generate or set a Content Security Policy nonce to apply to all generated tags.
17455 
         *
17456 
         * @param string|null $nonce
17457 
         * @return string
17458 
         * @static
17459 
         */
17460 
        public static function useCspNonce($nonce = null)
17461 
        {
17462 
                        /** @var \Illuminate\Foundation\Vite $instance */
17463 
                        return $instance->useCspNonce($nonce);
17464 
        }
17465 
                    /**
17466 
         * Use the given key to detect integrity hashes in the manifest.
17467 
         *
17468 
         * @param string|false $key
17469 
         * @return \Illuminate\Foundation\Vite
17470 
         * @static
17471 
         */
17472 
        public static function useIntegrityKey($key)
17473 
        {
17474 
                        /** @var \Illuminate\Foundation\Vite $instance */
17475 
                        return $instance->useIntegrityKey($key);
17476 
        }
17477 
                    /**
17478 
         * Set the Vite entry points.
17479 
         *
17480 
         * @param array $entryPoints
17481 
         * @return \Illuminate\Foundation\Vite
17482 
         * @static
17483 
         */
17484 
        public static function withEntryPoints($entryPoints)
17485 
        {
17486 
                        /** @var \Illuminate\Foundation\Vite $instance */
17487 
                        return $instance->withEntryPoints($entryPoints);
17488 
        }
17489 
                    /**
17490 
         * Set the filename for the manifest file.
17491 
         *
17492 
         * @param string $filename
17493 
         * @return \Illuminate\Foundation\Vite
17494 
         * @static
17495 
         */
17496 
        public static function useManifestFilename($filename)
17497 
        {
17498 
                        /** @var \Illuminate\Foundation\Vite $instance */
17499 
                        return $instance->useManifestFilename($filename);
17500 
        }
17501 
                    /**
17502 
         * Get the Vite "hot" file path.
17503 
         *
17504 
         * @return string
17505 
         * @static
17506 
         */
17507 
        public static function hotFile()
17508 
        {
17509 
                        /** @var \Illuminate\Foundation\Vite $instance */
17510 
                        return $instance->hotFile();
17511 
        }
17512 
                    /**
17513 
         * Set the Vite "hot" file path.
17514 
         *
17515 
         * @param string $path
17516 
         * @return \Illuminate\Foundation\Vite
17517 
         * @static
17518 
         */
17519 
        public static function useHotFile($path)
17520 
        {
17521 
                        /** @var \Illuminate\Foundation\Vite $instance */
17522 
                        return $instance->useHotFile($path);
17523 
        }
17524 
                    /**
17525 
         * Set the Vite build directory.
17526 
         *
17527 
         * @param string $path
17528 
         * @return \Illuminate\Foundation\Vite
17529 
         * @static
17530 
         */
17531 
        public static function useBuildDirectory($path)
17532 
        {
17533 
                        /** @var \Illuminate\Foundation\Vite $instance */
17534 
                        return $instance->useBuildDirectory($path);
17535 
        }
17536 
                    /**
17537 
         * Use the given callback to resolve attributes for script tags.
17538 
         *
17539 
         * @param \Illuminate\Foundation\(callable(string,  string, ?array, ?array): array)|array  $attributes
17540 
         * @return \Illuminate\Foundation\Vite
17541 
         * @static
17542 
         */
17543 
        public static function useScriptTagAttributes($attributes)
17544 
        {
17545 
                        /** @var \Illuminate\Foundation\Vite $instance */
17546 
                        return $instance->useScriptTagAttributes($attributes);
17547 
        }
17548 
                    /**
17549 
         * Use the given callback to resolve attributes for style tags.
17550 
         *
17551 
         * @param \Illuminate\Foundation\(callable(string,  string, ?array, ?array): array)|array  $attributes
17552 
         * @return \Illuminate\Foundation\Vite
17553 
         * @static
17554 
         */
17555 
        public static function useStyleTagAttributes($attributes)
17556 
        {
17557 
                        /** @var \Illuminate\Foundation\Vite $instance */
17558 
                        return $instance->useStyleTagAttributes($attributes);
17559 
        }
17560 
                    /**
17561 
         * Use the given callback to resolve attributes for preload tags.
17562 
         *
17563 
         * @param \Illuminate\Foundation\(callable(string,  string, ?array, ?array): (array|false))|array|false  $attributes
17564 
         * @return \Illuminate\Foundation\Vite
17565 
         * @static
17566 
         */
17567 
        public static function usePreloadTagAttributes($attributes)
17568 
        {
17569 
                        /** @var \Illuminate\Foundation\Vite $instance */
17570 
                        return $instance->usePreloadTagAttributes($attributes);
17571 
        }
17572 
                    /**
17573 
         * Generate React refresh runtime script.
17574 
         *
17575 
         * @return \Illuminate\Support\HtmlString|void
17576 
         * @static
17577 
         */
17578 
        public static function reactRefresh()
17579 
        {
17580 
                        /** @var \Illuminate\Foundation\Vite $instance */
17581 
                        return $instance->reactRefresh();
17582 
        }
17583 
                    /**
17584 
         * Get the URL for an asset.
17585 
         *
17586 
         * @param string $asset
17587 
         * @param string|null $buildDirectory
17588 
         * @return string
17589 
         * @static
17590 
         */
17591 
        public static function asset($asset, $buildDirectory = null)
17592 
        {
17593 
                        /** @var \Illuminate\Foundation\Vite $instance */
17594 
                        return $instance->asset($asset, $buildDirectory);
17595 
        }
17596 
                    /**
17597 
         * Get a unique hash representing the current manifest, or null if there is no manifest.
17598 
         *
17599 
         * @param string|null $buildDirectory
17600 
         * @return string|null
17601 
         * @static
17602 
         */
17603 
        public static function manifestHash($buildDirectory = null)
17604 
        {
17605 
                        /** @var \Illuminate\Foundation\Vite $instance */
17606 
                        return $instance->manifestHash($buildDirectory);
17607 
        }
17608 
                    /**
17609 
         * Determine if the HMR server is running.
17610 
         *
17611 
         * @return bool
17612 
         * @static
17613 
         */
17614 
        public static function isRunningHot()
17615 
        {
17616 
                        /** @var \Illuminate\Foundation\Vite $instance */
17617 
                        return $instance->isRunningHot();
17618 
        }
17619 
                    /**
17620 
         * Get the Vite tag content as a string of HTML.
17621 
         *
17622 
         * @return string
17623 
         * @static
17624 
         */
17625 
        public static function toHtml()
17626 
        {
17627 
                        /** @var \Illuminate\Foundation\Vite $instance */
17628 
                        return $instance->toHtml();
17629 
        }
17630 
                    /**
17631 
         * Register a custom macro.
17632 
         *
17633 
         * @param string $name
17634 
         * @param object|callable $macro
17635 
         * @return void
17636 
         * @static
17637 
         */
17638 
        public static function macro($name, $macro)
17639 
        {
17640 
                        \Illuminate\Foundation\Vite::macro($name, $macro);
17641 
        }
17642 
                    /**
17643 
         * Mix another object into the class.
17644 
         *
17645 
         * @param object $mixin
17646 
         * @param bool $replace
17647 
         * @return void
17648 
         * @throws \ReflectionException
17649 
         * @static
17650 
         */
17651 
        public static function mixin($mixin, $replace = true)
17652 
        {
17653 
                        \Illuminate\Foundation\Vite::mixin($mixin, $replace);
17654 
        }
17655 
                    /**
17656 
         * Checks if macro is registered.
17657 
         *
17658 
         * @param string $name
17659 
         * @return bool
17660 
         * @static
17661 
         */
17662 
        public static function hasMacro($name)
17663 
        {
17664 
                        return \Illuminate\Foundation\Vite::hasMacro($name);
17665 
        }
17666 
                    /**
17667 
         * Flush the existing macros.
17668 
         *
17669 
         * @return void
17670 
         * @static
17671 
         */
17672 
        public static function flushMacros()
17673 
        {
17674 
                        \Illuminate\Foundation\Vite::flushMacros();
17675 
        }
17676 
 
17677 
    }
17678 
 
17679 
}
17680 
 
17681 
    namespace Illuminate\Support {
17682 
            /**
17683 
     *
17684 
     *
17685 
     */
17686 
        class Arr {
17687 
 
17688 
    }
17689 
            /**
17690 
     *
17691 
     *
17692 
     */
17693 
        class Js {
17694 
 
17695 
    }
17696 
            /**
17697 
     *
17698 
     *
17699 
     */
17700 
        class Str {
17701 
 
17702 
    }
17703 
 
17704 
}
17705 
 
17706 
        namespace Srmklive\PayPal\Facades {
17707 
            /**
17708 
     *
17709 
     *
17710 
     */
17711 
        class PayPal {
17712 
                    /**
17713 
         * Get specific PayPal API provider object to use.
17714 
         *
17715 
         * @throws Exception
17716 
         * @return \Srmklive\PayPal\Services\PayPal
17717 
         * @static
17718 
         */
17719 
        public static function getProvider()
17720 
        {
17721 
                        return \Srmklive\PayPal\PayPalFacadeAccessor::getProvider();
17722 
        }
17723 
                    /**
17724 
         * Set PayPal API Client to use.
17725 
         *
17726 
         * @throws \Exception
17727 
         * @return \Srmklive\PayPal\Services\PayPal
17728 
         * @static
17729 
         */
17730 
        public static function setProvider()
17731 
        {
17732 
                        return \Srmklive\PayPal\PayPalFacadeAccessor::setProvider();
17733 
        }
17734 
 
17735 
    }
17736 
 
17737 
}
17738 
 
17739 
    namespace Clockwork\Support\Laravel {
17740 
            /**
17741 
     *
17742 
     *
17743 
     */
17744 
        class Facade {
17745 
                    /**
17746 
         *
17747 
         *
17748 
         * @static
17749 
         */
17750 
        public static function addDataSource($dataSource)
17751 
        {
17752 
                        /** @var \Clockwork\Clockwork $instance */
17753 
                        return $instance->addDataSource($dataSource);
17754 
        }
17755 
                    /**
17756 
         *
17757 
         *
17758 
         * @static
17759 
         */
17760 
        public static function resolveRequest()
17761 
        {
17762 
                        /** @var \Clockwork\Clockwork $instance */
17763 
                        return $instance->resolveRequest();
17764 
        }
17765 
                    /**
17766 
         *
17767 
         *
17768 
         * @static
17769 
         */
17770 
        public static function resolveAsCommand($name, $exitCode = null, $arguments = [], $options = [], $argumentsDefaults = [], $optionsDefaults = [], $output = null)
17771 
        {
17772 
                        /** @var \Clockwork\Clockwork $instance */
17773 
                        return $instance->resolveAsCommand($name, $exitCode, $arguments, $options, $argumentsDefaults, $optionsDefaults, $output);
17774 
        }
17775 
                    /**
17776 
         *
17777 
         *
17778 
         * @static
17779 
         */
17780 
        public static function resolveAsQueueJob($name, $description = null, $status = 'processed', $payload = [], $queue = null, $connection = null, $options = [])
17781 
        {
17782 
                        /** @var \Clockwork\Clockwork $instance */
17783 
                        return $instance->resolveAsQueueJob($name, $description, $status, $payload, $queue, $connection, $options);
17784 
        }
17785 
                    /**
17786 
         *
17787 
         *
17788 
         * @static
17789 
         */
17790 
        public static function resolveAsTest($name, $status = 'passed', $statusMessage = null, $asserts = [])
17791 
        {
17792 
                        /** @var \Clockwork\Clockwork $instance */
17793 
                        return $instance->resolveAsTest($name, $status, $statusMessage, $asserts);
17794 
        }
17795 
                    /**
17796 
         *
17797 
         *
17798 
         * @static
17799 
         */
17800 
        public static function extendRequest($request = null)
17801 
        {
17802 
                        /** @var \Clockwork\Clockwork $instance */
17803 
                        return $instance->extendRequest($request);
17804 
        }
17805 
                    /**
17806 
         *
17807 
         *
17808 
         * @static
17809 
         */
17810 
        public static function storeRequest()
17811 
        {
17812 
                        /** @var \Clockwork\Clockwork $instance */
17813 
                        return $instance->storeRequest();
17814 
        }
17815 
                    /**
17816 
         *
17817 
         *
17818 
         * @static
17819 
         */
17820 
        public static function reset()
17821 
        {
17822 
                        /** @var \Clockwork\Clockwork $instance */
17823 
                        return $instance->reset();
17824 
        }
17825 
                    /**
17826 
         *
17827 
         *
17828 
         * @static
17829 
         */
17830 
        public static function request($request = null)
17831 
        {
17832 
                        /** @var \Clockwork\Clockwork $instance */
17833 
                        return $instance->request($request);
17834 
        }
17835 
                    /**
17836 
         *
17837 
         *
17838 
         * @static
17839 
         */
17840 
        public static function log($level = null, $message = null, $context = [])
17841 
        {
17842 
                        /** @var \Clockwork\Clockwork $instance */
17843 
                        return $instance->log($level, $message, $context);
17844 
        }
17845 
                    /**
17846 
         *
17847 
         *
17848 
         * @static
17849 
         */
17850 
        public static function timeline()
17851 
        {
17852 
                        /** @var \Clockwork\Clockwork $instance */
17853 
                        return $instance->timeline();
17854 
        }
17855 
                    /**
17856 
         *
17857 
         *
17858 
         * @static
17859 
         */
17860 
        public static function event($description, $data = [])
17861 
        {
17862 
                        /** @var \Clockwork\Clockwork $instance */
17863 
                        return $instance->event($description, $data);
17864 
        }
17865 
                    /**
17866 
         *
17867 
         *
17868 
         * @static
17869 
         */
17870 
        public static function shouldCollect($shouldCollect = null)
17871 
        {
17872 
                        /** @var \Clockwork\Clockwork $instance */
17873 
                        return $instance->shouldCollect($shouldCollect);
17874 
        }
17875 
                    /**
17876 
         *
17877 
         *
17878 
         * @static
17879 
         */
17880 
        public static function shouldRecord($shouldRecord = null)
17881 
        {
17882 
                        /** @var \Clockwork\Clockwork $instance */
17883 
                        return $instance->shouldRecord($shouldRecord);
17884 
        }
17885 
                    /**
17886 
         *
17887 
         *
17888 
         * @static
17889 
         */
17890 
        public static function dataSources($dataSources = null)
17891 
        {
17892 
                        /** @var \Clockwork\Clockwork $instance */
17893 
                        return $instance->dataSources($dataSources);
17894 
        }
17895 
                    /**
17896 
         *
17897 
         *
17898 
         * @static
17899 
         */
17900 
        public static function storage($storage = null)
17901 
        {
17902 
                        /** @var \Clockwork\Clockwork $instance */
17903 
                        return $instance->storage($storage);
17904 
        }
17905 
                    /**
17906 
         *
17907 
         *
17908 
         * @static
17909 
         */
17910 
        public static function authenticator($authenticator = null)
17911 
        {
17912 
                        /** @var \Clockwork\Clockwork $instance */
17913 
                        return $instance->authenticator($authenticator);
17914 
        }
17915 
                    /**
17916 
         *
17917 
         *
17918 
         * @static
17919 
         */
17920 
        public static function getDataSources()
17921 
        {
17922 
                        /** @var \Clockwork\Clockwork $instance */
17923 
                        return $instance->getDataSources();
17924 
        }
17925 
                    /**
17926 
         *
17927 
         *
17928 
         * @static
17929 
         */
17930 
        public static function getRequest()
17931 
        {
17932 
                        /** @var \Clockwork\Clockwork $instance */
17933 
                        return $instance->getRequest();
17934 
        }
17935 
                    /**
17936 
         *
17937 
         *
17938 
         * @static
17939 
         */
17940 
        public static function setRequest($request)
17941 
        {
17942 
                        /** @var \Clockwork\Clockwork $instance */
17943 
                        return $instance->setRequest($request);
17944 
        }
17945 
                    /**
17946 
         *
17947 
         *
17948 
         * @static
17949 
         */
17950 
        public static function getStorage()
17951 
        {
17952 
                        /** @var \Clockwork\Clockwork $instance */
17953 
                        return $instance->getStorage();
17954 
        }
17955 
                    /**
17956 
         *
17957 
         *
17958 
         * @static
17959 
         */
17960 
        public static function setStorage($storage)
17961 
        {
17962 
                        /** @var \Clockwork\Clockwork $instance */
17963 
                        return $instance->setStorage($storage);
17964 
        }
17965 
                    /**
17966 
         *
17967 
         *
17968 
         * @static
17969 
         */
17970 
        public static function getAuthenticator()
17971 
        {
17972 
                        /** @var \Clockwork\Clockwork $instance */
17973 
                        return $instance->getAuthenticator();
17974 
        }
17975 
                    /**
17976 
         *
17977 
         *
17978 
         * @static
17979 
         */
17980 
        public static function setAuthenticator($authenticator)
17981 
        {
17982 
                        /** @var \Clockwork\Clockwork $instance */
17983 
                        return $instance->setAuthenticator($authenticator);
17984 
        }
17985 
 
17986 
    }
17987 
 
17988 
}
17989 
 
17990 
    namespace PragmaRX\Google2FALaravel {
17991 
            /**
17992 
     *
17993 
     *
17994 
     */
17995 
        class Facade {
17996 
                    /**
17997 
         * Set the QRCode Backend.
17998 
         *
17999 
         * @param string $qrCodeBackend
18000 
         * @return self
18001 
         * @static
18002 
         */
18003 
        public static function setQrCodeBackend($qrCodeBackend)
18004 
        {
18005 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18006 
                        return $instance->setQrCodeBackend($qrCodeBackend);
18007 
        }
18008 
                    /**
18009 
         * Authenticator boot.
18010 
         *
18011 
         * @param $request
18012 
         * @return \Google2FA
18013 
         * @static
18014 
         */
18015 
        public static function boot($request)
18016 
        {
18017 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18018 
                        return $instance->boot($request);
18019 
        }
18020 
                    /**
18021 
         * The QRCode Backend.
18022 
         *
18023 
         * @return mixed
18024 
         * @static
18025 
         */
18026 
        public static function getQRCodeBackend()
18027 
        {
18028 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18029 
                        return $instance->getQRCodeBackend();
18030 
        }
18031 
                    /**
18032 
         * Check if the 2FA is activated for the user.
18033 
         *
18034 
         * @return bool
18035 
         * @static
18036 
         */
18037 
        public static function isActivated()
18038 
        {
18039 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18040 
                        return $instance->isActivated();
18041 
        }
18042 
                    /**
18043 
         * Set current auth as valid.
18044 
         *
18045 
         * @static
18046 
         */
18047 
        public static function login()
18048 
        {
18049 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18050 
                        return $instance->login();
18051 
        }
18052 
                    /**
18053 
         * OTP logout.
18054 
         *
18055 
         * @static
18056 
         */
18057 
        public static function logout()
18058 
        {
18059 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18060 
                        return $instance->logout();
18061 
        }
18062 
                    /**
18063 
         * Verify the OTP.
18064 
         *
18065 
         * @param $secret
18066 
         * @param $one_time_password
18067 
         * @return mixed
18068 
         * @static
18069 
         */
18070 
        public static function verifyGoogle2FA($secret, $one_time_password)
18071 
        {
18072 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18073 
                        return $instance->verifyGoogle2FA($secret, $one_time_password);
18074 
        }
18075 
                    /**
18076 
         * Generates a QR code data url to display inline.
18077 
         *
18078 
         * @param string $company
18079 
         * @param string $holder
18080 
         * @param string $secret
18081 
         * @param int $size
18082 
         * @param string $encoding Default to UTF-8
18083 
         * @return string
18084 
         * @static
18085 
         */
18086 
        public static function getQRCodeInline($company, $holder, $secret, $size = 200, $encoding = 'utf-8')
18087 
        {            //Method inherited from \PragmaRX\Google2FAQRCode\Google2FA
18088 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18089 
                        return $instance->getQRCodeInline($company, $holder, $secret, $size, $encoding);
18090 
        }
18091 
                    /**
18092 
         * Service setter
18093 
         *
18094 
         * @return \PragmaRX\Google2FAQRCode\QRCode\QRCodeServiceContract
18095 
         * @static
18096 
         */
18097 
        public static function getQrCodeService()
18098 
        {            //Method inherited from \PragmaRX\Google2FAQRCode\Google2FA
18099 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18100 
                        return $instance->getQrCodeService();
18101 
        }
18102 
                    /**
18103 
         * Service setter
18104 
         *
18105 
         * @return self
18106 
         * @static
18107 
         */
18108 
        public static function setQrCodeService($service)
18109 
        {            //Method inherited from \PragmaRX\Google2FAQRCode\Google2FA
18110 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18111 
                        return $instance->setQrCodeService($service);
18112 
        }
18113 
                    /**
18114 
         * Create the QR Code service instance
18115 
         *
18116 
         * @return \PragmaRX\Google2FAQRCode\QRCode\QRCodeServiceContract
18117 
         * @static
18118 
         */
18119 
        public static function qrCodeServiceFactory($imageBackEnd = null)
18120 
        {            //Method inherited from \PragmaRX\Google2FAQRCode\Google2FA
18121 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18122 
                        return $instance->qrCodeServiceFactory($imageBackEnd);
18123 
        }
18124 
                    /**
18125 
         * Find a valid One Time Password.
18126 
         *
18127 
         * @param string $secret
18128 
         * @param string $key
18129 
         * @param int|null $window
18130 
         * @param int $startingTimestamp
18131 
         * @param int $timestamp
18132 
         * @param int|null $oldTimestamp
18133 
         * @throws \PragmaRX\Google2FA\Exceptions\SecretKeyTooShortException
18134 
         * @throws \PragmaRX\Google2FA\Exceptions\InvalidCharactersException
18135 
         * @throws \PragmaRX\Google2FA\Exceptions\IncompatibleWithGoogleAuthenticatorException
18136 
         * @return bool|int
18137 
         * @static
18138 
         */
18139 
        public static function findValidOTP($secret, $key, $window, $startingTimestamp, $timestamp, $oldTimestamp = null)
18140 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18141 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18142 
                        return $instance->findValidOTP($secret, $key, $window, $startingTimestamp, $timestamp, $oldTimestamp);
18143 
        }
18144 
                    /**
18145 
         * Generate a digit secret key in base32 format.
18146 
         *
18147 
         * @param int $length
18148 
         * @param string $prefix
18149 
         * @throws \PragmaRX\Google2FA\Exceptions\IncompatibleWithGoogleAuthenticatorException
18150 
         * @throws \PragmaRX\Google2FA\Exceptions\InvalidCharactersException
18151 
         * @throws \PragmaRX\Google2FA\Exceptions\SecretKeyTooShortException
18152 
         * @return string
18153 
         * @static
18154 
         */
18155 
        public static function generateSecretKey($length = 16, $prefix = '')
18156 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18157 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18158 
                        return $instance->generateSecretKey($length, $prefix);
18159 
        }
18160 
                    /**
18161 
         * Get the current one time password for a key.
18162 
         *
18163 
         * @param string $secret
18164 
         * @throws \PragmaRX\Google2FA\Exceptions\SecretKeyTooShortException
18165 
         * @throws \PragmaRX\Google2FA\Exceptions\InvalidCharactersException
18166 
         * @throws \PragmaRX\Google2FA\Exceptions\IncompatibleWithGoogleAuthenticatorException
18167 
         * @return string
18168 
         * @static
18169 
         */
18170 
        public static function getCurrentOtp($secret)
18171 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18172 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18173 
                        return $instance->getCurrentOtp($secret);
18174 
        }
18175 
                    /**
18176 
         * Get the HMAC algorithm.
18177 
         *
18178 
         * @return string
18179 
         * @static
18180 
         */
18181 
        public static function getAlgorithm()
18182 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18183 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18184 
                        return $instance->getAlgorithm();
18185 
        }
18186 
                    /**
18187 
         * Get key regeneration.
18188 
         *
18189 
         * @return int
18190 
         * @static
18191 
         */
18192 
        public static function getKeyRegeneration()
18193 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18194 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18195 
                        return $instance->getKeyRegeneration();
18196 
        }
18197 
                    /**
18198 
         * Get OTP length.
18199 
         *
18200 
         * @return int
18201 
         * @static
18202 
         */
18203 
        public static function getOneTimePasswordLength()
18204 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18205 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18206 
                        return $instance->getOneTimePasswordLength();
18207 
        }
18208 
                    /**
18209 
         * Get secret.
18210 
         *
18211 
         * @param string|null $secret
18212 
         * @return string
18213 
         * @static
18214 
         */
18215 
        public static function getSecret($secret = null)
18216 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18217 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18218 
                        return $instance->getSecret($secret);
18219 
        }
18220 
                    /**
18221 
         * Returns the current Unix Timestamp divided by the $keyRegeneration
18222 
         * period.
18223 
         *
18224 
         * @return int
18225 
         * @static
18226 
         */
18227 
        public static function getTimestamp()
18228 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18229 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18230 
                        return $instance->getTimestamp();
18231 
        }
18232 
                    /**
18233 
         * Get the OTP window.
18234 
         *
18235 
         * @param null|int $window
18236 
         * @return int
18237 
         * @static
18238 
         */
18239 
        public static function getWindow($window = null)
18240 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18241 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18242 
                        return $instance->getWindow($window);
18243 
        }
18244 
                    /**
18245 
         * Takes the secret key and the timestamp and returns the one time
18246 
         * password.
18247 
         *
18248 
         * @param string $secret Secret key in binary form.
18249 
         * @param int $counter Timestamp as returned by getTimestamp.
18250 
         * @throws \PragmaRX\Google2FA\Exceptions\SecretKeyTooShortException
18251 
         * @throws \PragmaRX\Google2FA\Exceptions\InvalidCharactersException
18252 
         * @throws Exceptions\IncompatibleWithGoogleAuthenticatorException
18253 
         * @return string
18254 
         * @static
18255 
         */
18256 
        public static function oathTotp($secret, $counter)
18257 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18258 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18259 
                        return $instance->oathTotp($secret, $counter);
18260 
        }
18261 
                    /**
18262 
         * Extracts the OTP from the SHA1 hash.
18263 
         *
18264 
         * @param string $hash
18265 
         * @return string
18266 
         * @static
18267 
         */
18268 
        public static function oathTruncate($hash)
18269 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18270 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18271 
                        return $instance->oathTruncate($hash);
18272 
        }
18273 
                    /**
18274 
         * Remove invalid chars from a base 32 string.
18275 
         *
18276 
         * @param string $string
18277 
         * @return string|null
18278 
         * @static
18279 
         */
18280 
        public static function removeInvalidChars($string)
18281 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18282 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18283 
                        return $instance->removeInvalidChars($string);
18284 
        }
18285 
                    /**
18286 
         * Setter for the enforce Google Authenticator compatibility property.
18287 
         *
18288 
         * @param mixed $enforceGoogleAuthenticatorCompatibility
18289 
         * @return \PragmaRX\Google2FALaravel\Google2FA
18290 
         * @static
18291 
         */
18292 
        public static function setEnforceGoogleAuthenticatorCompatibility($enforceGoogleAuthenticatorCompatibility)
18293 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18294 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18295 
                        return $instance->setEnforceGoogleAuthenticatorCompatibility($enforceGoogleAuthenticatorCompatibility);
18296 
        }
18297 
                    /**
18298 
         * Set the HMAC hashing algorithm.
18299 
         *
18300 
         * @param mixed $algorithm
18301 
         * @throws \PragmaRX\Google2FA\Exceptions\InvalidAlgorithmException
18302 
         * @return \PragmaRX\Google2FA\Google2FA
18303 
         * @static
18304 
         */
18305 
        public static function setAlgorithm($algorithm)
18306 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18307 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18308 
                        return $instance->setAlgorithm($algorithm);
18309 
        }
18310 
                    /**
18311 
         * Set key regeneration.
18312 
         *
18313 
         * @param mixed $keyRegeneration
18314 
         * @static
18315 
         */
18316 
        public static function setKeyRegeneration($keyRegeneration)
18317 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18318 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18319 
                        return $instance->setKeyRegeneration($keyRegeneration);
18320 
        }
18321 
                    /**
18322 
         * Set OTP length.
18323 
         *
18324 
         * @param mixed $oneTimePasswordLength
18325 
         * @static
18326 
         */
18327 
        public static function setOneTimePasswordLength($oneTimePasswordLength)
18328 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18329 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18330 
                        return $instance->setOneTimePasswordLength($oneTimePasswordLength);
18331 
        }
18332 
                    /**
18333 
         * Set secret.
18334 
         *
18335 
         * @param mixed $secret
18336 
         * @static
18337 
         */
18338 
        public static function setSecret($secret)
18339 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18340 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18341 
                        return $instance->setSecret($secret);
18342 
        }
18343 
                    /**
18344 
         * Set the OTP window.
18345 
         *
18346 
         * @param mixed $window
18347 
         * @static
18348 
         */
18349 
        public static function setWindow($window)
18350 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18351 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18352 
                        return $instance->setWindow($window);
18353 
        }
18354 
                    /**
18355 
         * Verifies a user inputted key against the current timestamp. Checks $window
18356 
         * keys either side of the timestamp.
18357 
         *
18358 
         * @param string $key User specified key
18359 
         * @param string $secret
18360 
         * @param null|int $window
18361 
         * @param null|int $timestamp
18362 
         * @param null|int $oldTimestamp
18363 
         * @throws \PragmaRX\Google2FA\Exceptions\SecretKeyTooShortException
18364 
         * @throws \PragmaRX\Google2FA\Exceptions\InvalidCharactersException
18365 
         * @throws \PragmaRX\Google2FA\Exceptions\IncompatibleWithGoogleAuthenticatorException
18366 
         * @return bool|int
18367 
         * @static
18368 
         */
18369 
        public static function verify($key, $secret, $window = null, $timestamp = null, $oldTimestamp = null)
18370 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18371 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18372 
                        return $instance->verify($key, $secret, $window, $timestamp, $oldTimestamp);
18373 
        }
18374 
                    /**
18375 
         * Verifies a user inputted key against the current timestamp. Checks $window
18376 
         * keys either side of the timestamp.
18377 
         *
18378 
         * @param string $secret
18379 
         * @param string $key User specified key
18380 
         * @param int|null $window
18381 
         * @param null|int $timestamp
18382 
         * @param null|int $oldTimestamp
18383 
         * @throws \PragmaRX\Google2FA\Exceptions\SecretKeyTooShortException
18384 
         * @throws \PragmaRX\Google2FA\Exceptions\InvalidCharactersException
18385 
         * @throws \PragmaRX\Google2FA\Exceptions\IncompatibleWithGoogleAuthenticatorException
18386 
         * @return bool|int
18387 
         * @static
18388 
         */
18389 
        public static function verifyKey($secret, $key, $window = null, $timestamp = null, $oldTimestamp = null)
18390 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18391 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18392 
                        return $instance->verifyKey($secret, $key, $window, $timestamp, $oldTimestamp);
18393 
        }
18394 
                    /**
18395 
         * Verifies a user inputted key against the current timestamp. Checks $window
18396 
         * keys either side of the timestamp, but ensures that the given key is newer than
18397 
         * the given oldTimestamp. Useful if you need to ensure that a single key cannot
18398 
         * be used twice.
18399 
         *
18400 
         * @param string $secret
18401 
         * @param string $key User specified key
18402 
         * @param int|null $oldTimestamp The timestamp from the last verified key
18403 
         * @param int|null $window
18404 
         * @param int|null $timestamp
18405 
         * @throws \PragmaRX\Google2FA\Exceptions\SecretKeyTooShortException
18406 
         * @throws \PragmaRX\Google2FA\Exceptions\InvalidCharactersException
18407 
         * @throws \PragmaRX\Google2FA\Exceptions\IncompatibleWithGoogleAuthenticatorException
18408 
         * @return bool|int
18409 
         * @static
18410 
         */
18411 
        public static function verifyKeyNewer($secret, $key, $oldTimestamp, $window = null, $timestamp = null)
18412 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18413 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18414 
                        return $instance->verifyKeyNewer($secret, $key, $oldTimestamp, $window, $timestamp);
18415 
        }
18416 
                    /**
18417 
         * Creates a QR code url.
18418 
         *
18419 
         * @param string $company
18420 
         * @param string $holder
18421 
         * @param string $secret
18422 
         * @return string
18423 
         * @static
18424 
         */
18425 
        public static function getQRCodeUrl($company, $holder, $secret)
18426 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18427 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18428 
                        return $instance->getQRCodeUrl($company, $holder, $secret);
18429 
        }
18430 
                    /**
18431 
         * Generate a digit secret key in base32 format.
18432 
         *
18433 
         * @param int $length
18434 
         * @param string $prefix
18435 
         * @throws \Exception
18436 
         * @throws \PragmaRX\Google2FA\Exceptions\InvalidCharactersException
18437 
         * @throws \PragmaRX\Google2FA\Exceptions\SecretKeyTooShortException
18438 
         * @throws \PragmaRX\Google2FA\Exceptions\IncompatibleWithGoogleAuthenticatorException
18439 
         * @return string
18440 
         * @static
18441 
         */
18442 
        public static function generateBase32RandomKey($length = 16, $prefix = '')
18443 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18444 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18445 
                        return $instance->generateBase32RandomKey($length, $prefix);
18446 
        }
18447 
                    /**
18448 
         * Decodes a base32 string into a binary string.
18449 
         *
18450 
         * @param string $b32
18451 
         * @throws \PragmaRX\Google2FA\Exceptions\InvalidCharactersException
18452 
         * @throws \PragmaRX\Google2FA\Exceptions\SecretKeyTooShortException
18453 
         * @throws \PragmaRX\Google2FA\Exceptions\IncompatibleWithGoogleAuthenticatorException
18454 
         * @return string
18455 
         * @static
18456 
         */
18457 
        public static function base32Decode($b32)
18458 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18459 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18460 
                        return $instance->base32Decode($b32);
18461 
        }
18462 
                    /**
18463 
         * Encode a string to Base32.
18464 
         *
18465 
         * @param string $string
18466 
         * @return string
18467 
         * @static
18468 
         */
18469 
        public static function toBase32($string)
18470 
        {            //Method inherited from \PragmaRX\Google2FA\Google2FA
18471 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18472 
                        return $instance->toBase32($string);
18473 
        }
18474 
                    /**
18475 
         * Get a config value.
18476 
         *
18477 
         * @param $string
18478 
         * @throws \Exception
18479 
         * @return mixed
18480 
         * @static
18481 
         */
18482 
        public static function config($string, $default = null)
18483 
        {
18484 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18485 
                        return $instance->config($string, $default);
18486 
        }
18487 
                    /**
18488 
         * Get the request property.
18489 
         *
18490 
         * @return mixed
18491 
         * @static
18492 
         */
18493 
        public static function getRequest()
18494 
        {
18495 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18496 
                        return $instance->getRequest();
18497 
        }
18498 
                    /**
18499 
         * Set the request property.
18500 
         *
18501 
         * @param mixed $request
18502 
         * @return \PragmaRX\Google2FALaravel\Google2FA
18503 
         * @static
18504 
         */
18505 
        public static function setRequest($request)
18506 
        {
18507 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18508 
                        return $instance->setRequest($request);
18509 
        }
18510 
                    /**
18511 
         * Get a session var value.
18512 
         *
18513 
         * @param null $var
18514 
         * @return mixed
18515 
         * @static
18516 
         */
18517 
        public static function sessionGet($var = null, $default = null)
18518 
        {
18519 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18520 
                        return $instance->sessionGet($var, $default);
18521 
        }
18522 
                    /**
18523 
         *
18524 
         *
18525 
         * @param mixed $stateless
18526 
         * @return \PragmaRX\Google2FALaravel\Authenticator
18527 
         * @static
18528 
         */
18529 
        public static function setStateless($stateless = true)
18530 
        {
18531 
                        /** @var \PragmaRX\Google2FALaravel\Google2FA $instance */
18532 
                        return $instance->setStateless($stateless);
18533 
        }
18534 
 
18535 
    }
18536 
 
18537 
}
18538 
 
18539 
    namespace Spatie\LaravelIgnition\Facades {
18540 
            /**
18541 
     *
18542 
     *
18543 
     * @see \Spatie\FlareClient\Flare
18544 
     */
18545 
        class Flare {
18546 
                    /**
18547 
         *
18548 
         *
18549 
         * @static
18550 
         */
18551 
        public static function make($apiKey = null, $contextDetector = null)
18552 
        {
18553 
                        return \Spatie\FlareClient\Flare::make($apiKey, $contextDetector);
18554 
        }
18555 
                    /**
18556 
         *
18557 
         *
18558 
         * @static
18559 
         */
18560 
        public static function setApiToken($apiToken)
18561 
        {
18562 
                        /** @var \Spatie\FlareClient\Flare $instance */
18563 
                        return $instance->setApiToken($apiToken);
18564 
        }
18565 
                    /**
18566 
         *
18567 
         *
18568 
         * @static
18569 
         */
18570 
        public static function apiTokenSet()
18571 
        {
18572 
                        /** @var \Spatie\FlareClient\Flare $instance */
18573 
                        return $instance->apiTokenSet();
18574 
        }
18575 
                    /**
18576 
         *
18577 
         *
18578 
         * @static
18579 
         */
18580 
        public static function setBaseUrl($baseUrl)
18581 
        {
18582 
                        /** @var \Spatie\FlareClient\Flare $instance */
18583 
                        return $instance->setBaseUrl($baseUrl);
18584 
        }
18585 
                    /**
18586 
         *
18587 
         *
18588 
         * @static
18589 
         */
18590 
        public static function setStage($stage)
18591 
        {
18592 
                        /** @var \Spatie\FlareClient\Flare $instance */
18593 
                        return $instance->setStage($stage);
18594 
        }
18595 
                    /**
18596 
         *
18597 
         *
18598 
         * @static
18599 
         */
18600 
        public static function sendReportsImmediately()
18601 
        {
18602 
                        /** @var \Spatie\FlareClient\Flare $instance */
18603 
                        return $instance->sendReportsImmediately();
18604 
        }
18605 
                    /**
18606 
         *
18607 
         *
18608 
         * @static
18609 
         */
18610 
        public static function determineVersionUsing($determineVersionCallable)
18611 
        {
18612 
                        /** @var \Spatie\FlareClient\Flare $instance */
18613 
                        return $instance->determineVersionUsing($determineVersionCallable);
18614 
        }
18615 
                    /**
18616 
         *
18617 
         *
18618 
         * @static
18619 
         */
18620 
        public static function reportErrorLevels($reportErrorLevels)
18621 
        {
18622 
                        /** @var \Spatie\FlareClient\Flare $instance */
18623 
                        return $instance->reportErrorLevels($reportErrorLevels);
18624 
        }
18625 
                    /**
18626 
         *
18627 
         *
18628 
         * @static
18629 
         */
18630 
        public static function filterExceptionsUsing($filterExceptionsCallable)
18631 
        {
18632 
                        /** @var \Spatie\FlareClient\Flare $instance */
18633 
                        return $instance->filterExceptionsUsing($filterExceptionsCallable);
18634 
        }
18635 
                    /**
18636 
         *
18637 
         *
18638 
         * @static
18639 
         */
18640 
        public static function filterReportsUsing($filterReportsCallable)
18641 
        {
18642 
                        /** @var \Spatie\FlareClient\Flare $instance */
18643 
                        return $instance->filterReportsUsing($filterReportsCallable);
18644 
        }
18645 
                    /**
18646 
         *
18647 
         *
18648 
         * @param array<class-string<ArgumentReducer>|ArgumentReducer>|\Spatie\Backtrace\Arguments\ArgumentReducers|null $argumentReducers
18649 
         * @static
18650 
         */
18651 
        public static function argumentReducers($argumentReducers)
18652 
        {
18653 
                        /** @var \Spatie\FlareClient\Flare $instance */
18654 
                        return $instance->argumentReducers($argumentReducers);
18655 
        }
18656 
                    /**
18657 
         *
18658 
         *
18659 
         * @static
18660 
         */
18661 
        public static function withStackFrameArguments($withStackFrameArguments = true)
18662 
        {
18663 
                        /** @var \Spatie\FlareClient\Flare $instance */
18664 
                        return $instance->withStackFrameArguments($withStackFrameArguments);
18665 
        }
18666 
                    /**
18667 
         *
18668 
         *
18669 
         * @static
18670 
         */
18671 
        public static function version()
18672 
        {
18673 
                        /** @var \Spatie\FlareClient\Flare $instance */
18674 
                        return $instance->version();
18675 
        }
18676 
                    /**
18677 
         *
18678 
         *
18679 
         * @return array<int, FlareMiddleware|class-string<FlareMiddleware>>
18680 
         * @static
18681 
         */
18682 
        public static function getMiddleware()
18683 
        {
18684 
                        /** @var \Spatie\FlareClient\Flare $instance */
18685 
                        return $instance->getMiddleware();
18686 
        }
18687 
                    /**
18688 
         *
18689 
         *
18690 
         * @static
18691 
         */
18692 
        public static function setContextProviderDetector($contextDetector)
18693 
        {
18694 
                        /** @var \Spatie\FlareClient\Flare $instance */
18695 
                        return $instance->setContextProviderDetector($contextDetector);
18696 
        }
18697 
                    /**
18698 
         *
18699 
         *
18700 
         * @static
18701 
         */
18702 
        public static function setContainer($container)
18703 
        {
18704 
                        /** @var \Spatie\FlareClient\Flare $instance */
18705 
                        return $instance->setContainer($container);
18706 
        }
18707 
                    /**
18708 
         *
18709 
         *
18710 
         * @static
18711 
         */
18712 
        public static function registerFlareHandlers()
18713 
        {
18714 
                        /** @var \Spatie\FlareClient\Flare $instance */
18715 
                        return $instance->registerFlareHandlers();
18716 
        }
18717 
                    /**
18718 
         *
18719 
         *
18720 
         * @static
18721 
         */
18722 
        public static function registerExceptionHandler()
18723 
        {
18724 
                        /** @var \Spatie\FlareClient\Flare $instance */
18725 
                        return $instance->registerExceptionHandler();
18726 
        }
18727 
                    /**
18728 
         *
18729 
         *
18730 
         * @static
18731 
         */
18732 
        public static function registerErrorHandler()
18733 
        {
18734 
                        /** @var \Spatie\FlareClient\Flare $instance */
18735 
                        return $instance->registerErrorHandler();
18736 
        }
18737 
                    /**
18738 
         *
18739 
         *
18740 
         * @param \Spatie\FlareClient\FlareMiddleware\FlareMiddleware|array<FlareMiddleware>|\Spatie\FlareClient\class-string<FlareMiddleware>|callable $middleware
18741 
         * @return \Spatie\FlareClient\Flare
18742 
         * @static
18743 
         */
18744 
        public static function registerMiddleware($middleware)
18745 
        {
18746 
                        /** @var \Spatie\FlareClient\Flare $instance */
18747 
                        return $instance->registerMiddleware($middleware);
18748 
        }
18749 
                    /**
18750 
         *
18751 
         *
18752 
         * @return array<int,FlareMiddleware|class-string<FlareMiddleware>>
18753 
         * @static
18754 
         */
18755 
        public static function getMiddlewares()
18756 
        {
18757 
                        /** @var \Spatie\FlareClient\Flare $instance */
18758 
                        return $instance->getMiddlewares();
18759 
        }
18760 
                    /**
18761 
         *
18762 
         *
18763 
         * @param string $name
18764 
         * @param string $messageLevel
18765 
         * @param array<int, mixed> $metaData
18766 
         * @return \Spatie\FlareClient\Flare
18767 
         * @static
18768 
         */
18769 
        public static function glow($name, $messageLevel = 'info', $metaData = [])
18770 
        {
18771 
                        /** @var \Spatie\FlareClient\Flare $instance */
18772 
                        return $instance->glow($name, $messageLevel, $metaData);
18773 
        }
18774 
                    /**
18775 
         *
18776 
         *
18777 
         * @static
18778 
         */
18779 
        public static function handleException($throwable)
18780 
        {
18781 
                        /** @var \Spatie\FlareClient\Flare $instance */
18782 
                        return $instance->handleException($throwable);
18783 
        }
18784 
                    /**
18785 
         *
18786 
         *
18787 
         * @return mixed
18788 
         * @static
18789 
         */
18790 
        public static function handleError($code, $message, $file = '', $line = 0)
18791 
        {
18792 
                        /** @var \Spatie\FlareClient\Flare $instance */
18793 
                        return $instance->handleError($code, $message, $file, $line);
18794 
        }
18795 
                    /**
18796 
         *
18797 
         *
18798 
         * @static
18799 
         */
18800 
        public static function applicationPath($applicationPath)
18801 
        {
18802 
                        /** @var \Spatie\FlareClient\Flare $instance */
18803 
                        return $instance->applicationPath($applicationPath);
18804 
        }
18805 
                    /**
18806 
         *
18807 
         *
18808 
         * @static
18809 
         */
18810 
        public static function report($throwable, $callback = null, $report = null)
18811 
        {
18812 
                        /** @var \Spatie\FlareClient\Flare $instance */
18813 
                        return $instance->report($throwable, $callback, $report);
18814 
        }
18815 
                    /**
18816 
         *
18817 
         *
18818 
         * @static
18819 
         */
18820 
        public static function reportMessage($message, $logLevel, $callback = null)
18821 
        {
18822 
                        /** @var \Spatie\FlareClient\Flare $instance */
18823 
                        return $instance->reportMessage($message, $logLevel, $callback);
18824 
        }
18825 
                    /**
18826 
         *
18827 
         *
18828 
         * @static
18829 
         */
18830 
        public static function sendTestReport($throwable)
18831 
        {
18832 
                        /** @var \Spatie\FlareClient\Flare $instance */
18833 
                        return $instance->sendTestReport($throwable);
18834 
        }
18835 
                    /**
18836 
         *
18837 
         *
18838 
         * @static
18839 
         */
18840 
        public static function reset()
18841 
        {
18842 
                        /** @var \Spatie\FlareClient\Flare $instance */
18843 
                        return $instance->reset();
18844 
        }
18845 
                    /**
18846 
         *
18847 
         *
18848 
         * @static
18849 
         */
18850 
        public static function anonymizeIp()
18851 
        {
18852 
                        /** @var \Spatie\FlareClient\Flare $instance */
18853 
                        return $instance->anonymizeIp();
18854 
        }
18855 
                    /**
18856 
         *
18857 
         *
18858 
         * @param array<int, string> $fieldNames
18859 
         * @return \Spatie\FlareClient\Flare
18860 
         * @static
18861 
         */
18862 
        public static function censorRequestBodyFields($fieldNames)
18863 
        {
18864 
                        /** @var \Spatie\FlareClient\Flare $instance */
18865 
                        return $instance->censorRequestBodyFields($fieldNames);
18866 
        }
18867 
                    /**
18868 
         *
18869 
         *
18870 
         * @static
18871 
         */
18872 
        public static function createReport($throwable)
18873 
        {
18874 
                        /** @var \Spatie\FlareClient\Flare $instance */
18875 
                        return $instance->createReport($throwable);
18876 
        }
18877 
                    /**
18878 
         *
18879 
         *
18880 
         * @static
18881 
         */
18882 
        public static function createReportFromMessage($message, $logLevel)
18883 
        {
18884 
                        /** @var \Spatie\FlareClient\Flare $instance */
18885 
                        return $instance->createReportFromMessage($message, $logLevel);
18886 
        }
18887 
                    /**
18888 
         *
18889 
         *
18890 
         * @static
18891 
         */
18892 
        public static function stage($stage)
18893 
        {
18894 
                        /** @var \Spatie\FlareClient\Flare $instance */
18895 
                        return $instance->stage($stage);
18896 
        }
18897 
                    /**
18898 
         *
18899 
         *
18900 
         * @static
18901 
         */
18902 
        public static function messageLevel($messageLevel)
18903 
        {
18904 
                        /** @var \Spatie\FlareClient\Flare $instance */
18905 
                        return $instance->messageLevel($messageLevel);
18906 
        }
18907 
                    /**
18908 
         *
18909 
         *
18910 
         * @param string $groupName
18911 
         * @param mixed $default
18912 
         * @return array<int, mixed>
18913 
         * @static
18914 
         */
18915 
        public static function getGroup($groupName = 'context', $default = [])
18916 
        {
18917 
                        /** @var \Spatie\FlareClient\Flare $instance */
18918 
                        return $instance->getGroup($groupName, $default);
18919 
        }
18920 
                    /**
18921 
         *
18922 
         *
18923 
         * @static
18924 
         */
18925 
        public static function context($key, $value)
18926 
        {
18927 
                        /** @var \Spatie\FlareClient\Flare $instance */
18928 
                        return $instance->context($key, $value);
18929 
        }
18930 
                    /**
18931 
         *
18932 
         *
18933 
         * @param string $groupName
18934 
         * @param array<string, mixed> $properties
18935 
         * @return \Spatie\FlareClient\Flare
18936 
         * @static
18937 
         */
18938 
        public static function group($groupName, $properties)
18939 
        {
18940 
                        /** @var \Spatie\FlareClient\Flare $instance */
18941 
                        return $instance->group($groupName, $properties);
18942 
        }
18943 
 
18944 
    }
18945 
 
18946 
}
18947 
 
18948 
    namespace Illuminate\Http {
18949 
            /**
18950 
     *
18951 
     *
18952 
     */
18953 
        class Request {
18954 
                    /**
18955 
         *
18956 
         *
18957 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
18958 
         * @param array $rules
18959 
         * @param mixed $params
18960 
         * @static
18961 
         */
18962 
        public static function validate($rules, ...$params)
18963 
        {
18964 
                        return \Illuminate\Http\Request::validate($rules, ...$params);
18965 
        }
18966 
                    /**
18967 
         *
18968 
         *
18969 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
18970 
         * @param string $errorBag
18971 
         * @param array $rules
18972 
         * @param mixed $params
18973 
         * @static
18974 
         */
18975 
        public static function validateWithBag($errorBag, $rules, ...$params)
18976 
        {
18977 
                        return \Illuminate\Http\Request::validateWithBag($errorBag, $rules, ...$params);
18978 
        }
18979 
                    /**
18980 
         *
18981 
         *
18982 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
18983 
         * @param mixed $absolute
18984 
         * @static
18985 
         */
18986 
        public static function hasValidSignature($absolute = true)
18987 
        {
18988 
                        return \Illuminate\Http\Request::hasValidSignature($absolute);
18989 
        }
18990 
                    /**
18991 
         *
18992 
         *
18993 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
18994 
         * @static
18995 
         */
18996 
        public static function hasValidRelativeSignature()
18997 
        {
18998 
                        return \Illuminate\Http\Request::hasValidRelativeSignature();
18999 
        }
19000 
                    /**
19001 
         *
19002 
         *
19003 
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
19004 
         * @param mixed $ignoreQuery
19005 
         * @param mixed $absolute
19006 
         * @static
19007 
         */
19008 
        public static function hasValidSignatureWhileIgnoring($ignoreQuery = [], $absolute = true)
19009 
        {
19010 
                        return \Illuminate\Http\Request::hasValidSignatureWhileIgnoring($ignoreQuery, $absolute);
19011 
        }
19012 
 
19013 
    }
19014 
 
19015 
}
19016 
 
19017 
 
19018 
namespace  {
19019 
            class App extends \Illuminate\Support\Facades\App {}
19020 
            class Arr extends \Illuminate\Support\Arr {}
19021 
            class Artisan extends \Illuminate\Support\Facades\Artisan {}
19022 
            class Auth extends \Illuminate\Support\Facades\Auth {}
19023 
            class Blade extends \Illuminate\Support\Facades\Blade {}
19024 
            class Broadcast extends \Illuminate\Support\Facades\Broadcast {}
19025 
            class Bus extends \Illuminate\Support\Facades\Bus {}
19026 
            class Cache extends \Illuminate\Support\Facades\Cache {}
19027 
            class Config extends \Illuminate\Support\Facades\Config {}
19028 
            class Cookie extends \Illuminate\Support\Facades\Cookie {}
19029 
            class Crypt extends \Illuminate\Support\Facades\Crypt {}
19030 
            class Date extends \Illuminate\Support\Facades\Date {}
19031 
            class DB extends \Illuminate\Support\Facades\DB {}
19032 
            class Eloquent extends \Illuminate\Database\Eloquent\Model {
19033 
                /**
19034 
             * Create and return an un-saved model instance.
19035 
             *
19036 
             * @param array $attributes
19037 
             * @return \Illuminate\Database\Eloquent\Model|static
19038 
             * @static
19039 
             */
19040 
            public static function make($attributes = [])
19041 
            {
19042 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19043 
                                return $instance->make($attributes);
19044 
            }
19045 
 
19046 
                /**
19047 
             * Register a new global scope.
19048 
             *
19049 
             * @param string $identifier
19050 
             * @param \Illuminate\Database\Eloquent\Scope|\Closure $scope
19051 
             * @return \Illuminate\Database\Eloquent\Builder|static
19052 
             * @static
19053 
             */
19054 
            public static function withGlobalScope($identifier, $scope)
19055 
            {
19056 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19057 
                                return $instance->withGlobalScope($identifier, $scope);
19058 
            }
19059 
 
19060 
                /**
19061 
             * Remove a registered global scope.
19062 
             *
19063 
             * @param \Illuminate\Database\Eloquent\Scope|string $scope
19064 
             * @return \Illuminate\Database\Eloquent\Builder|static
19065 
             * @static
19066 
             */
19067 
            public static function withoutGlobalScope($scope)
19068 
            {
19069 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19070 
                                return $instance->withoutGlobalScope($scope);
19071 
            }
19072 
 
19073 
                /**
19074 
             * Remove all or passed registered global scopes.
19075 
             *
19076 
             * @param array|null $scopes
19077 
             * @return \Illuminate\Database\Eloquent\Builder|static
19078 
             * @static
19079 
             */
19080 
            public static function withoutGlobalScopes($scopes = null)
19081 
            {
19082 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19083 
                                return $instance->withoutGlobalScopes($scopes);
19084 
            }
19085 
 
19086 
                /**
19087 
             * Get an array of global scopes that were removed from the query.
19088 
             *
19089 
             * @return array
19090 
             * @static
19091 
             */
19092 
            public static function removedScopes()
19093 
            {
19094 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19095 
                                return $instance->removedScopes();
19096 
            }
19097 
 
19098 
                /**
19099 
             * Add a where clause on the primary key to the query.
19100 
             *
19101 
             * @param mixed $id
19102 
             * @return \Illuminate\Database\Eloquent\Builder|static
19103 
             * @static
19104 
             */
19105 
            public static function whereKey($id)
19106 
            {
19107 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19108 
                                return $instance->whereKey($id);
19109 
            }
19110 
 
19111 
                /**
19112 
             * Add a where clause on the primary key to the query.
19113 
             *
19114 
             * @param mixed $id
19115 
             * @return \Illuminate\Database\Eloquent\Builder|static
19116 
             * @static
19117 
             */
19118 
            public static function whereKeyNot($id)
19119 
            {
19120 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19121 
                                return $instance->whereKeyNot($id);
19122 
            }
19123 
 
19124 
                /**
19125 
             * Add a basic where clause to the query.
19126 
             *
19127 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
19128 
             * @param mixed $operator
19129 
             * @param mixed $value
19130 
             * @param string $boolean
19131 
             * @return \Illuminate\Database\Eloquent\Builder|static
19132 
             * @static
19133 
             */
19134 
            public static function where($column, $operator = null, $value = null, $boolean = 'and')
19135 
            {
19136 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19137 
                                return $instance->where($column, $operator, $value, $boolean);
19138 
            }
19139 
 
19140 
                /**
19141 
             * Add a basic where clause to the query, and return the first result.
19142 
             *
19143 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
19144 
             * @param mixed $operator
19145 
             * @param mixed $value
19146 
             * @param string $boolean
19147 
             * @return \Illuminate\Database\Eloquent\Model|static|null
19148 
             * @static
19149 
             */
19150 
            public static function firstWhere($column, $operator = null, $value = null, $boolean = 'and')
19151 
            {
19152 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19153 
                                return $instance->firstWhere($column, $operator, $value, $boolean);
19154 
            }
19155 
 
19156 
                /**
19157 
             * Add an "or where" clause to the query.
19158 
             *
19159 
             * @param \Closure|array|string|\Illuminate\Database\Query\Expression $column
19160 
             * @param mixed $operator
19161 
             * @param mixed $value
19162 
             * @return \Illuminate\Database\Eloquent\Builder|static
19163 
             * @static
19164 
             */
19165 
            public static function orWhere($column, $operator = null, $value = null)
19166 
            {
19167 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19168 
                                return $instance->orWhere($column, $operator, $value);
19169 
            }
19170 
 
19171 
                /**
19172 
             * Add a basic "where not" clause to the query.
19173 
             *
19174 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
19175 
             * @param mixed $operator
19176 
             * @param mixed $value
19177 
             * @param string $boolean
19178 
             * @return \Illuminate\Database\Eloquent\Builder|static
19179 
             * @static
19180 
             */
19181 
            public static function whereNot($column, $operator = null, $value = null, $boolean = 'and')
19182 
            {
19183 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19184 
                                return $instance->whereNot($column, $operator, $value, $boolean);
19185 
            }
19186 
 
19187 
                /**
19188 
             * Add an "or where not" clause to the query.
19189 
             *
19190 
             * @param \Closure|array|string|\Illuminate\Database\Query\Expression $column
19191 
             * @param mixed $operator
19192 
             * @param mixed $value
19193 
             * @return \Illuminate\Database\Eloquent\Builder|static
19194 
             * @static
19195 
             */
19196 
            public static function orWhereNot($column, $operator = null, $value = null)
19197 
            {
19198 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19199 
                                return $instance->orWhereNot($column, $operator, $value);
19200 
            }
19201 
 
19202 
                /**
19203 
             * Add an "order by" clause for a timestamp to the query.
19204 
             *
19205 
             * @param string|\Illuminate\Database\Query\Expression $column
19206 
             * @return \Illuminate\Database\Eloquent\Builder|static
19207 
             * @static
19208 
             */
19209 
            public static function latest($column = null)
19210 
            {
19211 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19212 
                                return $instance->latest($column);
19213 
            }
19214 
 
19215 
                /**
19216 
             * Add an "order by" clause for a timestamp to the query.
19217 
             *
19218 
             * @param string|\Illuminate\Database\Query\Expression $column
19219 
             * @return \Illuminate\Database\Eloquent\Builder|static
19220 
             * @static
19221 
             */
19222 
            public static function oldest($column = null)
19223 
            {
19224 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19225 
                                return $instance->oldest($column);
19226 
            }
19227 
 
19228 
                /**
19229 
             * Create a collection of models from plain arrays.
19230 
             *
19231 
             * @param array $items
19232 
             * @return \Illuminate\Database\Eloquent\Collection
19233 
             * @static
19234 
             */
19235 
            public static function hydrate($items)
19236 
            {
19237 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19238 
                                return $instance->hydrate($items);
19239 
            }
19240 
 
19241 
                /**
19242 
             * Create a collection of models from a raw query.
19243 
             *
19244 
             * @param string $query
19245 
             * @param array $bindings
19246 
             * @return \Illuminate\Database\Eloquent\Collection
19247 
             * @static
19248 
             */
19249 
            public static function fromQuery($query, $bindings = [])
19250 
            {
19251 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19252 
                                return $instance->fromQuery($query, $bindings);
19253 
            }
19254 
 
19255 
                /**
19256 
             * Find a model by its primary key.
19257 
             *
19258 
             * @param mixed $id
19259 
             * @param array|string $columns
19260 
             * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static[]|static|null
19261 
             * @static
19262 
             */
19263 
            public static function find($id, $columns = [])
19264 
            {
19265 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19266 
                                return $instance->find($id, $columns);
19267 
            }
19268 
 
19269 
                /**
19270 
             * Find multiple models by their primary keys.
19271 
             *
19272 
             * @param \Illuminate\Contracts\Support\Arrayable|array $ids
19273 
             * @param array|string $columns
19274 
             * @return \Illuminate\Database\Eloquent\Collection
19275 
             * @static
19276 
             */
19277 
            public static function findMany($ids, $columns = [])
19278 
            {
19279 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19280 
                                return $instance->findMany($ids, $columns);
19281 
            }
19282 
 
19283 
                /**
19284 
             * Find a model by its primary key or throw an exception.
19285 
             *
19286 
             * @param mixed $id
19287 
             * @param array|string $columns
19288 
             * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static|static[]
19289 
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
19290 
             * @static
19291 
             */
19292 
            public static function findOrFail($id, $columns = [])
19293 
            {
19294 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19295 
                                return $instance->findOrFail($id, $columns);
19296 
            }
19297 
 
19298 
                /**
19299 
             * Find a model by its primary key or return fresh model instance.
19300 
             *
19301 
             * @param mixed $id
19302 
             * @param array|string $columns
19303 
             * @return \Illuminate\Database\Eloquent\Model|static
19304 
             * @static
19305 
             */
19306 
            public static function findOrNew($id, $columns = [])
19307 
            {
19308 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19309 
                                return $instance->findOrNew($id, $columns);
19310 
            }
19311 
 
19312 
                /**
19313 
             * Find a model by its primary key or call a callback.
19314 
             *
19315 
             * @param mixed $id
19316 
             * @param \Closure|array|string $columns
19317 
             * @param \Closure|null $callback
19318 
             * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static[]|static|mixed
19319 
             * @static
19320 
             */
19321 
            public static function findOr($id, $columns = [], $callback = null)
19322 
            {
19323 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19324 
                                return $instance->findOr($id, $columns, $callback);
19325 
            }
19326 
 
19327 
                /**
19328 
             * Get the first record matching the attributes or instantiate it.
19329 
             *
19330 
             * @param array $attributes
19331 
             * @param array $values
19332 
             * @return \Illuminate\Database\Eloquent\Model|static
19333 
             * @static
19334 
             */
19335 
            public static function firstOrNew($attributes = [], $values = [])
19336 
            {
19337 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19338 
                                return $instance->firstOrNew($attributes, $values);
19339 
            }
19340 
 
19341 
                /**
19342 
             * Get the first record matching the attributes or create it.
19343 
             *
19344 
             * @param array $attributes
19345 
             * @param array $values
19346 
             * @return \Illuminate\Database\Eloquent\Model|static
19347 
             * @static
19348 
             */
19349 
            public static function firstOrCreate($attributes = [], $values = [])
19350 
            {
19351 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19352 
                                return $instance->firstOrCreate($attributes, $values);
19353 
            }
19354 
 
19355 
                /**
19356 
             * Create or update a record matching the attributes, and fill it with values.
19357 
             *
19358 
             * @param array $attributes
19359 
             * @param array $values
19360 
             * @return \Illuminate\Database\Eloquent\Model|static
19361 
             * @static
19362 
             */
19363 
            public static function updateOrCreate($attributes, $values = [])
19364 
            {
19365 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19366 
                                return $instance->updateOrCreate($attributes, $values);
19367 
            }
19368 
 
19369 
                /**
19370 
             * Execute the query and get the first result or throw an exception.
19371 
             *
19372 
             * @param array|string $columns
19373 
             * @return \Illuminate\Database\Eloquent\Model|static
19374 
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
19375 
             * @static
19376 
             */
19377 
            public static function firstOrFail($columns = [])
19378 
            {
19379 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19380 
                                return $instance->firstOrFail($columns);
19381 
            }
19382 
 
19383 
                /**
19384 
             * Execute the query and get the first result or call a callback.
19385 
             *
19386 
             * @param \Closure|array|string $columns
19387 
             * @param \Closure|null $callback
19388 
             * @return \Illuminate\Database\Eloquent\Model|static|mixed
19389 
             * @static
19390 
             */
19391 
            public static function firstOr($columns = [], $callback = null)
19392 
            {
19393 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19394 
                                return $instance->firstOr($columns, $callback);
19395 
            }
19396 
 
19397 
                /**
19398 
             * Execute the query and get the first result if it's the sole matching record.
19399 
             *
19400 
             * @param array|string $columns
19401 
             * @return \Illuminate\Database\Eloquent\Model
19402 
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
19403 
             * @throws \Illuminate\Database\MultipleRecordsFoundException
19404 
             * @static
19405 
             */
19406 
            public static function sole($columns = [])
19407 
            {
19408 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19409 
                                return $instance->sole($columns);
19410 
            }
19411 
 
19412 
                /**
19413 
             * Get a single column's value from the first result of a query.
19414 
             *
19415 
             * @param string|\Illuminate\Database\Query\Expression $column
19416 
             * @return mixed
19417 
             * @static
19418 
             */
19419 
            public static function value($column)
19420 
            {
19421 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19422 
                                return $instance->value($column);
19423 
            }
19424 
 
19425 
                /**
19426 
             * Get a single column's value from the first result of a query if it's the sole matching record.
19427 
             *
19428 
             * @param string|\Illuminate\Database\Query\Expression $column
19429 
             * @return mixed
19430 
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
19431 
             * @throws \Illuminate\Database\MultipleRecordsFoundException
19432 
             * @static
19433 
             */
19434 
            public static function soleValue($column)
19435 
            {
19436 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19437 
                                return $instance->soleValue($column);
19438 
            }
19439 
 
19440 
                /**
19441 
             * Get a single column's value from the first result of the query or throw an exception.
19442 
             *
19443 
             * @param string|\Illuminate\Database\Query\Expression $column
19444 
             * @return mixed
19445 
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
19446 
             * @static
19447 
             */
19448 
            public static function valueOrFail($column)
19449 
            {
19450 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19451 
                                return $instance->valueOrFail($column);
19452 
            }
19453 
 
19454 
                /**
19455 
             * Execute the query as a "select" statement.
19456 
             *
19457 
             * @param array|string $columns
19458 
             * @return \Illuminate\Database\Eloquent\Collection|static[]
19459 
             * @static
19460 
             */
19461 
            public static function get($columns = [])
19462 
            {
19463 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19464 
                                return $instance->get($columns);
19465 
            }
19466 
 
19467 
                /**
19468 
             * Get the hydrated models without eager loading.
19469 
             *
19470 
             * @param array|string $columns
19471 
             * @return \Illuminate\Database\Eloquent\Model[]|static[]
19472 
             * @static
19473 
             */
19474 
            public static function getModels($columns = [])
19475 
            {
19476 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19477 
                                return $instance->getModels($columns);
19478 
            }
19479 
 
19480 
                /**
19481 
             * Eager load the relationships for the models.
19482 
             *
19483 
             * @param array $models
19484 
             * @return array
19485 
             * @static
19486 
             */
19487 
            public static function eagerLoadRelations($models)
19488 
            {
19489 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19490 
                                return $instance->eagerLoadRelations($models);
19491 
            }
19492 
 
19493 
                /**
19494 
             * Get a lazy collection for the given query.
19495 
             *
19496 
             * @return \Illuminate\Support\LazyCollection
19497 
             * @static
19498 
             */
19499 
            public static function cursor()
19500 
            {
19501 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19502 
                                return $instance->cursor();
19503 
            }
19504 
 
19505 
                /**
19506 
             * Get a collection with the values of a given column.
19507 
             *
19508 
             * @param string|\Illuminate\Database\Query\Expression $column
19509 
             * @param string|null $key
19510 
             * @return \Illuminate\Support\Collection
19511 
             * @static
19512 
             */
19513 
            public static function pluck($column, $key = null)
19514 
            {
19515 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19516 
                                return $instance->pluck($column, $key);
19517 
            }
19518 
 
19519 
                /**
19520 
             * Paginate the given query.
19521 
             *
19522 
             * @param int|null|\Closure $perPage
19523 
             * @param array|string $columns
19524 
             * @param string $pageName
19525 
             * @param int|null $page
19526 
             * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator
19527 
             * @throws \InvalidArgumentException
19528 
             * @static
19529 
             */
19530 
            public static function paginate($perPage = null, $columns = [], $pageName = 'page', $page = null)
19531 
            {
19532 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19533 
                                return $instance->paginate($perPage, $columns, $pageName, $page);
19534 
            }
19535 
 
19536 
                /**
19537 
             * Paginate the given query into a simple paginator.
19538 
             *
19539 
             * @param int|null $perPage
19540 
             * @param array|string $columns
19541 
             * @param string $pageName
19542 
             * @param int|null $page
19543 
             * @return \Illuminate\Contracts\Pagination\Paginator
19544 
             * @static
19545 
             */
19546 
            public static function simplePaginate($perPage = null, $columns = [], $pageName = 'page', $page = null)
19547 
            {
19548 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19549 
                                return $instance->simplePaginate($perPage, $columns, $pageName, $page);
19550 
            }
19551 
 
19552 
                /**
19553 
             * Paginate the given query into a cursor paginator.
19554 
             *
19555 
             * @param int|null $perPage
19556 
             * @param array|string $columns
19557 
             * @param string $cursorName
19558 
             * @param \Illuminate\Pagination\Cursor|string|null $cursor
19559 
             * @return \Illuminate\Contracts\Pagination\CursorPaginator
19560 
             * @static
19561 
             */
19562 
            public static function cursorPaginate($perPage = null, $columns = [], $cursorName = 'cursor', $cursor = null)
19563 
            {
19564 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19565 
                                return $instance->cursorPaginate($perPage, $columns, $cursorName, $cursor);
19566 
            }
19567 
 
19568 
                /**
19569 
             * Save a new model and return the instance.
19570 
             *
19571 
             * @param array $attributes
19572 
             * @return \Illuminate\Database\Eloquent\Model|$this
19573 
             * @static
19574 
             */
19575 
            public static function create($attributes = [])
19576 
            {
19577 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19578 
                                return $instance->create($attributes);
19579 
            }
19580 
 
19581 
                /**
19582 
             * Save a new model and return the instance. Allow mass-assignment.
19583 
             *
19584 
             * @param array $attributes
19585 
             * @return \Illuminate\Database\Eloquent\Model|$this
19586 
             * @static
19587 
             */
19588 
            public static function forceCreate($attributes)
19589 
            {
19590 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19591 
                                return $instance->forceCreate($attributes);
19592 
            }
19593 
 
19594 
                /**
19595 
             * Insert new records or update the existing ones.
19596 
             *
19597 
             * @param array $values
19598 
             * @param array|string $uniqueBy
19599 
             * @param array|null $update
19600 
             * @return int
19601 
             * @static
19602 
             */
19603 
            public static function upsert($values, $uniqueBy, $update = null)
19604 
            {
19605 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19606 
                                return $instance->upsert($values, $uniqueBy, $update);
19607 
            }
19608 
 
19609 
                /**
19610 
             * Register a replacement for the default delete function.
19611 
             *
19612 
             * @param \Closure $callback
19613 
             * @return void
19614 
             * @static
19615 
             */
19616 
            public static function onDelete($callback)
19617 
            {
19618 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19619 
                                $instance->onDelete($callback);
19620 
            }
19621 
 
19622 
                /**
19623 
             * Call the given local model scopes.
19624 
             *
19625 
             * @param array|string $scopes
19626 
             * @return static|mixed
19627 
             * @static
19628 
             */
19629 
            public static function scopes($scopes)
19630 
            {
19631 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19632 
                                return $instance->scopes($scopes);
19633 
            }
19634 
 
19635 
                /**
19636 
             * Apply the scopes to the Eloquent builder instance and return it.
19637 
             *
19638 
             * @return static
19639 
             * @static
19640 
             */
19641 
            public static function applyScopes()
19642 
            {
19643 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19644 
                                return $instance->applyScopes();
19645 
            }
19646 
 
19647 
                /**
19648 
             * Prevent the specified relations from being eager loaded.
19649 
             *
19650 
             * @param mixed $relations
19651 
             * @return \Illuminate\Database\Eloquent\Builder|static
19652 
             * @static
19653 
             */
19654 
            public static function without($relations)
19655 
            {
19656 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19657 
                                return $instance->without($relations);
19658 
            }
19659 
 
19660 
                /**
19661 
             * Set the relationships that should be eager loaded while removing any previously added eager loading specifications.
19662 
             *
19663 
             * @param mixed $relations
19664 
             * @return \Illuminate\Database\Eloquent\Builder|static
19665 
             * @static
19666 
             */
19667 
            public static function withOnly($relations)
19668 
            {
19669 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19670 
                                return $instance->withOnly($relations);
19671 
            }
19672 
 
19673 
                /**
19674 
             * Create a new instance of the model being queried.
19675 
             *
19676 
             * @param array $attributes
19677 
             * @return \Illuminate\Database\Eloquent\Model|static
19678 
             * @static
19679 
             */
19680 
            public static function newModelInstance($attributes = [])
19681 
            {
19682 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19683 
                                return $instance->newModelInstance($attributes);
19684 
            }
19685 
 
19686 
                /**
19687 
             * Apply query-time casts to the model instance.
19688 
             *
19689 
             * @param array $casts
19690 
             * @return \Illuminate\Database\Eloquent\Builder|static
19691 
             * @static
19692 
             */
19693 
            public static function withCasts($casts)
19694 
            {
19695 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19696 
                                return $instance->withCasts($casts);
19697 
            }
19698 
 
19699 
                /**
19700 
             * Get the underlying query builder instance.
19701 
             *
19702 
             * @return \Illuminate\Database\Query\Builder
19703 
             * @static
19704 
             */
19705 
            public static function getQuery()
19706 
            {
19707 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19708 
                                return $instance->getQuery();
19709 
            }
19710 
 
19711 
                /**
19712 
             * Set the underlying query builder instance.
19713 
             *
19714 
             * @param \Illuminate\Database\Query\Builder $query
19715 
             * @return \Illuminate\Database\Eloquent\Builder|static
19716 
             * @static
19717 
             */
19718 
            public static function setQuery($query)
19719 
            {
19720 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19721 
                                return $instance->setQuery($query);
19722 
            }
19723 
 
19724 
                /**
19725 
             * Get a base query builder instance.
19726 
             *
19727 
             * @return \Illuminate\Database\Query\Builder
19728 
             * @static
19729 
             */
19730 
            public static function toBase()
19731 
            {
19732 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19733 
                                return $instance->toBase();
19734 
            }
19735 
 
19736 
                /**
19737 
             * Get the relationships being eagerly loaded.
19738 
             *
19739 
             * @return array
19740 
             * @static
19741 
             */
19742 
            public static function getEagerLoads()
19743 
            {
19744 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19745 
                                return $instance->getEagerLoads();
19746 
            }
19747 
 
19748 
                /**
19749 
             * Set the relationships being eagerly loaded.
19750 
             *
19751 
             * @param array $eagerLoad
19752 
             * @return \Illuminate\Database\Eloquent\Builder|static
19753 
             * @static
19754 
             */
19755 
            public static function setEagerLoads($eagerLoad)
19756 
            {
19757 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19758 
                                return $instance->setEagerLoads($eagerLoad);
19759 
            }
19760 
 
19761 
                /**
19762 
             * Indicate that the given relationships should not be eagerly loaded.
19763 
             *
19764 
             * @param array $relations
19765 
             * @return \Illuminate\Database\Eloquent\Builder|static
19766 
             * @static
19767 
             */
19768 
            public static function withoutEagerLoad($relations)
19769 
            {
19770 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19771 
                                return $instance->withoutEagerLoad($relations);
19772 
            }
19773 
 
19774 
                /**
19775 
             * Flush the relationships being eagerly loaded.
19776 
             *
19777 
             * @return \Illuminate\Database\Eloquent\Builder|static
19778 
             * @static
19779 
             */
19780 
            public static function withoutEagerLoads()
19781 
            {
19782 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19783 
                                return $instance->withoutEagerLoads();
19784 
            }
19785 
 
19786 
                /**
19787 
             * Get the model instance being queried.
19788 
             *
19789 
             * @return \Illuminate\Database\Eloquent\Model|static
19790 
             * @static
19791 
             */
19792 
            public static function getModel()
19793 
            {
19794 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19795 
                                return $instance->getModel();
19796 
            }
19797 
 
19798 
                /**
19799 
             * Set a model instance for the model being queried.
19800 
             *
19801 
             * @param \Illuminate\Database\Eloquent\Model $model
19802 
             * @return \Illuminate\Database\Eloquent\Builder|static
19803 
             * @static
19804 
             */
19805 
            public static function setModel($model)
19806 
            {
19807 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19808 
                                return $instance->setModel($model);
19809 
            }
19810 
 
19811 
                /**
19812 
             * Get the given macro by name.
19813 
             *
19814 
             * @param string $name
19815 
             * @return \Closure
19816 
             * @static
19817 
             */
19818 
            public static function getMacro($name)
19819 
            {
19820 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19821 
                                return $instance->getMacro($name);
19822 
            }
19823 
 
19824 
                /**
19825 
             * Checks if a macro is registered.
19826 
             *
19827 
             * @param string $name
19828 
             * @return bool
19829 
             * @static
19830 
             */
19831 
            public static function hasMacro($name)
19832 
            {
19833 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19834 
                                return $instance->hasMacro($name);
19835 
            }
19836 
 
19837 
                /**
19838 
             * Get the given global macro by name.
19839 
             *
19840 
             * @param string $name
19841 
             * @return \Closure
19842 
             * @static
19843 
             */
19844 
            public static function getGlobalMacro($name)
19845 
            {
19846 
                                return \Illuminate\Database\Eloquent\Builder::getGlobalMacro($name);
19847 
            }
19848 
 
19849 
                /**
19850 
             * Checks if a global macro is registered.
19851 
             *
19852 
             * @param string $name
19853 
             * @return bool
19854 
             * @static
19855 
             */
19856 
            public static function hasGlobalMacro($name)
19857 
            {
19858 
                                return \Illuminate\Database\Eloquent\Builder::hasGlobalMacro($name);
19859 
            }
19860 
 
19861 
                /**
19862 
             * Clone the Eloquent query builder.
19863 
             *
19864 
             * @return static
19865 
             * @static
19866 
             */
19867 
            public static function clone()
19868 
            {
19869 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19870 
                                return $instance->clone();
19871 
            }
19872 
 
19873 
                /**
19874 
             * Chunk the results of the query.
19875 
             *
19876 
             * @param int $count
19877 
             * @param callable $callback
19878 
             * @return bool
19879 
             * @static
19880 
             */
19881 
            public static function chunk($count, $callback)
19882 
            {
19883 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19884 
                                return $instance->chunk($count, $callback);
19885 
            }
19886 
 
19887 
                /**
19888 
             * Run a map over each item while chunking.
19889 
             *
19890 
             * @param callable $callback
19891 
             * @param int $count
19892 
             * @return \Illuminate\Support\Collection
19893 
             * @static
19894 
             */
19895 
            public static function chunkMap($callback, $count = 1000)
19896 
            {
19897 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19898 
                                return $instance->chunkMap($callback, $count);
19899 
            }
19900 
 
19901 
                /**
19902 
             * Execute a callback over each item while chunking.
19903 
             *
19904 
             * @param callable $callback
19905 
             * @param int $count
19906 
             * @return bool
19907 
             * @throws \RuntimeException
19908 
             * @static
19909 
             */
19910 
            public static function each($callback, $count = 1000)
19911 
            {
19912 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19913 
                                return $instance->each($callback, $count);
19914 
            }
19915 
 
19916 
                /**
19917 
             * Chunk the results of a query by comparing IDs.
19918 
             *
19919 
             * @param int $count
19920 
             * @param callable $callback
19921 
             * @param string|null $column
19922 
             * @param string|null $alias
19923 
             * @return bool
19924 
             * @static
19925 
             */
19926 
            public static function chunkById($count, $callback, $column = null, $alias = null)
19927 
            {
19928 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19929 
                                return $instance->chunkById($count, $callback, $column, $alias);
19930 
            }
19931 
 
19932 
                /**
19933 
             * Execute a callback over each item while chunking by ID.
19934 
             *
19935 
             * @param callable $callback
19936 
             * @param int $count
19937 
             * @param string|null $column
19938 
             * @param string|null $alias
19939 
             * @return bool
19940 
             * @static
19941 
             */
19942 
            public static function eachById($callback, $count = 1000, $column = null, $alias = null)
19943 
            {
19944 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19945 
                                return $instance->eachById($callback, $count, $column, $alias);
19946 
            }
19947 
 
19948 
                /**
19949 
             * Query lazily, by chunks of the given size.
19950 
             *
19951 
             * @param int $chunkSize
19952 
             * @return \Illuminate\Support\LazyCollection
19953 
             * @throws \InvalidArgumentException
19954 
             * @static
19955 
             */
19956 
            public static function lazy($chunkSize = 1000)
19957 
            {
19958 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19959 
                                return $instance->lazy($chunkSize);
19960 
            }
19961 
 
19962 
                /**
19963 
             * Query lazily, by chunking the results of a query by comparing IDs.
19964 
             *
19965 
             * @param int $chunkSize
19966 
             * @param string|null $column
19967 
             * @param string|null $alias
19968 
             * @return \Illuminate\Support\LazyCollection
19969 
             * @throws \InvalidArgumentException
19970 
             * @static
19971 
             */
19972 
            public static function lazyById($chunkSize = 1000, $column = null, $alias = null)
19973 
            {
19974 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19975 
                                return $instance->lazyById($chunkSize, $column, $alias);
19976 
            }
19977 
 
19978 
                /**
19979 
             * Query lazily, by chunking the results of a query by comparing IDs in descending order.
19980 
             *
19981 
             * @param int $chunkSize
19982 
             * @param string|null $column
19983 
             * @param string|null $alias
19984 
             * @return \Illuminate\Support\LazyCollection
19985 
             * @throws \InvalidArgumentException
19986 
             * @static
19987 
             */
19988 
            public static function lazyByIdDesc($chunkSize = 1000, $column = null, $alias = null)
19989 
            {
19990 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
19991 
                                return $instance->lazyByIdDesc($chunkSize, $column, $alias);
19992 
            }
19993 
 
19994 
                /**
19995 
             * Execute the query and get the first result.
19996 
             *
19997 
             * @param array|string $columns
19998 
             * @return \Illuminate\Database\Eloquent\Model|object|static|null
19999 
             * @static
20000 
             */
20001 
            public static function first($columns = [])
20002 
            {
20003 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20004 
                                return $instance->first($columns);
20005 
            }
20006 
 
20007 
                /**
20008 
             * Execute the query and get the first result if it's the sole matching record.
20009 
             *
20010 
             * @param array|string $columns
20011 
             * @return \Illuminate\Database\Eloquent\Model|object|static|null
20012 
             * @throws \Illuminate\Database\RecordsNotFoundException
20013 
             * @throws \Illuminate\Database\MultipleRecordsFoundException
20014 
             * @static
20015 
             */
20016 
            public static function baseSole($columns = [])
20017 
            {
20018 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20019 
                                return $instance->baseSole($columns);
20020 
            }
20021 
 
20022 
                /**
20023 
             * Pass the query to a given callback.
20024 
             *
20025 
             * @param callable $callback
20026 
             * @return \Illuminate\Database\Eloquent\Builder|static
20027 
             * @static
20028 
             */
20029 
            public static function tap($callback)
20030 
            {
20031 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20032 
                                return $instance->tap($callback);
20033 
            }
20034 
 
20035 
                /**
20036 
             * Apply the callback if the given "value" is (or resolves to) truthy.
20037 
             *
20038 
             * @template TWhenParameter
20039 
             * @template TWhenReturnType
20040 
             * @param \Illuminate\Database\Eloquent\(\Closure($this):  TWhenParameter)|TWhenParameter|null  $value
20041 
             * @param \Illuminate\Database\Eloquent\(callable($this,  TWhenParameter): TWhenReturnType)|null  $callback
20042 
             * @param \Illuminate\Database\Eloquent\(callable($this,  TWhenParameter): TWhenReturnType)|null  $default
20043 
             * @return $this|\Illuminate\Database\Eloquent\TWhenReturnType
20044 
             * @static
20045 
             */
20046 
            public static function when($value = null, $callback = null, $default = null)
20047 
            {
20048 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20049 
                                return $instance->when($value, $callback, $default);
20050 
            }
20051 
 
20052 
                /**
20053 
             * Apply the callback if the given "value" is (or resolves to) falsy.
20054 
             *
20055 
             * @template TUnlessParameter
20056 
             * @template TUnlessReturnType
20057 
             * @param \Illuminate\Database\Eloquent\(\Closure($this):  TUnlessParameter)|TUnlessParameter|null  $value
20058 
             * @param \Illuminate\Database\Eloquent\(callable($this,  TUnlessParameter): TUnlessReturnType)|null  $callback
20059 
             * @param \Illuminate\Database\Eloquent\(callable($this,  TUnlessParameter): TUnlessReturnType)|null  $default
20060 
             * @return $this|\Illuminate\Database\Eloquent\TUnlessReturnType
20061 
             * @static
20062 
             */
20063 
            public static function unless($value = null, $callback = null, $default = null)
20064 
            {
20065 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20066 
                                return $instance->unless($value, $callback, $default);
20067 
            }
20068 
 
20069 
                /**
20070 
             * Add a relationship count / exists condition to the query.
20071 
             *
20072 
             * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation
20073 
             * @param string $operator
20074 
             * @param int $count
20075 
             * @param string $boolean
20076 
             * @param \Closure|null $callback
20077 
             * @return \Illuminate\Database\Eloquent\Builder|static
20078 
             * @throws \RuntimeException
20079 
             * @static
20080 
             */
20081 
            public static function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
20082 
            {
20083 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20084 
                                return $instance->has($relation, $operator, $count, $boolean, $callback);
20085 
            }
20086 
 
20087 
                /**
20088 
             * Add a relationship count / exists condition to the query with an "or".
20089 
             *
20090 
             * @param string $relation
20091 
             * @param string $operator
20092 
             * @param int $count
20093 
             * @return \Illuminate\Database\Eloquent\Builder|static
20094 
             * @static
20095 
             */
20096 
            public static function orHas($relation, $operator = '>=', $count = 1)
20097 
            {
20098 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20099 
                                return $instance->orHas($relation, $operator, $count);
20100 
            }
20101 
 
20102 
                /**
20103 
             * Add a relationship count / exists condition to the query.
20104 
             *
20105 
             * @param string $relation
20106 
             * @param string $boolean
20107 
             * @param \Closure|null $callback
20108 
             * @return \Illuminate\Database\Eloquent\Builder|static
20109 
             * @static
20110 
             */
20111 
            public static function doesntHave($relation, $boolean = 'and', $callback = null)
20112 
            {
20113 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20114 
                                return $instance->doesntHave($relation, $boolean, $callback);
20115 
            }
20116 
 
20117 
                /**
20118 
             * Add a relationship count / exists condition to the query with an "or".
20119 
             *
20120 
             * @param string $relation
20121 
             * @return \Illuminate\Database\Eloquent\Builder|static
20122 
             * @static
20123 
             */
20124 
            public static function orDoesntHave($relation)
20125 
            {
20126 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20127 
                                return $instance->orDoesntHave($relation);
20128 
            }
20129 
 
20130 
                /**
20131 
             * Add a relationship count / exists condition to the query with where clauses.
20132 
             *
20133 
             * @param string $relation
20134 
             * @param \Closure|null $callback
20135 
             * @param string $operator
20136 
             * @param int $count
20137 
             * @return \Illuminate\Database\Eloquent\Builder|static
20138 
             * @static
20139 
             */
20140 
            public static function whereHas($relation, $callback = null, $operator = '>=', $count = 1)
20141 
            {
20142 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20143 
                                return $instance->whereHas($relation, $callback, $operator, $count);
20144 
            }
20145 
 
20146 
                /**
20147 
             * Add a relationship count / exists condition to the query with where clauses.
20148 
             *
20149 
             * Also load the relationship with same condition.
20150 
             *
20151 
             * @param string $relation
20152 
             * @param \Closure|null $callback
20153 
             * @param string $operator
20154 
             * @param int $count
20155 
             * @return \Illuminate\Database\Eloquent\Builder|static
20156 
             * @static
20157 
             */
20158 
            public static function withWhereHas($relation, $callback = null, $operator = '>=', $count = 1)
20159 
            {
20160 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20161 
                                return $instance->withWhereHas($relation, $callback, $operator, $count);
20162 
            }
20163 
 
20164 
                /**
20165 
             * Add a relationship count / exists condition to the query with where clauses and an "or".
20166 
             *
20167 
             * @param string $relation
20168 
             * @param \Closure|null $callback
20169 
             * @param string $operator
20170 
             * @param int $count
20171 
             * @return \Illuminate\Database\Eloquent\Builder|static
20172 
             * @static
20173 
             */
20174 
            public static function orWhereHas($relation, $callback = null, $operator = '>=', $count = 1)
20175 
            {
20176 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20177 
                                return $instance->orWhereHas($relation, $callback, $operator, $count);
20178 
            }
20179 
 
20180 
                /**
20181 
             * Add a relationship count / exists condition to the query with where clauses.
20182 
             *
20183 
             * @param string $relation
20184 
             * @param \Closure|null $callback
20185 
             * @return \Illuminate\Database\Eloquent\Builder|static
20186 
             * @static
20187 
             */
20188 
            public static function whereDoesntHave($relation, $callback = null)
20189 
            {
20190 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20191 
                                return $instance->whereDoesntHave($relation, $callback);
20192 
            }
20193 
 
20194 
                /**
20195 
             * Add a relationship count / exists condition to the query with where clauses and an "or".
20196 
             *
20197 
             * @param string $relation
20198 
             * @param \Closure|null $callback
20199 
             * @return \Illuminate\Database\Eloquent\Builder|static
20200 
             * @static
20201 
             */
20202 
            public static function orWhereDoesntHave($relation, $callback = null)
20203 
            {
20204 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20205 
                                return $instance->orWhereDoesntHave($relation, $callback);
20206 
            }
20207 
 
20208 
                /**
20209 
             * Add a polymorphic relationship count / exists condition to the query.
20210 
             *
20211 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20212 
             * @param string|array $types
20213 
             * @param string $operator
20214 
             * @param int $count
20215 
             * @param string $boolean
20216 
             * @param \Closure|null $callback
20217 
             * @return \Illuminate\Database\Eloquent\Builder|static
20218 
             * @static
20219 
             */
20220 
            public static function hasMorph($relation, $types, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
20221 
            {
20222 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20223 
                                return $instance->hasMorph($relation, $types, $operator, $count, $boolean, $callback);
20224 
            }
20225 
 
20226 
                /**
20227 
             * Add a polymorphic relationship count / exists condition to the query with an "or".
20228 
             *
20229 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20230 
             * @param string|array $types
20231 
             * @param string $operator
20232 
             * @param int $count
20233 
             * @return \Illuminate\Database\Eloquent\Builder|static
20234 
             * @static
20235 
             */
20236 
            public static function orHasMorph($relation, $types, $operator = '>=', $count = 1)
20237 
            {
20238 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20239 
                                return $instance->orHasMorph($relation, $types, $operator, $count);
20240 
            }
20241 
 
20242 
                /**
20243 
             * Add a polymorphic relationship count / exists condition to the query.
20244 
             *
20245 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20246 
             * @param string|array $types
20247 
             * @param string $boolean
20248 
             * @param \Closure|null $callback
20249 
             * @return \Illuminate\Database\Eloquent\Builder|static
20250 
             * @static
20251 
             */
20252 
            public static function doesntHaveMorph($relation, $types, $boolean = 'and', $callback = null)
20253 
            {
20254 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20255 
                                return $instance->doesntHaveMorph($relation, $types, $boolean, $callback);
20256 
            }
20257 
 
20258 
                /**
20259 
             * Add a polymorphic relationship count / exists condition to the query with an "or".
20260 
             *
20261 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20262 
             * @param string|array $types
20263 
             * @return \Illuminate\Database\Eloquent\Builder|static
20264 
             * @static
20265 
             */
20266 
            public static function orDoesntHaveMorph($relation, $types)
20267 
            {
20268 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20269 
                                return $instance->orDoesntHaveMorph($relation, $types);
20270 
            }
20271 
 
20272 
                /**
20273 
             * Add a polymorphic relationship count / exists condition to the query with where clauses.
20274 
             *
20275 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20276 
             * @param string|array $types
20277 
             * @param \Closure|null $callback
20278 
             * @param string $operator
20279 
             * @param int $count
20280 
             * @return \Illuminate\Database\Eloquent\Builder|static
20281 
             * @static
20282 
             */
20283 
            public static function whereHasMorph($relation, $types, $callback = null, $operator = '>=', $count = 1)
20284 
            {
20285 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20286 
                                return $instance->whereHasMorph($relation, $types, $callback, $operator, $count);
20287 
            }
20288 
 
20289 
                /**
20290 
             * Add a polymorphic relationship count / exists condition to the query with where clauses and an "or".
20291 
             *
20292 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20293 
             * @param string|array $types
20294 
             * @param \Closure|null $callback
20295 
             * @param string $operator
20296 
             * @param int $count
20297 
             * @return \Illuminate\Database\Eloquent\Builder|static
20298 
             * @static
20299 
             */
20300 
            public static function orWhereHasMorph($relation, $types, $callback = null, $operator = '>=', $count = 1)
20301 
            {
20302 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20303 
                                return $instance->orWhereHasMorph($relation, $types, $callback, $operator, $count);
20304 
            }
20305 
 
20306 
                /**
20307 
             * Add a polymorphic relationship count / exists condition to the query with where clauses.
20308 
             *
20309 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20310 
             * @param string|array $types
20311 
             * @param \Closure|null $callback
20312 
             * @return \Illuminate\Database\Eloquent\Builder|static
20313 
             * @static
20314 
             */
20315 
            public static function whereDoesntHaveMorph($relation, $types, $callback = null)
20316 
            {
20317 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20318 
                                return $instance->whereDoesntHaveMorph($relation, $types, $callback);
20319 
            }
20320 
 
20321 
                /**
20322 
             * Add a polymorphic relationship count / exists condition to the query with where clauses and an "or".
20323 
             *
20324 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20325 
             * @param string|array $types
20326 
             * @param \Closure|null $callback
20327 
             * @return \Illuminate\Database\Eloquent\Builder|static
20328 
             * @static
20329 
             */
20330 
            public static function orWhereDoesntHaveMorph($relation, $types, $callback = null)
20331 
            {
20332 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20333 
                                return $instance->orWhereDoesntHaveMorph($relation, $types, $callback);
20334 
            }
20335 
 
20336 
                /**
20337 
             * Add a basic where clause to a relationship query.
20338 
             *
20339 
             * @param string $relation
20340 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
20341 
             * @param mixed $operator
20342 
             * @param mixed $value
20343 
             * @return \Illuminate\Database\Eloquent\Builder|static
20344 
             * @static
20345 
             */
20346 
            public static function whereRelation($relation, $column, $operator = null, $value = null)
20347 
            {
20348 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20349 
                                return $instance->whereRelation($relation, $column, $operator, $value);
20350 
            }
20351 
 
20352 
                /**
20353 
             * Add an "or where" clause to a relationship query.
20354 
             *
20355 
             * @param string $relation
20356 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
20357 
             * @param mixed $operator
20358 
             * @param mixed $value
20359 
             * @return \Illuminate\Database\Eloquent\Builder|static
20360 
             * @static
20361 
             */
20362 
            public static function orWhereRelation($relation, $column, $operator = null, $value = null)
20363 
            {
20364 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20365 
                                return $instance->orWhereRelation($relation, $column, $operator, $value);
20366 
            }
20367 
 
20368 
                /**
20369 
             * Add a polymorphic relationship condition to the query with a where clause.
20370 
             *
20371 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20372 
             * @param string|array $types
20373 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
20374 
             * @param mixed $operator
20375 
             * @param mixed $value
20376 
             * @return \Illuminate\Database\Eloquent\Builder|static
20377 
             * @static
20378 
             */
20379 
            public static function whereMorphRelation($relation, $types, $column, $operator = null, $value = null)
20380 
            {
20381 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20382 
                                return $instance->whereMorphRelation($relation, $types, $column, $operator, $value);
20383 
            }
20384 
 
20385 
                /**
20386 
             * Add a polymorphic relationship condition to the query with an "or where" clause.
20387 
             *
20388 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20389 
             * @param string|array $types
20390 
             * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
20391 
             * @param mixed $operator
20392 
             * @param mixed $value
20393 
             * @return \Illuminate\Database\Eloquent\Builder|static
20394 
             * @static
20395 
             */
20396 
            public static function orWhereMorphRelation($relation, $types, $column, $operator = null, $value = null)
20397 
            {
20398 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20399 
                                return $instance->orWhereMorphRelation($relation, $types, $column, $operator, $value);
20400 
            }
20401 
 
20402 
                /**
20403 
             * Add a morph-to relationship condition to the query.
20404 
             *
20405 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20406 
             * @param \Illuminate\Database\Eloquent\Model|string $model
20407 
             * @return \Illuminate\Database\Eloquent\Builder|static
20408 
             * @static
20409 
             */
20410 
            public static function whereMorphedTo($relation, $model, $boolean = 'and')
20411 
            {
20412 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20413 
                                return $instance->whereMorphedTo($relation, $model, $boolean);
20414 
            }
20415 
 
20416 
                /**
20417 
             * Add a not morph-to relationship condition to the query.
20418 
             *
20419 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20420 
             * @param \Illuminate\Database\Eloquent\Model|string $model
20421 
             * @return \Illuminate\Database\Eloquent\Builder|static
20422 
             * @static
20423 
             */
20424 
            public static function whereNotMorphedTo($relation, $model, $boolean = 'and')
20425 
            {
20426 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20427 
                                return $instance->whereNotMorphedTo($relation, $model, $boolean);
20428 
            }
20429 
 
20430 
                /**
20431 
             * Add a morph-to relationship condition to the query with an "or where" clause.
20432 
             *
20433 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20434 
             * @param \Illuminate\Database\Eloquent\Model|string $model
20435 
             * @return \Illuminate\Database\Eloquent\Builder|static
20436 
             * @static
20437 
             */
20438 
            public static function orWhereMorphedTo($relation, $model)
20439 
            {
20440 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20441 
                                return $instance->orWhereMorphedTo($relation, $model);
20442 
            }
20443 
 
20444 
                /**
20445 
             * Add a not morph-to relationship condition to the query with an "or where" clause.
20446 
             *
20447 
             * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20448 
             * @param \Illuminate\Database\Eloquent\Model|string $model
20449 
             * @return \Illuminate\Database\Eloquent\Builder|static
20450 
             * @static
20451 
             */
20452 
            public static function orWhereNotMorphedTo($relation, $model)
20453 
            {
20454 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20455 
                                return $instance->orWhereNotMorphedTo($relation, $model);
20456 
            }
20457 
 
20458 
                /**
20459 
             * Add a "belongs to" relationship where clause to the query.
20460 
             *
20461 
             * @param \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection<\Illuminate\Database\Eloquent\Model> $related
20462 
             * @param string|null $relationshipName
20463 
             * @param string $boolean
20464 
             * @return \Illuminate\Database\Eloquent\Builder|static
20465 
             * @throws \Illuminate\Database\Eloquent\RelationNotFoundException
20466 
             * @static
20467 
             */
20468 
            public static function whereBelongsTo($related, $relationshipName = null, $boolean = 'and')
20469 
            {
20470 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20471 
                                return $instance->whereBelongsTo($related, $relationshipName, $boolean);
20472 
            }
20473 
 
20474 
                /**
20475 
             * Add an "BelongsTo" relationship with an "or where" clause to the query.
20476 
             *
20477 
             * @param \Illuminate\Database\Eloquent\Model $related
20478 
             * @param string|null $relationshipName
20479 
             * @return \Illuminate\Database\Eloquent\Builder|static
20480 
             * @throws \RuntimeException
20481 
             * @static
20482 
             */
20483 
            public static function orWhereBelongsTo($related, $relationshipName = null)
20484 
            {
20485 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20486 
                                return $instance->orWhereBelongsTo($related, $relationshipName);
20487 
            }
20488 
 
20489 
                /**
20490 
             * Add subselect queries to include an aggregate value for a relationship.
20491 
             *
20492 
             * @param mixed $relations
20493 
             * @param string $column
20494 
             * @param string $function
20495 
             * @return \Illuminate\Database\Eloquent\Builder|static
20496 
             * @static
20497 
             */
20498 
            public static function withAggregate($relations, $column, $function = null)
20499 
            {
20500 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20501 
                                return $instance->withAggregate($relations, $column, $function);
20502 
            }
20503 
 
20504 
                /**
20505 
             * Add subselect queries to count the relations.
20506 
             *
20507 
             * @param mixed $relations
20508 
             * @return \Illuminate\Database\Eloquent\Builder|static
20509 
             * @static
20510 
             */
20511 
            public static function withCount($relations)
20512 
            {
20513 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20514 
                                return $instance->withCount($relations);
20515 
            }
20516 
 
20517 
                /**
20518 
             * Add subselect queries to include the max of the relation's column.
20519 
             *
20520 
             * @param string|array $relation
20521 
             * @param string $column
20522 
             * @return \Illuminate\Database\Eloquent\Builder|static
20523 
             * @static
20524 
             */
20525 
            public static function withMax($relation, $column)
20526 
            {
20527 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20528 
                                return $instance->withMax($relation, $column);
20529 
            }
20530 
 
20531 
                /**
20532 
             * Add subselect queries to include the min of the relation's column.
20533 
             *
20534 
             * @param string|array $relation
20535 
             * @param string $column
20536 
             * @return \Illuminate\Database\Eloquent\Builder|static
20537 
             * @static
20538 
             */
20539 
            public static function withMin($relation, $column)
20540 
            {
20541 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20542 
                                return $instance->withMin($relation, $column);
20543 
            }
20544 
 
20545 
                /**
20546 
             * Add subselect queries to include the sum of the relation's column.
20547 
             *
20548 
             * @param string|array $relation
20549 
             * @param string $column
20550 
             * @return \Illuminate\Database\Eloquent\Builder|static
20551 
             * @static
20552 
             */
20553 
            public static function withSum($relation, $column)
20554 
            {
20555 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20556 
                                return $instance->withSum($relation, $column);
20557 
            }
20558 
 
20559 
                /**
20560 
             * Add subselect queries to include the average of the relation's column.
20561 
             *
20562 
             * @param string|array $relation
20563 
             * @param string $column
20564 
             * @return \Illuminate\Database\Eloquent\Builder|static
20565 
             * @static
20566 
             */
20567 
            public static function withAvg($relation, $column)
20568 
            {
20569 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20570 
                                return $instance->withAvg($relation, $column);
20571 
            }
20572 
 
20573 
                /**
20574 
             * Add subselect queries to include the existence of related models.
20575 
             *
20576 
             * @param string|array $relation
20577 
             * @return \Illuminate\Database\Eloquent\Builder|static
20578 
             * @static
20579 
             */
20580 
            public static function withExists($relation)
20581 
            {
20582 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20583 
                                return $instance->withExists($relation);
20584 
            }
20585 
 
20586 
                /**
20587 
             * Merge the where constraints from another query to the current query.
20588 
             *
20589 
             * @param \Illuminate\Database\Eloquent\Builder $from
20590 
             * @return \Illuminate\Database\Eloquent\Builder|static
20591 
             * @static
20592 
             */
20593 
            public static function mergeConstraintsFrom($from)
20594 
            {
20595 
                                /** @var \Illuminate\Database\Eloquent\Builder $instance */
20596 
                                return $instance->mergeConstraintsFrom($from);
20597 
            }
20598 
 
20599 
                /**
20600 
             * Set the columns to be selected.
20601 
             *
20602 
             * @param array|mixed $columns
20603 
             * @return \Illuminate\Database\Query\Builder
20604 
             * @static
20605 
             */
20606 
            public static function select($columns = [])
20607 
            {
20608 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20609 
                                return $instance->select($columns);
20610 
            }
20611 
 
20612 
                /**
20613 
             * Add a subselect expression to the query.
20614 
             *
20615 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20616 
             * @param string $as
20617 
             * @return \Illuminate\Database\Query\Builder
20618 
             * @throws \InvalidArgumentException
20619 
             * @static
20620 
             */
20621 
            public static function selectSub($query, $as)
20622 
            {
20623 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20624 
                                return $instance->selectSub($query, $as);
20625 
            }
20626 
 
20627 
                /**
20628 
             * Add a new "raw" select expression to the query.
20629 
             *
20630 
             * @param string $expression
20631 
             * @param array $bindings
20632 
             * @return \Illuminate\Database\Query\Builder
20633 
             * @static
20634 
             */
20635 
            public static function selectRaw($expression, $bindings = [])
20636 
            {
20637 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20638 
                                return $instance->selectRaw($expression, $bindings);
20639 
            }
20640 
 
20641 
                /**
20642 
             * Makes "from" fetch from a subquery.
20643 
             *
20644 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20645 
             * @param string $as
20646 
             * @return \Illuminate\Database\Query\Builder
20647 
             * @throws \InvalidArgumentException
20648 
             * @static
20649 
             */
20650 
            public static function fromSub($query, $as)
20651 
            {
20652 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20653 
                                return $instance->fromSub($query, $as);
20654 
            }
20655 
 
20656 
                /**
20657 
             * Add a raw from clause to the query.
20658 
             *
20659 
             * @param string $expression
20660 
             * @param mixed $bindings
20661 
             * @return \Illuminate\Database\Query\Builder
20662 
             * @static
20663 
             */
20664 
            public static function fromRaw($expression, $bindings = [])
20665 
            {
20666 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20667 
                                return $instance->fromRaw($expression, $bindings);
20668 
            }
20669 
 
20670 
                /**
20671 
             * Add a new select column to the query.
20672 
             *
20673 
             * @param array|mixed $column
20674 
             * @return \Illuminate\Database\Query\Builder
20675 
             * @static
20676 
             */
20677 
            public static function addSelect($column)
20678 
            {
20679 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20680 
                                return $instance->addSelect($column);
20681 
            }
20682 
 
20683 
                /**
20684 
             * Force the query to only return distinct results.
20685 
             *
20686 
             * @return \Illuminate\Database\Query\Builder
20687 
             * @static
20688 
             */
20689 
            public static function distinct()
20690 
            {
20691 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20692 
                                return $instance->distinct();
20693 
            }
20694 
 
20695 
                /**
20696 
             * Set the table which the query is targeting.
20697 
             *
20698 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $table
20699 
             * @param string|null $as
20700 
             * @return \Illuminate\Database\Query\Builder
20701 
             * @static
20702 
             */
20703 
            public static function from($table, $as = null)
20704 
            {
20705 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20706 
                                return $instance->from($table, $as);
20707 
            }
20708 
 
20709 
                /**
20710 
             * Add an index hint to suggest a query index.
20711 
             *
20712 
             * @param string $index
20713 
             * @return \Illuminate\Database\Query\Builder
20714 
             * @static
20715 
             */
20716 
            public static function useIndex($index)
20717 
            {
20718 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20719 
                                return $instance->useIndex($index);
20720 
            }
20721 
 
20722 
                /**
20723 
             * Add an index hint to force a query index.
20724 
             *
20725 
             * @param string $index
20726 
             * @return \Illuminate\Database\Query\Builder
20727 
             * @static
20728 
             */
20729 
            public static function forceIndex($index)
20730 
            {
20731 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20732 
                                return $instance->forceIndex($index);
20733 
            }
20734 
 
20735 
                /**
20736 
             * Add an index hint to ignore a query index.
20737 
             *
20738 
             * @param string $index
20739 
             * @return \Illuminate\Database\Query\Builder
20740 
             * @static
20741 
             */
20742 
            public static function ignoreIndex($index)
20743 
            {
20744 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20745 
                                return $instance->ignoreIndex($index);
20746 
            }
20747 
 
20748 
                /**
20749 
             * Add a join clause to the query.
20750 
             *
20751 
             * @param string $table
20752 
             * @param \Closure|string $first
20753 
             * @param string|null $operator
20754 
             * @param string|null $second
20755 
             * @param string $type
20756 
             * @param bool $where
20757 
             * @return \Illuminate\Database\Query\Builder
20758 
             * @static
20759 
             */
20760 
            public static function join($table, $first, $operator = null, $second = null, $type = 'inner', $where = false)
20761 
            {
20762 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20763 
                                return $instance->join($table, $first, $operator, $second, $type, $where);
20764 
            }
20765 
 
20766 
                /**
20767 
             * Add a "join where" clause to the query.
20768 
             *
20769 
             * @param string $table
20770 
             * @param \Closure|string $first
20771 
             * @param string $operator
20772 
             * @param string $second
20773 
             * @param string $type
20774 
             * @return \Illuminate\Database\Query\Builder
20775 
             * @static
20776 
             */
20777 
            public static function joinWhere($table, $first, $operator, $second, $type = 'inner')
20778 
            {
20779 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20780 
                                return $instance->joinWhere($table, $first, $operator, $second, $type);
20781 
            }
20782 
 
20783 
                /**
20784 
             * Add a subquery join clause to the query.
20785 
             *
20786 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20787 
             * @param string $as
20788 
             * @param \Closure|string $first
20789 
             * @param string|null $operator
20790 
             * @param string|null $second
20791 
             * @param string $type
20792 
             * @param bool $where
20793 
             * @return \Illuminate\Database\Query\Builder
20794 
             * @throws \InvalidArgumentException
20795 
             * @static
20796 
             */
20797 
            public static function joinSub($query, $as, $first, $operator = null, $second = null, $type = 'inner', $where = false)
20798 
            {
20799 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20800 
                                return $instance->joinSub($query, $as, $first, $operator, $second, $type, $where);
20801 
            }
20802 
 
20803 
                /**
20804 
             * Add a left join to the query.
20805 
             *
20806 
             * @param string $table
20807 
             * @param \Closure|string $first
20808 
             * @param string|null $operator
20809 
             * @param string|null $second
20810 
             * @return \Illuminate\Database\Query\Builder
20811 
             * @static
20812 
             */
20813 
            public static function leftJoin($table, $first, $operator = null, $second = null)
20814 
            {
20815 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20816 
                                return $instance->leftJoin($table, $first, $operator, $second);
20817 
            }
20818 
 
20819 
                /**
20820 
             * Add a "join where" clause to the query.
20821 
             *
20822 
             * @param string $table
20823 
             * @param \Closure|string $first
20824 
             * @param string $operator
20825 
             * @param string $second
20826 
             * @return \Illuminate\Database\Query\Builder
20827 
             * @static
20828 
             */
20829 
            public static function leftJoinWhere($table, $first, $operator, $second)
20830 
            {
20831 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20832 
                                return $instance->leftJoinWhere($table, $first, $operator, $second);
20833 
            }
20834 
 
20835 
                /**
20836 
             * Add a subquery left join to the query.
20837 
             *
20838 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20839 
             * @param string $as
20840 
             * @param \Closure|string $first
20841 
             * @param string|null $operator
20842 
             * @param string|null $second
20843 
             * @return \Illuminate\Database\Query\Builder
20844 
             * @static
20845 
             */
20846 
            public static function leftJoinSub($query, $as, $first, $operator = null, $second = null)
20847 
            {
20848 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20849 
                                return $instance->leftJoinSub($query, $as, $first, $operator, $second);
20850 
            }
20851 
 
20852 
                /**
20853 
             * Add a right join to the query.
20854 
             *
20855 
             * @param string $table
20856 
             * @param \Closure|string $first
20857 
             * @param string|null $operator
20858 
             * @param string|null $second
20859 
             * @return \Illuminate\Database\Query\Builder
20860 
             * @static
20861 
             */
20862 
            public static function rightJoin($table, $first, $operator = null, $second = null)
20863 
            {
20864 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20865 
                                return $instance->rightJoin($table, $first, $operator, $second);
20866 
            }
20867 
 
20868 
                /**
20869 
             * Add a "right join where" clause to the query.
20870 
             *
20871 
             * @param string $table
20872 
             * @param \Closure|string $first
20873 
             * @param string $operator
20874 
             * @param string $second
20875 
             * @return \Illuminate\Database\Query\Builder
20876 
             * @static
20877 
             */
20878 
            public static function rightJoinWhere($table, $first, $operator, $second)
20879 
            {
20880 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20881 
                                return $instance->rightJoinWhere($table, $first, $operator, $second);
20882 
            }
20883 
 
20884 
                /**
20885 
             * Add a subquery right join to the query.
20886 
             *
20887 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20888 
             * @param string $as
20889 
             * @param \Closure|string $first
20890 
             * @param string|null $operator
20891 
             * @param string|null $second
20892 
             * @return \Illuminate\Database\Query\Builder
20893 
             * @static
20894 
             */
20895 
            public static function rightJoinSub($query, $as, $first, $operator = null, $second = null)
20896 
            {
20897 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20898 
                                return $instance->rightJoinSub($query, $as, $first, $operator, $second);
20899 
            }
20900 
 
20901 
                /**
20902 
             * Add a "cross join" clause to the query.
20903 
             *
20904 
             * @param string $table
20905 
             * @param \Closure|string|null $first
20906 
             * @param string|null $operator
20907 
             * @param string|null $second
20908 
             * @return \Illuminate\Database\Query\Builder
20909 
             * @static
20910 
             */
20911 
            public static function crossJoin($table, $first = null, $operator = null, $second = null)
20912 
            {
20913 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20914 
                                return $instance->crossJoin($table, $first, $operator, $second);
20915 
            }
20916 
 
20917 
                /**
20918 
             * Add a subquery cross join to the query.
20919 
             *
20920 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
20921 
             * @param string $as
20922 
             * @return \Illuminate\Database\Query\Builder
20923 
             * @static
20924 
             */
20925 
            public static function crossJoinSub($query, $as)
20926 
            {
20927 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20928 
                                return $instance->crossJoinSub($query, $as);
20929 
            }
20930 
 
20931 
                /**
20932 
             * Merge an array of where clauses and bindings.
20933 
             *
20934 
             * @param array $wheres
20935 
             * @param array $bindings
20936 
             * @return \Illuminate\Database\Query\Builder
20937 
             * @static
20938 
             */
20939 
            public static function mergeWheres($wheres, $bindings)
20940 
            {
20941 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20942 
                                return $instance->mergeWheres($wheres, $bindings);
20943 
            }
20944 
 
20945 
                /**
20946 
             * Prepare the value and operator for a where clause.
20947 
             *
20948 
             * @param string $value
20949 
             * @param string $operator
20950 
             * @param bool $useDefault
20951 
             * @return array
20952 
             * @throws \InvalidArgumentException
20953 
             * @static
20954 
             */
20955 
            public static function prepareValueAndOperator($value, $operator, $useDefault = false)
20956 
            {
20957 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20958 
                                return $instance->prepareValueAndOperator($value, $operator, $useDefault);
20959 
            }
20960 
 
20961 
                /**
20962 
             * Add a "where" clause comparing two columns to the query.
20963 
             *
20964 
             * @param string|array $first
20965 
             * @param string|null $operator
20966 
             * @param string|null $second
20967 
             * @param string|null $boolean
20968 
             * @return \Illuminate\Database\Query\Builder
20969 
             * @static
20970 
             */
20971 
            public static function whereColumn($first, $operator = null, $second = null, $boolean = 'and')
20972 
            {
20973 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20974 
                                return $instance->whereColumn($first, $operator, $second, $boolean);
20975 
            }
20976 
 
20977 
                /**
20978 
             * Add an "or where" clause comparing two columns to the query.
20979 
             *
20980 
             * @param string|array $first
20981 
             * @param string|null $operator
20982 
             * @param string|null $second
20983 
             * @return \Illuminate\Database\Query\Builder
20984 
             * @static
20985 
             */
20986 
            public static function orWhereColumn($first, $operator = null, $second = null)
20987 
            {
20988 
                                /** @var \Illuminate\Database\Query\Builder $instance */
20989 
                                return $instance->orWhereColumn($first, $operator, $second);
20990 
            }
20991 
 
20992 
                /**
20993 
             * Add a raw where clause to the query.
20994 
             *
20995 
             * @param string $sql
20996 
             * @param mixed $bindings
20997 
             * @param string $boolean
20998 
             * @return \Illuminate\Database\Query\Builder
20999 
             * @static
21000 
             */
21001 
            public static function whereRaw($sql, $bindings = [], $boolean = 'and')
21002 
            {
21003 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21004 
                                return $instance->whereRaw($sql, $bindings, $boolean);
21005 
            }
21006 
 
21007 
                /**
21008 
             * Add a raw or where clause to the query.
21009 
             *
21010 
             * @param string $sql
21011 
             * @param mixed $bindings
21012 
             * @return \Illuminate\Database\Query\Builder
21013 
             * @static
21014 
             */
21015 
            public static function orWhereRaw($sql, $bindings = [])
21016 
            {
21017 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21018 
                                return $instance->orWhereRaw($sql, $bindings);
21019 
            }
21020 
 
21021 
                /**
21022 
             * Add a "where in" clause to the query.
21023 
             *
21024 
             * @param string $column
21025 
             * @param mixed $values
21026 
             * @param string $boolean
21027 
             * @param bool $not
21028 
             * @return \Illuminate\Database\Query\Builder
21029 
             * @static
21030 
             */
21031 
            public static function whereIn($column, $values, $boolean = 'and', $not = false)
21032 
            {
21033 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21034 
                                return $instance->whereIn($column, $values, $boolean, $not);
21035 
            }
21036 
 
21037 
                /**
21038 
             * Add an "or where in" clause to the query.
21039 
             *
21040 
             * @param string $column
21041 
             * @param mixed $values
21042 
             * @return \Illuminate\Database\Query\Builder
21043 
             * @static
21044 
             */
21045 
            public static function orWhereIn($column, $values)
21046 
            {
21047 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21048 
                                return $instance->orWhereIn($column, $values);
21049 
            }
21050 
 
21051 
                /**
21052 
             * Add a "where not in" clause to the query.
21053 
             *
21054 
             * @param string $column
21055 
             * @param mixed $values
21056 
             * @param string $boolean
21057 
             * @return \Illuminate\Database\Query\Builder
21058 
             * @static
21059 
             */
21060 
            public static function whereNotIn($column, $values, $boolean = 'and')
21061 
            {
21062 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21063 
                                return $instance->whereNotIn($column, $values, $boolean);
21064 
            }
21065 
 
21066 
                /**
21067 
             * Add an "or where not in" clause to the query.
21068 
             *
21069 
             * @param string $column
21070 
             * @param mixed $values
21071 
             * @return \Illuminate\Database\Query\Builder
21072 
             * @static
21073 
             */
21074 
            public static function orWhereNotIn($column, $values)
21075 
            {
21076 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21077 
                                return $instance->orWhereNotIn($column, $values);
21078 
            }
21079 
 
21080 
                /**
21081 
             * Add a "where in raw" clause for integer values to the query.
21082 
             *
21083 
             * @param string $column
21084 
             * @param \Illuminate\Contracts\Support\Arrayable|array $values
21085 
             * @param string $boolean
21086 
             * @param bool $not
21087 
             * @return \Illuminate\Database\Query\Builder
21088 
             * @static
21089 
             */
21090 
            public static function whereIntegerInRaw($column, $values, $boolean = 'and', $not = false)
21091 
            {
21092 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21093 
                                return $instance->whereIntegerInRaw($column, $values, $boolean, $not);
21094 
            }
21095 
 
21096 
                /**
21097 
             * Add an "or where in raw" clause for integer values to the query.
21098 
             *
21099 
             * @param string $column
21100 
             * @param \Illuminate\Contracts\Support\Arrayable|array $values
21101 
             * @return \Illuminate\Database\Query\Builder
21102 
             * @static
21103 
             */
21104 
            public static function orWhereIntegerInRaw($column, $values)
21105 
            {
21106 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21107 
                                return $instance->orWhereIntegerInRaw($column, $values);
21108 
            }
21109 
 
21110 
                /**
21111 
             * Add a "where not in raw" clause for integer values to the query.
21112 
             *
21113 
             * @param string $column
21114 
             * @param \Illuminate\Contracts\Support\Arrayable|array $values
21115 
             * @param string $boolean
21116 
             * @return \Illuminate\Database\Query\Builder
21117 
             * @static
21118 
             */
21119 
            public static function whereIntegerNotInRaw($column, $values, $boolean = 'and')
21120 
            {
21121 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21122 
                                return $instance->whereIntegerNotInRaw($column, $values, $boolean);
21123 
            }
21124 
 
21125 
                /**
21126 
             * Add an "or where not in raw" clause for integer values to the query.
21127 
             *
21128 
             * @param string $column
21129 
             * @param \Illuminate\Contracts\Support\Arrayable|array $values
21130 
             * @return \Illuminate\Database\Query\Builder
21131 
             * @static
21132 
             */
21133 
            public static function orWhereIntegerNotInRaw($column, $values)
21134 
            {
21135 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21136 
                                return $instance->orWhereIntegerNotInRaw($column, $values);
21137 
            }
21138 
 
21139 
                /**
21140 
             * Add a "where null" clause to the query.
21141 
             *
21142 
             * @param string|array $columns
21143 
             * @param string $boolean
21144 
             * @param bool $not
21145 
             * @return \Illuminate\Database\Query\Builder
21146 
             * @static
21147 
             */
21148 
            public static function whereNull($columns, $boolean = 'and', $not = false)
21149 
            {
21150 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21151 
                                return $instance->whereNull($columns, $boolean, $not);
21152 
            }
21153 
 
21154 
                /**
21155 
             * Add an "or where null" clause to the query.
21156 
             *
21157 
             * @param string|array $column
21158 
             * @return \Illuminate\Database\Query\Builder
21159 
             * @static
21160 
             */
21161 
            public static function orWhereNull($column)
21162 
            {
21163 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21164 
                                return $instance->orWhereNull($column);
21165 
            }
21166 
 
21167 
                /**
21168 
             * Add a "where not null" clause to the query.
21169 
             *
21170 
             * @param string|array $columns
21171 
             * @param string $boolean
21172 
             * @return \Illuminate\Database\Query\Builder
21173 
             * @static
21174 
             */
21175 
            public static function whereNotNull($columns, $boolean = 'and')
21176 
            {
21177 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21178 
                                return $instance->whereNotNull($columns, $boolean);
21179 
            }
21180 
 
21181 
                /**
21182 
             * Add a where between statement to the query.
21183 
             *
21184 
             * @param string|\Illuminate\Database\Query\Expression $column
21185 
             * @param \Illuminate\Database\Query\iterable $values
21186 
             * @param string $boolean
21187 
             * @param bool $not
21188 
             * @return \Illuminate\Database\Query\Builder
21189 
             * @static
21190 
             */
21191 
            public static function whereBetween($column, $values, $boolean = 'and', $not = false)
21192 
            {
21193 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21194 
                                return $instance->whereBetween($column, $values, $boolean, $not);
21195 
            }
21196 
 
21197 
                /**
21198 
             * Add a where between statement using columns to the query.
21199 
             *
21200 
             * @param string $column
21201 
             * @param array $values
21202 
             * @param string $boolean
21203 
             * @param bool $not
21204 
             * @return \Illuminate\Database\Query\Builder
21205 
             * @static
21206 
             */
21207 
            public static function whereBetweenColumns($column, $values, $boolean = 'and', $not = false)
21208 
            {
21209 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21210 
                                return $instance->whereBetweenColumns($column, $values, $boolean, $not);
21211 
            }
21212 
 
21213 
                /**
21214 
             * Add an or where between statement to the query.
21215 
             *
21216 
             * @param string $column
21217 
             * @param \Illuminate\Database\Query\iterable $values
21218 
             * @return \Illuminate\Database\Query\Builder
21219 
             * @static
21220 
             */
21221 
            public static function orWhereBetween($column, $values)
21222 
            {
21223 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21224 
                                return $instance->orWhereBetween($column, $values);
21225 
            }
21226 
 
21227 
                /**
21228 
             * Add an or where between statement using columns to the query.
21229 
             *
21230 
             * @param string $column
21231 
             * @param array $values
21232 
             * @return \Illuminate\Database\Query\Builder
21233 
             * @static
21234 
             */
21235 
            public static function orWhereBetweenColumns($column, $values)
21236 
            {
21237 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21238 
                                return $instance->orWhereBetweenColumns($column, $values);
21239 
            }
21240 
 
21241 
                /**
21242 
             * Add a where not between statement to the query.
21243 
             *
21244 
             * @param string $column
21245 
             * @param \Illuminate\Database\Query\iterable $values
21246 
             * @param string $boolean
21247 
             * @return \Illuminate\Database\Query\Builder
21248 
             * @static
21249 
             */
21250 
            public static function whereNotBetween($column, $values, $boolean = 'and')
21251 
            {
21252 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21253 
                                return $instance->whereNotBetween($column, $values, $boolean);
21254 
            }
21255 
 
21256 
                /**
21257 
             * Add a where not between statement using columns to the query.
21258 
             *
21259 
             * @param string $column
21260 
             * @param array $values
21261 
             * @param string $boolean
21262 
             * @return \Illuminate\Database\Query\Builder
21263 
             * @static
21264 
             */
21265 
            public static function whereNotBetweenColumns($column, $values, $boolean = 'and')
21266 
            {
21267 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21268 
                                return $instance->whereNotBetweenColumns($column, $values, $boolean);
21269 
            }
21270 
 
21271 
                /**
21272 
             * Add an or where not between statement to the query.
21273 
             *
21274 
             * @param string $column
21275 
             * @param \Illuminate\Database\Query\iterable $values
21276 
             * @return \Illuminate\Database\Query\Builder
21277 
             * @static
21278 
             */
21279 
            public static function orWhereNotBetween($column, $values)
21280 
            {
21281 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21282 
                                return $instance->orWhereNotBetween($column, $values);
21283 
            }
21284 
 
21285 
                /**
21286 
             * Add an or where not between statement using columns to the query.
21287 
             *
21288 
             * @param string $column
21289 
             * @param array $values
21290 
             * @return \Illuminate\Database\Query\Builder
21291 
             * @static
21292 
             */
21293 
            public static function orWhereNotBetweenColumns($column, $values)
21294 
            {
21295 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21296 
                                return $instance->orWhereNotBetweenColumns($column, $values);
21297 
            }
21298 
 
21299 
                /**
21300 
             * Add an "or where not null" clause to the query.
21301 
             *
21302 
             * @param string $column
21303 
             * @return \Illuminate\Database\Query\Builder
21304 
             * @static
21305 
             */
21306 
            public static function orWhereNotNull($column)
21307 
            {
21308 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21309 
                                return $instance->orWhereNotNull($column);
21310 
            }
21311 
 
21312 
                /**
21313 
             * Add a "where date" statement to the query.
21314 
             *
21315 
             * @param string $column
21316 
             * @param string $operator
21317 
             * @param \DateTimeInterface|string|null $value
21318 
             * @param string $boolean
21319 
             * @return \Illuminate\Database\Query\Builder
21320 
             * @static
21321 
             */
21322 
            public static function whereDate($column, $operator, $value = null, $boolean = 'and')
21323 
            {
21324 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21325 
                                return $instance->whereDate($column, $operator, $value, $boolean);
21326 
            }
21327 
 
21328 
                /**
21329 
             * Add an "or where date" statement to the query.
21330 
             *
21331 
             * @param string $column
21332 
             * @param string $operator
21333 
             * @param \DateTimeInterface|string|null $value
21334 
             * @return \Illuminate\Database\Query\Builder
21335 
             * @static
21336 
             */
21337 
            public static function orWhereDate($column, $operator, $value = null)
21338 
            {
21339 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21340 
                                return $instance->orWhereDate($column, $operator, $value);
21341 
            }
21342 
 
21343 
                /**
21344 
             * Add a "where time" statement to the query.
21345 
             *
21346 
             * @param string $column
21347 
             * @param string $operator
21348 
             * @param \DateTimeInterface|string|null $value
21349 
             * @param string $boolean
21350 
             * @return \Illuminate\Database\Query\Builder
21351 
             * @static
21352 
             */
21353 
            public static function whereTime($column, $operator, $value = null, $boolean = 'and')
21354 
            {
21355 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21356 
                                return $instance->whereTime($column, $operator, $value, $boolean);
21357 
            }
21358 
 
21359 
                /**
21360 
             * Add an "or where time" statement to the query.
21361 
             *
21362 
             * @param string $column
21363 
             * @param string $operator
21364 
             * @param \DateTimeInterface|string|null $value
21365 
             * @return \Illuminate\Database\Query\Builder
21366 
             * @static
21367 
             */
21368 
            public static function orWhereTime($column, $operator, $value = null)
21369 
            {
21370 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21371 
                                return $instance->orWhereTime($column, $operator, $value);
21372 
            }
21373 
 
21374 
                /**
21375 
             * Add a "where day" statement to the query.
21376 
             *
21377 
             * @param string $column
21378 
             * @param string $operator
21379 
             * @param \DateTimeInterface|string|int|null $value
21380 
             * @param string $boolean
21381 
             * @return \Illuminate\Database\Query\Builder
21382 
             * @static
21383 
             */
21384 
            public static function whereDay($column, $operator, $value = null, $boolean = 'and')
21385 
            {
21386 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21387 
                                return $instance->whereDay($column, $operator, $value, $boolean);
21388 
            }
21389 
 
21390 
                /**
21391 
             * Add an "or where day" statement to the query.
21392 
             *
21393 
             * @param string $column
21394 
             * @param string $operator
21395 
             * @param \DateTimeInterface|string|int|null $value
21396 
             * @return \Illuminate\Database\Query\Builder
21397 
             * @static
21398 
             */
21399 
            public static function orWhereDay($column, $operator, $value = null)
21400 
            {
21401 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21402 
                                return $instance->orWhereDay($column, $operator, $value);
21403 
            }
21404 
 
21405 
                /**
21406 
             * Add a "where month" statement to the query.
21407 
             *
21408 
             * @param string $column
21409 
             * @param string $operator
21410 
             * @param \DateTimeInterface|string|int|null $value
21411 
             * @param string $boolean
21412 
             * @return \Illuminate\Database\Query\Builder
21413 
             * @static
21414 
             */
21415 
            public static function whereMonth($column, $operator, $value = null, $boolean = 'and')
21416 
            {
21417 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21418 
                                return $instance->whereMonth($column, $operator, $value, $boolean);
21419 
            }
21420 
 
21421 
                /**
21422 
             * Add an "or where month" statement to the query.
21423 
             *
21424 
             * @param string $column
21425 
             * @param string $operator
21426 
             * @param \DateTimeInterface|string|int|null $value
21427 
             * @return \Illuminate\Database\Query\Builder
21428 
             * @static
21429 
             */
21430 
            public static function orWhereMonth($column, $operator, $value = null)
21431 
            {
21432 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21433 
                                return $instance->orWhereMonth($column, $operator, $value);
21434 
            }
21435 
 
21436 
                /**
21437 
             * Add a "where year" statement to the query.
21438 
             *
21439 
             * @param string $column
21440 
             * @param string $operator
21441 
             * @param \DateTimeInterface|string|int|null $value
21442 
             * @param string $boolean
21443 
             * @return \Illuminate\Database\Query\Builder
21444 
             * @static
21445 
             */
21446 
            public static function whereYear($column, $operator, $value = null, $boolean = 'and')
21447 
            {
21448 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21449 
                                return $instance->whereYear($column, $operator, $value, $boolean);
21450 
            }
21451 
 
21452 
                /**
21453 
             * Add an "or where year" statement to the query.
21454 
             *
21455 
             * @param string $column
21456 
             * @param string $operator
21457 
             * @param \DateTimeInterface|string|int|null $value
21458 
             * @return \Illuminate\Database\Query\Builder
21459 
             * @static
21460 
             */
21461 
            public static function orWhereYear($column, $operator, $value = null)
21462 
            {
21463 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21464 
                                return $instance->orWhereYear($column, $operator, $value);
21465 
            }
21466 
 
21467 
                /**
21468 
             * Add a nested where statement to the query.
21469 
             *
21470 
             * @param \Closure $callback
21471 
             * @param string $boolean
21472 
             * @return \Illuminate\Database\Query\Builder
21473 
             * @static
21474 
             */
21475 
            public static function whereNested($callback, $boolean = 'and')
21476 
            {
21477 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21478 
                                return $instance->whereNested($callback, $boolean);
21479 
            }
21480 
 
21481 
                /**
21482 
             * Create a new query instance for nested where condition.
21483 
             *
21484 
             * @return \Illuminate\Database\Query\Builder
21485 
             * @static
21486 
             */
21487 
            public static function forNestedWhere()
21488 
            {
21489 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21490 
                                return $instance->forNestedWhere();
21491 
            }
21492 
 
21493 
                /**
21494 
             * Add another query builder as a nested where to the query builder.
21495 
             *
21496 
             * @param \Illuminate\Database\Query\Builder $query
21497 
             * @param string $boolean
21498 
             * @return \Illuminate\Database\Query\Builder
21499 
             * @static
21500 
             */
21501 
            public static function addNestedWhereQuery($query, $boolean = 'and')
21502 
            {
21503 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21504 
                                return $instance->addNestedWhereQuery($query, $boolean);
21505 
            }
21506 
 
21507 
                /**
21508 
             * Add an exists clause to the query.
21509 
             *
21510 
             * @param \Closure $callback
21511 
             * @param string $boolean
21512 
             * @param bool $not
21513 
             * @return \Illuminate\Database\Query\Builder
21514 
             * @static
21515 
             */
21516 
            public static function whereExists($callback, $boolean = 'and', $not = false)
21517 
            {
21518 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21519 
                                return $instance->whereExists($callback, $boolean, $not);
21520 
            }
21521 
 
21522 
                /**
21523 
             * Add an or exists clause to the query.
21524 
             *
21525 
             * @param \Closure $callback
21526 
             * @param bool $not
21527 
             * @return \Illuminate\Database\Query\Builder
21528 
             * @static
21529 
             */
21530 
            public static function orWhereExists($callback, $not = false)
21531 
            {
21532 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21533 
                                return $instance->orWhereExists($callback, $not);
21534 
            }
21535 
 
21536 
                /**
21537 
             * Add a where not exists clause to the query.
21538 
             *
21539 
             * @param \Closure $callback
21540 
             * @param string $boolean
21541 
             * @return \Illuminate\Database\Query\Builder
21542 
             * @static
21543 
             */
21544 
            public static function whereNotExists($callback, $boolean = 'and')
21545 
            {
21546 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21547 
                                return $instance->whereNotExists($callback, $boolean);
21548 
            }
21549 
 
21550 
                /**
21551 
             * Add a where not exists clause to the query.
21552 
             *
21553 
             * @param \Closure $callback
21554 
             * @return \Illuminate\Database\Query\Builder
21555 
             * @static
21556 
             */
21557 
            public static function orWhereNotExists($callback)
21558 
            {
21559 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21560 
                                return $instance->orWhereNotExists($callback);
21561 
            }
21562 
 
21563 
                /**
21564 
             * Add an exists clause to the query.
21565 
             *
21566 
             * @param \Illuminate\Database\Query\Builder $query
21567 
             * @param string $boolean
21568 
             * @param bool $not
21569 
             * @return \Illuminate\Database\Query\Builder
21570 
             * @static
21571 
             */
21572 
            public static function addWhereExistsQuery($query, $boolean = 'and', $not = false)
21573 
            {
21574 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21575 
                                return $instance->addWhereExistsQuery($query, $boolean, $not);
21576 
            }
21577 
 
21578 
                /**
21579 
             * Adds a where condition using row values.
21580 
             *
21581 
             * @param array $columns
21582 
             * @param string $operator
21583 
             * @param array $values
21584 
             * @param string $boolean
21585 
             * @return \Illuminate\Database\Query\Builder
21586 
             * @throws \InvalidArgumentException
21587 
             * @static
21588 
             */
21589 
            public static function whereRowValues($columns, $operator, $values, $boolean = 'and')
21590 
            {
21591 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21592 
                                return $instance->whereRowValues($columns, $operator, $values, $boolean);
21593 
            }
21594 
 
21595 
                /**
21596 
             * Adds an or where condition using row values.
21597 
             *
21598 
             * @param array $columns
21599 
             * @param string $operator
21600 
             * @param array $values
21601 
             * @return \Illuminate\Database\Query\Builder
21602 
             * @static
21603 
             */
21604 
            public static function orWhereRowValues($columns, $operator, $values)
21605 
            {
21606 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21607 
                                return $instance->orWhereRowValues($columns, $operator, $values);
21608 
            }
21609 
 
21610 
                /**
21611 
             * Add a "where JSON contains" clause to the query.
21612 
             *
21613 
             * @param string $column
21614 
             * @param mixed $value
21615 
             * @param string $boolean
21616 
             * @param bool $not
21617 
             * @return \Illuminate\Database\Query\Builder
21618 
             * @static
21619 
             */
21620 
            public static function whereJsonContains($column, $value, $boolean = 'and', $not = false)
21621 
            {
21622 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21623 
                                return $instance->whereJsonContains($column, $value, $boolean, $not);
21624 
            }
21625 
 
21626 
                /**
21627 
             * Add an "or where JSON contains" clause to the query.
21628 
             *
21629 
             * @param string $column
21630 
             * @param mixed $value
21631 
             * @return \Illuminate\Database\Query\Builder
21632 
             * @static
21633 
             */
21634 
            public static function orWhereJsonContains($column, $value)
21635 
            {
21636 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21637 
                                return $instance->orWhereJsonContains($column, $value);
21638 
            }
21639 
 
21640 
                /**
21641 
             * Add a "where JSON not contains" clause to the query.
21642 
             *
21643 
             * @param string $column
21644 
             * @param mixed $value
21645 
             * @param string $boolean
21646 
             * @return \Illuminate\Database\Query\Builder
21647 
             * @static
21648 
             */
21649 
            public static function whereJsonDoesntContain($column, $value, $boolean = 'and')
21650 
            {
21651 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21652 
                                return $instance->whereJsonDoesntContain($column, $value, $boolean);
21653 
            }
21654 
 
21655 
                /**
21656 
             * Add an "or where JSON not contains" clause to the query.
21657 
             *
21658 
             * @param string $column
21659 
             * @param mixed $value
21660 
             * @return \Illuminate\Database\Query\Builder
21661 
             * @static
21662 
             */
21663 
            public static function orWhereJsonDoesntContain($column, $value)
21664 
            {
21665 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21666 
                                return $instance->orWhereJsonDoesntContain($column, $value);
21667 
            }
21668 
 
21669 
                /**
21670 
             * Add a clause that determines if a JSON path exists to the query.
21671 
             *
21672 
             * @param string $column
21673 
             * @param string $boolean
21674 
             * @param bool $not
21675 
             * @return \Illuminate\Database\Query\Builder
21676 
             * @static
21677 
             */
21678 
            public static function whereJsonContainsKey($column, $boolean = 'and', $not = false)
21679 
            {
21680 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21681 
                                return $instance->whereJsonContainsKey($column, $boolean, $not);
21682 
            }
21683 
 
21684 
                /**
21685 
             * Add an "or" clause that determines if a JSON path exists to the query.
21686 
             *
21687 
             * @param string $column
21688 
             * @return \Illuminate\Database\Query\Builder
21689 
             * @static
21690 
             */
21691 
            public static function orWhereJsonContainsKey($column)
21692 
            {
21693 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21694 
                                return $instance->orWhereJsonContainsKey($column);
21695 
            }
21696 
 
21697 
                /**
21698 
             * Add a clause that determines if a JSON path does not exist to the query.
21699 
             *
21700 
             * @param string $column
21701 
             * @param string $boolean
21702 
             * @return \Illuminate\Database\Query\Builder
21703 
             * @static
21704 
             */
21705 
            public static function whereJsonDoesntContainKey($column, $boolean = 'and')
21706 
            {
21707 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21708 
                                return $instance->whereJsonDoesntContainKey($column, $boolean);
21709 
            }
21710 
 
21711 
                /**
21712 
             * Add an "or" clause that determines if a JSON path does not exist to the query.
21713 
             *
21714 
             * @param string $column
21715 
             * @return \Illuminate\Database\Query\Builder
21716 
             * @static
21717 
             */
21718 
            public static function orWhereJsonDoesntContainKey($column)
21719 
            {
21720 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21721 
                                return $instance->orWhereJsonDoesntContainKey($column);
21722 
            }
21723 
 
21724 
                /**
21725 
             * Add a "where JSON length" clause to the query.
21726 
             *
21727 
             * @param string $column
21728 
             * @param mixed $operator
21729 
             * @param mixed $value
21730 
             * @param string $boolean
21731 
             * @return \Illuminate\Database\Query\Builder
21732 
             * @static
21733 
             */
21734 
            public static function whereJsonLength($column, $operator, $value = null, $boolean = 'and')
21735 
            {
21736 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21737 
                                return $instance->whereJsonLength($column, $operator, $value, $boolean);
21738 
            }
21739 
 
21740 
                /**
21741 
             * Add an "or where JSON length" clause to the query.
21742 
             *
21743 
             * @param string $column
21744 
             * @param mixed $operator
21745 
             * @param mixed $value
21746 
             * @return \Illuminate\Database\Query\Builder
21747 
             * @static
21748 
             */
21749 
            public static function orWhereJsonLength($column, $operator, $value = null)
21750 
            {
21751 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21752 
                                return $instance->orWhereJsonLength($column, $operator, $value);
21753 
            }
21754 
 
21755 
                /**
21756 
             * Handles dynamic "where" clauses to the query.
21757 
             *
21758 
             * @param string $method
21759 
             * @param array $parameters
21760 
             * @return \Illuminate\Database\Query\Builder
21761 
             * @static
21762 
             */
21763 
            public static function dynamicWhere($method, $parameters)
21764 
            {
21765 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21766 
                                return $instance->dynamicWhere($method, $parameters);
21767 
            }
21768 
 
21769 
                /**
21770 
             * Add a "where fulltext" clause to the query.
21771 
             *
21772 
             * @param string|string[] $columns
21773 
             * @param string $value
21774 
             * @param string $boolean
21775 
             * @return \Illuminate\Database\Query\Builder
21776 
             * @static
21777 
             */
21778 
            public static function whereFullText($columns, $value, $options = [], $boolean = 'and')
21779 
            {
21780 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21781 
                                return $instance->whereFullText($columns, $value, $options, $boolean);
21782 
            }
21783 
 
21784 
                /**
21785 
             * Add a "or where fulltext" clause to the query.
21786 
             *
21787 
             * @param string|string[] $columns
21788 
             * @param string $value
21789 
             * @return \Illuminate\Database\Query\Builder
21790 
             * @static
21791 
             */
21792 
            public static function orWhereFullText($columns, $value, $options = [])
21793 
            {
21794 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21795 
                                return $instance->orWhereFullText($columns, $value, $options);
21796 
            }
21797 
 
21798 
                /**
21799 
             * Add a "group by" clause to the query.
21800 
             *
21801 
             * @param array|string $groups
21802 
             * @return \Illuminate\Database\Query\Builder
21803 
             * @static
21804 
             */
21805 
            public static function groupBy(...$groups)
21806 
            {
21807 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21808 
                                return $instance->groupBy(...$groups);
21809 
            }
21810 
 
21811 
                /**
21812 
             * Add a raw groupBy clause to the query.
21813 
             *
21814 
             * @param string $sql
21815 
             * @param array $bindings
21816 
             * @return \Illuminate\Database\Query\Builder
21817 
             * @static
21818 
             */
21819 
            public static function groupByRaw($sql, $bindings = [])
21820 
            {
21821 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21822 
                                return $instance->groupByRaw($sql, $bindings);
21823 
            }
21824 
 
21825 
                /**
21826 
             * Add a "having" clause to the query.
21827 
             *
21828 
             * @param \Closure|string $column
21829 
             * @param string|int|float|null $operator
21830 
             * @param string|int|float|null $value
21831 
             * @param string $boolean
21832 
             * @return \Illuminate\Database\Query\Builder
21833 
             * @static
21834 
             */
21835 
            public static function having($column, $operator = null, $value = null, $boolean = 'and')
21836 
            {
21837 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21838 
                                return $instance->having($column, $operator, $value, $boolean);
21839 
            }
21840 
 
21841 
                /**
21842 
             * Add an "or having" clause to the query.
21843 
             *
21844 
             * @param \Closure|string $column
21845 
             * @param string|int|float|null $operator
21846 
             * @param string|int|float|null $value
21847 
             * @return \Illuminate\Database\Query\Builder
21848 
             * @static
21849 
             */
21850 
            public static function orHaving($column, $operator = null, $value = null)
21851 
            {
21852 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21853 
                                return $instance->orHaving($column, $operator, $value);
21854 
            }
21855 
 
21856 
                /**
21857 
             * Add a nested having statement to the query.
21858 
             *
21859 
             * @param \Closure $callback
21860 
             * @param string $boolean
21861 
             * @return \Illuminate\Database\Query\Builder
21862 
             * @static
21863 
             */
21864 
            public static function havingNested($callback, $boolean = 'and')
21865 
            {
21866 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21867 
                                return $instance->havingNested($callback, $boolean);
21868 
            }
21869 
 
21870 
                /**
21871 
             * Add another query builder as a nested having to the query builder.
21872 
             *
21873 
             * @param \Illuminate\Database\Query\Builder $query
21874 
             * @param string $boolean
21875 
             * @return \Illuminate\Database\Query\Builder
21876 
             * @static
21877 
             */
21878 
            public static function addNestedHavingQuery($query, $boolean = 'and')
21879 
            {
21880 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21881 
                                return $instance->addNestedHavingQuery($query, $boolean);
21882 
            }
21883 
 
21884 
                /**
21885 
             * Add a "having null" clause to the query.
21886 
             *
21887 
             * @param string|array $columns
21888 
             * @param string $boolean
21889 
             * @param bool $not
21890 
             * @return \Illuminate\Database\Query\Builder
21891 
             * @static
21892 
             */
21893 
            public static function havingNull($columns, $boolean = 'and', $not = false)
21894 
            {
21895 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21896 
                                return $instance->havingNull($columns, $boolean, $not);
21897 
            }
21898 
 
21899 
                /**
21900 
             * Add an "or having null" clause to the query.
21901 
             *
21902 
             * @param string $column
21903 
             * @return \Illuminate\Database\Query\Builder
21904 
             * @static
21905 
             */
21906 
            public static function orHavingNull($column)
21907 
            {
21908 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21909 
                                return $instance->orHavingNull($column);
21910 
            }
21911 
 
21912 
                /**
21913 
             * Add a "having not null" clause to the query.
21914 
             *
21915 
             * @param string|array $columns
21916 
             * @param string $boolean
21917 
             * @return \Illuminate\Database\Query\Builder
21918 
             * @static
21919 
             */
21920 
            public static function havingNotNull($columns, $boolean = 'and')
21921 
            {
21922 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21923 
                                return $instance->havingNotNull($columns, $boolean);
21924 
            }
21925 
 
21926 
                /**
21927 
             * Add an "or having not null" clause to the query.
21928 
             *
21929 
             * @param string $column
21930 
             * @return \Illuminate\Database\Query\Builder
21931 
             * @static
21932 
             */
21933 
            public static function orHavingNotNull($column)
21934 
            {
21935 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21936 
                                return $instance->orHavingNotNull($column);
21937 
            }
21938 
 
21939 
                /**
21940 
             * Add a "having between " clause to the query.
21941 
             *
21942 
             * @param string $column
21943 
             * @param array $values
21944 
             * @param string $boolean
21945 
             * @param bool $not
21946 
             * @return \Illuminate\Database\Query\Builder
21947 
             * @static
21948 
             */
21949 
            public static function havingBetween($column, $values, $boolean = 'and', $not = false)
21950 
            {
21951 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21952 
                                return $instance->havingBetween($column, $values, $boolean, $not);
21953 
            }
21954 
 
21955 
                /**
21956 
             * Add a raw having clause to the query.
21957 
             *
21958 
             * @param string $sql
21959 
             * @param array $bindings
21960 
             * @param string $boolean
21961 
             * @return \Illuminate\Database\Query\Builder
21962 
             * @static
21963 
             */
21964 
            public static function havingRaw($sql, $bindings = [], $boolean = 'and')
21965 
            {
21966 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21967 
                                return $instance->havingRaw($sql, $bindings, $boolean);
21968 
            }
21969 
 
21970 
                /**
21971 
             * Add a raw or having clause to the query.
21972 
             *
21973 
             * @param string $sql
21974 
             * @param array $bindings
21975 
             * @return \Illuminate\Database\Query\Builder
21976 
             * @static
21977 
             */
21978 
            public static function orHavingRaw($sql, $bindings = [])
21979 
            {
21980 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21981 
                                return $instance->orHavingRaw($sql, $bindings);
21982 
            }
21983 
 
21984 
                /**
21985 
             * Add an "order by" clause to the query.
21986 
             *
21987 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Query\Expression|string $column
21988 
             * @param string $direction
21989 
             * @return \Illuminate\Database\Query\Builder
21990 
             * @throws \InvalidArgumentException
21991 
             * @static
21992 
             */
21993 
            public static function orderBy($column, $direction = 'asc')
21994 
            {
21995 
                                /** @var \Illuminate\Database\Query\Builder $instance */
21996 
                                return $instance->orderBy($column, $direction);
21997 
            }
21998 
 
21999 
                /**
22000 
             * Add a descending "order by" clause to the query.
22001 
             *
22002 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Query\Expression|string $column
22003 
             * @return \Illuminate\Database\Query\Builder
22004 
             * @static
22005 
             */
22006 
            public static function orderByDesc($column)
22007 
            {
22008 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22009 
                                return $instance->orderByDesc($column);
22010 
            }
22011 
 
22012 
                /**
22013 
             * Put the query's results in random order.
22014 
             *
22015 
             * @param string|int $seed
22016 
             * @return \Illuminate\Database\Query\Builder
22017 
             * @static
22018 
             */
22019 
            public static function inRandomOrder($seed = '')
22020 
            {
22021 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22022 
                                return $instance->inRandomOrder($seed);
22023 
            }
22024 
 
22025 
                /**
22026 
             * Add a raw "order by" clause to the query.
22027 
             *
22028 
             * @param string $sql
22029 
             * @param array $bindings
22030 
             * @return \Illuminate\Database\Query\Builder
22031 
             * @static
22032 
             */
22033 
            public static function orderByRaw($sql, $bindings = [])
22034 
            {
22035 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22036 
                                return $instance->orderByRaw($sql, $bindings);
22037 
            }
22038 
 
22039 
                /**
22040 
             * Alias to set the "offset" value of the query.
22041 
             *
22042 
             * @param int $value
22043 
             * @return \Illuminate\Database\Query\Builder
22044 
             * @static
22045 
             */
22046 
            public static function skip($value)
22047 
            {
22048 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22049 
                                return $instance->skip($value);
22050 
            }
22051 
 
22052 
                /**
22053 
             * Set the "offset" value of the query.
22054 
             *
22055 
             * @param int $value
22056 
             * @return \Illuminate\Database\Query\Builder
22057 
             * @static
22058 
             */
22059 
            public static function offset($value)
22060 
            {
22061 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22062 
                                return $instance->offset($value);
22063 
            }
22064 
 
22065 
                /**
22066 
             * Alias to set the "limit" value of the query.
22067 
             *
22068 
             * @param int $value
22069 
             * @return \Illuminate\Database\Query\Builder
22070 
             * @static
22071 
             */
22072 
            public static function take($value)
22073 
            {
22074 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22075 
                                return $instance->take($value);
22076 
            }
22077 
 
22078 
                /**
22079 
             * Set the "limit" value of the query.
22080 
             *
22081 
             * @param int $value
22082 
             * @return \Illuminate\Database\Query\Builder
22083 
             * @static
22084 
             */
22085 
            public static function limit($value)
22086 
            {
22087 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22088 
                                return $instance->limit($value);
22089 
            }
22090 
 
22091 
                /**
22092 
             * Set the limit and offset for a given page.
22093 
             *
22094 
             * @param int $page
22095 
             * @param int $perPage
22096 
             * @return \Illuminate\Database\Query\Builder
22097 
             * @static
22098 
             */
22099 
            public static function forPage($page, $perPage = 15)
22100 
            {
22101 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22102 
                                return $instance->forPage($page, $perPage);
22103 
            }
22104 
 
22105 
                /**
22106 
             * Constrain the query to the previous "page" of results before a given ID.
22107 
             *
22108 
             * @param int $perPage
22109 
             * @param int|null $lastId
22110 
             * @param string $column
22111 
             * @return \Illuminate\Database\Query\Builder
22112 
             * @static
22113 
             */
22114 
            public static function forPageBeforeId($perPage = 15, $lastId = 0, $column = 'id')
22115 
            {
22116 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22117 
                                return $instance->forPageBeforeId($perPage, $lastId, $column);
22118 
            }
22119 
 
22120 
                /**
22121 
             * Constrain the query to the next "page" of results after a given ID.
22122 
             *
22123 
             * @param int $perPage
22124 
             * @param int|null $lastId
22125 
             * @param string $column
22126 
             * @return \Illuminate\Database\Query\Builder
22127 
             * @static
22128 
             */
22129 
            public static function forPageAfterId($perPage = 15, $lastId = 0, $column = 'id')
22130 
            {
22131 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22132 
                                return $instance->forPageAfterId($perPage, $lastId, $column);
22133 
            }
22134 
 
22135 
                /**
22136 
             * Remove all existing orders and optionally add a new order.
22137 
             *
22138 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Query\Expression|string|null $column
22139 
             * @param string $direction
22140 
             * @return \Illuminate\Database\Query\Builder
22141 
             * @static
22142 
             */
22143 
            public static function reorder($column = null, $direction = 'asc')
22144 
            {
22145 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22146 
                                return $instance->reorder($column, $direction);
22147 
            }
22148 
 
22149 
                /**
22150 
             * Add a union statement to the query.
22151 
             *
22152 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder $query
22153 
             * @param bool $all
22154 
             * @return \Illuminate\Database\Query\Builder
22155 
             * @static
22156 
             */
22157 
            public static function union($query, $all = false)
22158 
            {
22159 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22160 
                                return $instance->union($query, $all);
22161 
            }
22162 
 
22163 
                /**
22164 
             * Add a union all statement to the query.
22165 
             *
22166 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder $query
22167 
             * @return \Illuminate\Database\Query\Builder
22168 
             * @static
22169 
             */
22170 
            public static function unionAll($query)
22171 
            {
22172 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22173 
                                return $instance->unionAll($query);
22174 
            }
22175 
 
22176 
                /**
22177 
             * Lock the selected rows in the table.
22178 
             *
22179 
             * @param string|bool $value
22180 
             * @return \Illuminate\Database\Query\Builder
22181 
             * @static
22182 
             */
22183 
            public static function lock($value = true)
22184 
            {
22185 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22186 
                                return $instance->lock($value);
22187 
            }
22188 
 
22189 
                /**
22190 
             * Lock the selected rows in the table for updating.
22191 
             *
22192 
             * @return \Illuminate\Database\Query\Builder
22193 
             * @static
22194 
             */
22195 
            public static function lockForUpdate()
22196 
            {
22197 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22198 
                                return $instance->lockForUpdate();
22199 
            }
22200 
 
22201 
                /**
22202 
             * Share lock the selected rows in the table.
22203 
             *
22204 
             * @return \Illuminate\Database\Query\Builder
22205 
             * @static
22206 
             */
22207 
            public static function sharedLock()
22208 
            {
22209 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22210 
                                return $instance->sharedLock();
22211 
            }
22212 
 
22213 
                /**
22214 
             * Register a closure to be invoked before the query is executed.
22215 
             *
22216 
             * @param callable $callback
22217 
             * @return \Illuminate\Database\Query\Builder
22218 
             * @static
22219 
             */
22220 
            public static function beforeQuery($callback)
22221 
            {
22222 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22223 
                                return $instance->beforeQuery($callback);
22224 
            }
22225 
 
22226 
                /**
22227 
             * Invoke the "before query" modification callbacks.
22228 
             *
22229 
             * @return void
22230 
             * @static
22231 
             */
22232 
            public static function applyBeforeQueryCallbacks()
22233 
            {
22234 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22235 
                                $instance->applyBeforeQueryCallbacks();
22236 
            }
22237 
 
22238 
                /**
22239 
             * Get the SQL representation of the query.
22240 
             *
22241 
             * @return string
22242 
             * @static
22243 
             */
22244 
            public static function toSql()
22245 
            {
22246 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22247 
                                return $instance->toSql();
22248 
            }
22249 
 
22250 
                /**
22251 
             * Get a single expression value from the first result of a query.
22252 
             *
22253 
             * @param string $expression
22254 
             * @param array $bindings
22255 
             * @return mixed
22256 
             * @static
22257 
             */
22258 
            public static function rawValue($expression, $bindings = [])
22259 
            {
22260 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22261 
                                return $instance->rawValue($expression, $bindings);
22262 
            }
22263 
 
22264 
                /**
22265 
             * Get the count of the total records for the paginator.
22266 
             *
22267 
             * @param array $columns
22268 
             * @return int
22269 
             * @static
22270 
             */
22271 
            public static function getCountForPagination($columns = [])
22272 
            {
22273 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22274 
                                return $instance->getCountForPagination($columns);
22275 
            }
22276 
 
22277 
                /**
22278 
             * Concatenate values of a given column as a string.
22279 
             *
22280 
             * @param string $column
22281 
             * @param string $glue
22282 
             * @return string
22283 
             * @static
22284 
             */
22285 
            public static function implode($column, $glue = '')
22286 
            {
22287 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22288 
                                return $instance->implode($column, $glue);
22289 
            }
22290 
 
22291 
                /**
22292 
             * Determine if any rows exist for the current query.
22293 
             *
22294 
             * @return bool
22295 
             * @static
22296 
             */
22297 
            public static function exists()
22298 
            {
22299 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22300 
                                return $instance->exists();
22301 
            }
22302 
 
22303 
                /**
22304 
             * Determine if no rows exist for the current query.
22305 
             *
22306 
             * @return bool
22307 
             * @static
22308 
             */
22309 
            public static function doesntExist()
22310 
            {
22311 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22312 
                                return $instance->doesntExist();
22313 
            }
22314 
 
22315 
                /**
22316 
             * Execute the given callback if no rows exist for the current query.
22317 
             *
22318 
             * @param \Closure $callback
22319 
             * @return mixed
22320 
             * @static
22321 
             */
22322 
            public static function existsOr($callback)
22323 
            {
22324 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22325 
                                return $instance->existsOr($callback);
22326 
            }
22327 
 
22328 
                /**
22329 
             * Execute the given callback if rows exist for the current query.
22330 
             *
22331 
             * @param \Closure $callback
22332 
             * @return mixed
22333 
             * @static
22334 
             */
22335 
            public static function doesntExistOr($callback)
22336 
            {
22337 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22338 
                                return $instance->doesntExistOr($callback);
22339 
            }
22340 
 
22341 
                /**
22342 
             * Retrieve the "count" result of the query.
22343 
             *
22344 
             * @param string $columns
22345 
             * @return int
22346 
             * @static
22347 
             */
22348 
            public static function count($columns = '*')
22349 
            {
22350 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22351 
                                return $instance->count($columns);
22352 
            }
22353 
 
22354 
                /**
22355 
             * Retrieve the minimum value of a given column.
22356 
             *
22357 
             * @param string $column
22358 
             * @return mixed
22359 
             * @static
22360 
             */
22361 
            public static function min($column)
22362 
            {
22363 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22364 
                                return $instance->min($column);
22365 
            }
22366 
 
22367 
                /**
22368 
             * Retrieve the maximum value of a given column.
22369 
             *
22370 
             * @param string $column
22371 
             * @return mixed
22372 
             * @static
22373 
             */
22374 
            public static function max($column)
22375 
            {
22376 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22377 
                                return $instance->max($column);
22378 
            }
22379 
 
22380 
                /**
22381 
             * Retrieve the sum of the values of a given column.
22382 
             *
22383 
             * @param string $column
22384 
             * @return mixed
22385 
             * @static
22386 
             */
22387 
            public static function sum($column)
22388 
            {
22389 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22390 
                                return $instance->sum($column);
22391 
            }
22392 
 
22393 
                /**
22394 
             * Retrieve the average of the values of a given column.
22395 
             *
22396 
             * @param string $column
22397 
             * @return mixed
22398 
             * @static
22399 
             */
22400 
            public static function avg($column)
22401 
            {
22402 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22403 
                                return $instance->avg($column);
22404 
            }
22405 
 
22406 
                /**
22407 
             * Alias for the "avg" method.
22408 
             *
22409 
             * @param string $column
22410 
             * @return mixed
22411 
             * @static
22412 
             */
22413 
            public static function average($column)
22414 
            {
22415 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22416 
                                return $instance->average($column);
22417 
            }
22418 
 
22419 
                /**
22420 
             * Execute an aggregate function on the database.
22421 
             *
22422 
             * @param string $function
22423 
             * @param array $columns
22424 
             * @return mixed
22425 
             * @static
22426 
             */
22427 
            public static function aggregate($function, $columns = [])
22428 
            {
22429 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22430 
                                return $instance->aggregate($function, $columns);
22431 
            }
22432 
 
22433 
                /**
22434 
             * Execute a numeric aggregate function on the database.
22435 
             *
22436 
             * @param string $function
22437 
             * @param array $columns
22438 
             * @return float|int
22439 
             * @static
22440 
             */
22441 
            public static function numericAggregate($function, $columns = [])
22442 
            {
22443 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22444 
                                return $instance->numericAggregate($function, $columns);
22445 
            }
22446 
 
22447 
                /**
22448 
             * Insert new records into the database.
22449 
             *
22450 
             * @param array $values
22451 
             * @return bool
22452 
             * @static
22453 
             */
22454 
            public static function insert($values)
22455 
            {
22456 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22457 
                                return $instance->insert($values);
22458 
            }
22459 
 
22460 
                /**
22461 
             * Insert new records into the database while ignoring errors.
22462 
             *
22463 
             * @param array $values
22464 
             * @return int
22465 
             * @static
22466 
             */
22467 
            public static function insertOrIgnore($values)
22468 
            {
22469 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22470 
                                return $instance->insertOrIgnore($values);
22471 
            }
22472 
 
22473 
                /**
22474 
             * Insert a new record and get the value of the primary key.
22475 
             *
22476 
             * @param array $values
22477 
             * @param string|null $sequence
22478 
             * @return int
22479 
             * @static
22480 
             */
22481 
            public static function insertGetId($values, $sequence = null)
22482 
            {
22483 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22484 
                                return $instance->insertGetId($values, $sequence);
22485 
            }
22486 
 
22487 
                /**
22488 
             * Insert new records into the table using a subquery.
22489 
             *
22490 
             * @param array $columns
22491 
             * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
22492 
             * @return int
22493 
             * @static
22494 
             */
22495 
            public static function insertUsing($columns, $query)
22496 
            {
22497 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22498 
                                return $instance->insertUsing($columns, $query);
22499 
            }
22500 
 
22501 
                /**
22502 
             * Update records in a PostgreSQL database using the update from syntax.
22503 
             *
22504 
             * @param array $values
22505 
             * @return int
22506 
             * @static
22507 
             */
22508 
            public static function updateFrom($values)
22509 
            {
22510 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22511 
                                return $instance->updateFrom($values);
22512 
            }
22513 
 
22514 
                /**
22515 
             * Insert or update a record matching the attributes, and fill it with values.
22516 
             *
22517 
             * @param array $attributes
22518 
             * @param array $values
22519 
             * @return bool
22520 
             * @static
22521 
             */
22522 
            public static function updateOrInsert($attributes, $values = [])
22523 
            {
22524 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22525 
                                return $instance->updateOrInsert($attributes, $values);
22526 
            }
22527 
 
22528 
                /**
22529 
             * Increment the given column's values by the given amounts.
22530 
             *
22531 
             * @param array<string, float|int|numeric-string> $columns
22532 
             * @param array<string, mixed> $extra
22533 
             * @return int
22534 
             * @throws \InvalidArgumentException
22535 
             * @static
22536 
             */
22537 
            public static function incrementEach($columns, $extra = [])
22538 
            {
22539 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22540 
                                return $instance->incrementEach($columns, $extra);
22541 
            }
22542 
 
22543 
                /**
22544 
             * Decrement the given column's values by the given amounts.
22545 
             *
22546 
             * @param array<string, float|int|numeric-string> $columns
22547 
             * @param array<string, mixed> $extra
22548 
             * @return int
22549 
             * @throws \InvalidArgumentException
22550 
             * @static
22551 
             */
22552 
            public static function decrementEach($columns, $extra = [])
22553 
            {
22554 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22555 
                                return $instance->decrementEach($columns, $extra);
22556 
            }
22557 
 
22558 
                /**
22559 
             * Run a truncate statement on the table.
22560 
             *
22561 
             * @return void
22562 
             * @static
22563 
             */
22564 
            public static function truncate()
22565 
            {
22566 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22567 
                                $instance->truncate();
22568 
            }
22569 
 
22570 
                /**
22571 
             * Create a raw database expression.
22572 
             *
22573 
             * @param mixed $value
22574 
             * @return \Illuminate\Database\Query\Expression
22575 
             * @static
22576 
             */
22577 
            public static function raw($value)
22578 
            {
22579 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22580 
                                return $instance->raw($value);
22581 
            }
22582 
 
22583 
                /**
22584 
             * Get the current query value bindings in a flattened array.
22585 
             *
22586 
             * @return array
22587 
             * @static
22588 
             */
22589 
            public static function getBindings()
22590 
            {
22591 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22592 
                                return $instance->getBindings();
22593 
            }
22594 
 
22595 
                /**
22596 
             * Get the raw array of bindings.
22597 
             *
22598 
             * @return array
22599 
             * @static
22600 
             */
22601 
            public static function getRawBindings()
22602 
            {
22603 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22604 
                                return $instance->getRawBindings();
22605 
            }
22606 
 
22607 
                /**
22608 
             * Set the bindings on the query builder.
22609 
             *
22610 
             * @param array $bindings
22611 
             * @param string $type
22612 
             * @return \Illuminate\Database\Query\Builder
22613 
             * @throws \InvalidArgumentException
22614 
             * @static
22615 
             */
22616 
            public static function setBindings($bindings, $type = 'where')
22617 
            {
22618 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22619 
                                return $instance->setBindings($bindings, $type);
22620 
            }
22621 
 
22622 
                /**
22623 
             * Add a binding to the query.
22624 
             *
22625 
             * @param mixed $value
22626 
             * @param string $type
22627 
             * @return \Illuminate\Database\Query\Builder
22628 
             * @throws \InvalidArgumentException
22629 
             * @static
22630 
             */
22631 
            public static function addBinding($value, $type = 'where')
22632 
            {
22633 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22634 
                                return $instance->addBinding($value, $type);
22635 
            }
22636 
 
22637 
                /**
22638 
             * Cast the given binding value.
22639 
             *
22640 
             * @param mixed $value
22641 
             * @return mixed
22642 
             * @static
22643 
             */
22644 
            public static function castBinding($value)
22645 
            {
22646 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22647 
                                return $instance->castBinding($value);
22648 
            }
22649 
 
22650 
                /**
22651 
             * Merge an array of bindings into our bindings.
22652 
             *
22653 
             * @param \Illuminate\Database\Query\Builder $query
22654 
             * @return \Illuminate\Database\Query\Builder
22655 
             * @static
22656 
             */
22657 
            public static function mergeBindings($query)
22658 
            {
22659 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22660 
                                return $instance->mergeBindings($query);
22661 
            }
22662 
 
22663 
                /**
22664 
             * Remove all of the expressions from a list of bindings.
22665 
             *
22666 
             * @param array $bindings
22667 
             * @return array
22668 
             * @static
22669 
             */
22670 
            public static function cleanBindings($bindings)
22671 
            {
22672 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22673 
                                return $instance->cleanBindings($bindings);
22674 
            }
22675 
 
22676 
                /**
22677 
             * Get the database query processor instance.
22678 
             *
22679 
             * @return \Illuminate\Database\Query\Processors\Processor
22680 
             * @static
22681 
             */
22682 
            public static function getProcessor()
22683 
            {
22684 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22685 
                                return $instance->getProcessor();
22686 
            }
22687 
 
22688 
                /**
22689 
             * Get the query grammar instance.
22690 
             *
22691 
             * @return \Illuminate\Database\Query\Grammars\Grammar
22692 
             * @static
22693 
             */
22694 
            public static function getGrammar()
22695 
            {
22696 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22697 
                                return $instance->getGrammar();
22698 
            }
22699 
 
22700 
                /**
22701 
             * Use the "write" PDO connection when executing the query.
22702 
             *
22703 
             * @return \Illuminate\Database\Query\Builder
22704 
             * @static
22705 
             */
22706 
            public static function useWritePdo()
22707 
            {
22708 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22709 
                                return $instance->useWritePdo();
22710 
            }
22711 
 
22712 
                /**
22713 
             * Clone the query without the given properties.
22714 
             *
22715 
             * @param array $properties
22716 
             * @return static
22717 
             * @static
22718 
             */
22719 
            public static function cloneWithout($properties)
22720 
            {
22721 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22722 
                                return $instance->cloneWithout($properties);
22723 
            }
22724 
 
22725 
                /**
22726 
             * Clone the query without the given bindings.
22727 
             *
22728 
             * @param array $except
22729 
             * @return static
22730 
             * @static
22731 
             */
22732 
            public static function cloneWithoutBindings($except)
22733 
            {
22734 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22735 
                                return $instance->cloneWithoutBindings($except);
22736 
            }
22737 
 
22738 
                /**
22739 
             * Dump the current SQL and bindings.
22740 
             *
22741 
             * @return \Illuminate\Database\Query\Builder
22742 
             * @static
22743 
             */
22744 
            public static function dump()
22745 
            {
22746 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22747 
                                return $instance->dump();
22748 
            }
22749 
 
22750 
                /**
22751 
             * Die and dump the current SQL and bindings.
22752 
             *
22753 
             * @return \Illuminate\Database\Query\never
22754 
             * @static
22755 
             */
22756 
            public static function dd()
22757 
            {
22758 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22759 
                                return $instance->dd();
22760 
            }
22761 
 
22762 
                /**
22763 
             * Explains the query.
22764 
             *
22765 
             * @return \Illuminate\Support\Collection
22766 
             * @static
22767 
             */
22768 
            public static function explain()
22769 
            {
22770 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22771 
                                return $instance->explain();
22772 
            }
22773 
 
22774 
                /**
22775 
             * Register a custom macro.
22776 
             *
22777 
             * @param string $name
22778 
             * @param object|callable $macro
22779 
             * @return void
22780 
             * @static
22781 
             */
22782 
            public static function macro($name, $macro)
22783 
            {
22784 
                                \Illuminate\Database\Query\Builder::macro($name, $macro);
22785 
            }
22786 
 
22787 
                /**
22788 
             * Mix another object into the class.
22789 
             *
22790 
             * @param object $mixin
22791 
             * @param bool $replace
22792 
             * @return void
22793 
             * @throws \ReflectionException
22794 
             * @static
22795 
             */
22796 
            public static function mixin($mixin, $replace = true)
22797 
            {
22798 
                                \Illuminate\Database\Query\Builder::mixin($mixin, $replace);
22799 
            }
22800 
 
22801 
                /**
22802 
             * Flush the existing macros.
22803 
             *
22804 
             * @return void
22805 
             * @static
22806 
             */
22807 
            public static function flushMacros()
22808 
            {
22809 
                                \Illuminate\Database\Query\Builder::flushMacros();
22810 
            }
22811 
 
22812 
                /**
22813 
             * Dynamically handle calls to the class.
22814 
             *
22815 
             * @param string $method
22816 
             * @param array $parameters
22817 
             * @return mixed
22818 
             * @throws \BadMethodCallException
22819 
             * @static
22820 
             */
22821 
            public static function macroCall($method, $parameters)
22822 
            {
22823 
                                /** @var \Illuminate\Database\Query\Builder $instance */
22824 
                                return $instance->macroCall($method, $parameters);
22825 
            }
22826 
                    }
22827 
            class Event extends \Illuminate\Support\Facades\Event {}
22828 
            class File extends \Illuminate\Support\Facades\File {}
22829 
            class Gate extends \Illuminate\Support\Facades\Gate {}
22830 
            class Hash extends \Illuminate\Support\Facades\Hash {}
22831 
            class Http extends \Illuminate\Support\Facades\Http {}
22832 
            class Js extends \Illuminate\Support\Js {}
22833 
            class Lang extends \Illuminate\Support\Facades\Lang {}
22834 
            class Log extends \Illuminate\Support\Facades\Log {}
22835 
            class Mail extends \Illuminate\Support\Facades\Mail {}
22836 
            class Notification extends \Illuminate\Support\Facades\Notification {}
22837 
            class Password extends \Illuminate\Support\Facades\Password {}
22838 
            class Queue extends \Illuminate\Support\Facades\Queue {}
22839 
            class RateLimiter extends \Illuminate\Support\Facades\RateLimiter {}
22840 
            class Redirect extends \Illuminate\Support\Facades\Redirect {}
22841 
            class Request extends \Illuminate\Support\Facades\Request {}
22842 
            class Response extends \Illuminate\Support\Facades\Response {}
22843 
            class Route extends \Illuminate\Support\Facades\Route {}
22844 
            class Schema extends \Illuminate\Support\Facades\Schema {}
22845 
            class Session extends \Illuminate\Support\Facades\Session {}
22846 
            class Storage extends \Illuminate\Support\Facades\Storage {}
22847 
            class Str extends \Illuminate\Support\Str {}
22848 
            class URL extends \Illuminate\Support\Facades\URL {}
22849 
            class Validator extends \Illuminate\Support\Facades\Validator {}
22850 
            class View extends \Illuminate\Support\Facades\View {}
22851 
            class Vite extends \Illuminate\Support\Facades\Vite {}
22852 
            class PayPal extends \Srmklive\PayPal\Facades\PayPal {}
22853 
            class Clockwork extends \Clockwork\Support\Laravel\Facade {}
22854 
            class Google2FA extends \PragmaRX\Google2FALaravel\Facade {}
22855 
            class Flare extends \Spatie\LaravelIgnition\Facades\Flare {}
22856 
 
22857 
}
22858 
 
22859 
 
22860 
 
22861