· 8 years ago · Apr 21, 2018, 04:24 PM
1<?php
2/**
3 * A helper file for Laravel 5, to provide autocomplete information to your IDE
4 * Generated for Laravel 5.6.17 on 2018-04-21 16:19:00.
5 *
6 * This file should not be included in your code, only analyzed by your IDE!
7 *
8 * @author Barry vd. Heuvel <barryvdh@gmail.com>
9 * @see https://github.com/barryvdh/laravel-ide-helper
10 */
11
12namespace Illuminate\Support\Facades {
13
14 class App {
15
16 /**
17 * Get the version number of the application.
18 *
19 * @return string
20 * @static
21 */
22 public static function version()
23 {
24 return \Illuminate\Foundation\Application::version();
25 }
26
27 /**
28 * Run the given array of bootstrap classes.
29 *
30 * @param array $bootstrappers
31 * @return void
32 * @static
33 */
34 public static function bootstrapWith($bootstrappers)
35 {
36 \Illuminate\Foundation\Application::bootstrapWith($bootstrappers);
37 }
38
39 /**
40 * Register a callback to run after loading the environment.
41 *
42 * @param \Closure $callback
43 * @return void
44 * @static
45 */
46 public static function afterLoadingEnvironment($callback)
47 {
48 \Illuminate\Foundation\Application::afterLoadingEnvironment($callback);
49 }
50
51 /**
52 * Register a callback to run before a bootstrapper.
53 *
54 * @param string $bootstrapper
55 * @param \Closure $callback
56 * @return void
57 * @static
58 */
59 public static function beforeBootstrapping($bootstrapper, $callback)
60 {
61 \Illuminate\Foundation\Application::beforeBootstrapping($bootstrapper, $callback);
62 }
63
64 /**
65 * Register a callback to run after a bootstrapper.
66 *
67 * @param string $bootstrapper
68 * @param \Closure $callback
69 * @return void
70 * @static
71 */
72 public static function afterBootstrapping($bootstrapper, $callback)
73 {
74 \Illuminate\Foundation\Application::afterBootstrapping($bootstrapper, $callback);
75 }
76
77 /**
78 * Determine if the application has been bootstrapped before.
79 *
80 * @return bool
81 * @static
82 */
83 public static function hasBeenBootstrapped()
84 {
85 return \Illuminate\Foundation\Application::hasBeenBootstrapped();
86 }
87
88 /**
89 * Set the base path for the application.
90 *
91 * @param string $basePath
92 * @return $this
93 * @static
94 */
95 public static function setBasePath($basePath)
96 {
97 return \Illuminate\Foundation\Application::setBasePath($basePath);
98 }
99
100 /**
101 * Get the path to the application "app" directory.
102 *
103 * @param string $path Optionally, a path to append to the app path
104 * @return string
105 * @static
106 */
107 public static function path($path = '')
108 {
109 return \Illuminate\Foundation\Application::path($path);
110 }
111
112 /**
113 * Get the base path of the Laravel installation.
114 *
115 * @param string $path Optionally, a path to append to the base path
116 * @return string
117 * @static
118 */
119 public static function basePath($path = '')
120 {
121 return \Illuminate\Foundation\Application::basePath($path);
122 }
123
124 /**
125 * Get the path to the bootstrap directory.
126 *
127 * @param string $path Optionally, a path to append to the bootstrap path
128 * @return string
129 * @static
130 */
131 public static function bootstrapPath($path = '')
132 {
133 return \Illuminate\Foundation\Application::bootstrapPath($path);
134 }
135
136 /**
137 * Get the path to the application configuration files.
138 *
139 * @param string $path Optionally, a path to append to the config path
140 * @return string
141 * @static
142 */
143 public static function configPath($path = '')
144 {
145 return \Illuminate\Foundation\Application::configPath($path);
146 }
147
148 /**
149 * Get the path to the database directory.
150 *
151 * @param string $path Optionally, a path to append to the database path
152 * @return string
153 * @static
154 */
155 public static function databasePath($path = '')
156 {
157 return \Illuminate\Foundation\Application::databasePath($path);
158 }
159
160 /**
161 * Set the database directory.
162 *
163 * @param string $path
164 * @return $this
165 * @static
166 */
167 public static function useDatabasePath($path)
168 {
169 return \Illuminate\Foundation\Application::useDatabasePath($path);
170 }
171
172 /**
173 * Get the path to the language files.
174 *
175 * @return string
176 * @static
177 */
178 public static function langPath()
179 {
180 return \Illuminate\Foundation\Application::langPath();
181 }
182
183 /**
184 * Get the path to the public / web directory.
185 *
186 * @return string
187 * @static
188 */
189 public static function publicPath()
190 {
191 return \Illuminate\Foundation\Application::publicPath();
192 }
193
194 /**
195 * Get the path to the storage directory.
196 *
197 * @return string
198 * @static
199 */
200 public static function storagePath()
201 {
202 return \Illuminate\Foundation\Application::storagePath();
203 }
204
205 /**
206 * Set the storage directory.
207 *
208 * @param string $path
209 * @return $this
210 * @static
211 */
212 public static function useStoragePath($path)
213 {
214 return \Illuminate\Foundation\Application::useStoragePath($path);
215 }
216
217 /**
218 * Get the path to the resources directory.
219 *
220 * @param string $path
221 * @return string
222 * @static
223 */
224 public static function resourcePath($path = '')
225 {
226 return \Illuminate\Foundation\Application::resourcePath($path);
227 }
228
229 /**
230 * Get the path to the environment file directory.
231 *
232 * @return string
233 * @static
234 */
235 public static function environmentPath()
236 {
237 return \Illuminate\Foundation\Application::environmentPath();
238 }
239
240 /**
241 * Set the directory for the environment file.
242 *
243 * @param string $path
244 * @return $this
245 * @static
246 */
247 public static function useEnvironmentPath($path)
248 {
249 return \Illuminate\Foundation\Application::useEnvironmentPath($path);
250 }
251
252 /**
253 * Set the environment file to be loaded during bootstrapping.
254 *
255 * @param string $file
256 * @return $this
257 * @static
258 */
259 public static function loadEnvironmentFrom($file)
260 {
261 return \Illuminate\Foundation\Application::loadEnvironmentFrom($file);
262 }
263
264 /**
265 * Get the environment file the application is using.
266 *
267 * @return string
268 * @static
269 */
270 public static function environmentFile()
271 {
272 return \Illuminate\Foundation\Application::environmentFile();
273 }
274
275 /**
276 * Get the fully qualified path to the environment file.
277 *
278 * @return string
279 * @static
280 */
281 public static function environmentFilePath()
282 {
283 return \Illuminate\Foundation\Application::environmentFilePath();
284 }
285
286 /**
287 * Get or check the current application environment.
288 *
289 * @return string|bool
290 * @static
291 */
292 public static function environment()
293 {
294 return \Illuminate\Foundation\Application::environment();
295 }
296
297 /**
298 * Determine if application is in local environment.
299 *
300 * @return bool
301 * @static
302 */
303 public static function isLocal()
304 {
305 return \Illuminate\Foundation\Application::isLocal();
306 }
307
308 /**
309 * Detect the application's current environment.
310 *
311 * @param \Closure $callback
312 * @return string
313 * @static
314 */
315 public static function detectEnvironment($callback)
316 {
317 return \Illuminate\Foundation\Application::detectEnvironment($callback);
318 }
319
320 /**
321 * Determine if the application is running in the console.
322 *
323 * @return bool
324 * @static
325 */
326 public static function runningInConsole()
327 {
328 return \Illuminate\Foundation\Application::runningInConsole();
329 }
330
331 /**
332 * Determine if the application is running unit tests.
333 *
334 * @return bool
335 * @static
336 */
337 public static function runningUnitTests()
338 {
339 return \Illuminate\Foundation\Application::runningUnitTests();
340 }
341
342 /**
343 * Register all of the configured providers.
344 *
345 * @return void
346 * @static
347 */
348 public static function registerConfiguredProviders()
349 {
350 \Illuminate\Foundation\Application::registerConfiguredProviders();
351 }
352
353 /**
354 * Register a service provider with the application.
355 *
356 * @param \Illuminate\Support\ServiceProvider|string $provider
357 * @param array $options
358 * @param bool $force
359 * @return \Illuminate\Support\ServiceProvider
360 * @static
361 */
362 public static function register($provider, $options = array(), $force = false)
363 {
364 return \Illuminate\Foundation\Application::register($provider, $options, $force);
365 }
366
367 /**
368 * Get the registered service provider instance if it exists.
369 *
370 * @param \Illuminate\Support\ServiceProvider|string $provider
371 * @return \Illuminate\Support\ServiceProvider|null
372 * @static
373 */
374 public static function getProvider($provider)
375 {
376 return \Illuminate\Foundation\Application::getProvider($provider);
377 }
378
379 /**
380 * Get the registered service provider instances if any exist.
381 *
382 * @param \Illuminate\Support\ServiceProvider|string $provider
383 * @return array
384 * @static
385 */
386 public static function getProviders($provider)
387 {
388 return \Illuminate\Foundation\Application::getProviders($provider);
389 }
390
391 /**
392 * Resolve a service provider instance from the class name.
393 *
394 * @param string $provider
395 * @return \Illuminate\Support\ServiceProvider
396 * @static
397 */
398 public static function resolveProvider($provider)
399 {
400 return \Illuminate\Foundation\Application::resolveProvider($provider);
401 }
402
403 /**
404 * Load and boot all of the remaining deferred providers.
405 *
406 * @return void
407 * @static
408 */
409 public static function loadDeferredProviders()
410 {
411 \Illuminate\Foundation\Application::loadDeferredProviders();
412 }
413
414 /**
415 * Load the provider for a deferred service.
416 *
417 * @param string $service
418 * @return void
419 * @static
420 */
421 public static function loadDeferredProvider($service)
422 {
423 \Illuminate\Foundation\Application::loadDeferredProvider($service);
424 }
425
426 /**
427 * Register a deferred provider and service.
428 *
429 * @param string $provider
430 * @param string|null $service
431 * @return void
432 * @static
433 */
434 public static function registerDeferredProvider($provider, $service = null)
435 {
436 \Illuminate\Foundation\Application::registerDeferredProvider($provider, $service);
437 }
438
439 /**
440 * Resolve the given type from the container.
441 *
442 * (Overriding Container::make)
443 *
444 * @param string $abstract
445 * @param array $parameters
446 * @return mixed
447 * @static
448 */
449 public static function make($abstract, $parameters = array())
450 {
451 return \Illuminate\Foundation\Application::make($abstract, $parameters);
452 }
453
454 /**
455 * Determine if the given abstract type has been bound.
456 *
457 * (Overriding Container::bound)
458 *
459 * @param string $abstract
460 * @return bool
461 * @static
462 */
463 public static function bound($abstract)
464 {
465 return \Illuminate\Foundation\Application::bound($abstract);
466 }
467
468 /**
469 * Determine if the application has booted.
470 *
471 * @return bool
472 * @static
473 */
474 public static function isBooted()
475 {
476 return \Illuminate\Foundation\Application::isBooted();
477 }
478
479 /**
480 * Boot the application's service providers.
481 *
482 * @return void
483 * @static
484 */
485 public static function boot()
486 {
487 \Illuminate\Foundation\Application::boot();
488 }
489
490 /**
491 * Register a new boot listener.
492 *
493 * @param mixed $callback
494 * @return void
495 * @static
496 */
497 public static function booting($callback)
498 {
499 \Illuminate\Foundation\Application::booting($callback);
500 }
501
502 /**
503 * Register a new "booted" listener.
504 *
505 * @param mixed $callback
506 * @return void
507 * @static
508 */
509 public static function booted($callback)
510 {
511 \Illuminate\Foundation\Application::booted($callback);
512 }
513
514 /**
515 * {@inheritdoc}
516 *
517 * @static
518 */
519 public static function handle($request, $type = 1, $catch = true)
520 {
521 return \Illuminate\Foundation\Application::handle($request, $type, $catch);
522 }
523
524 /**
525 * Determine if middleware has been disabled for the application.
526 *
527 * @return bool
528 * @static
529 */
530 public static function shouldSkipMiddleware()
531 {
532 return \Illuminate\Foundation\Application::shouldSkipMiddleware();
533 }
534
535 /**
536 * Get the path to the cached services.php file.
537 *
538 * @return string
539 * @static
540 */
541 public static function getCachedServicesPath()
542 {
543 return \Illuminate\Foundation\Application::getCachedServicesPath();
544 }
545
546 /**
547 * Get the path to the cached packages.php file.
548 *
549 * @return string
550 * @static
551 */
552 public static function getCachedPackagesPath()
553 {
554 return \Illuminate\Foundation\Application::getCachedPackagesPath();
555 }
556
557 /**
558 * Determine if the application configuration is cached.
559 *
560 * @return bool
561 * @static
562 */
563 public static function configurationIsCached()
564 {
565 return \Illuminate\Foundation\Application::configurationIsCached();
566 }
567
568 /**
569 * Get the path to the configuration cache file.
570 *
571 * @return string
572 * @static
573 */
574 public static function getCachedConfigPath()
575 {
576 return \Illuminate\Foundation\Application::getCachedConfigPath();
577 }
578
579 /**
580 * Determine if the application routes are cached.
581 *
582 * @return bool
583 * @static
584 */
585 public static function routesAreCached()
586 {
587 return \Illuminate\Foundation\Application::routesAreCached();
588 }
589
590 /**
591 * Get the path to the routes cache file.
592 *
593 * @return string
594 * @static
595 */
596 public static function getCachedRoutesPath()
597 {
598 return \Illuminate\Foundation\Application::getCachedRoutesPath();
599 }
600
601 /**
602 * Determine if the application is currently down for maintenance.
603 *
604 * @return bool
605 * @static
606 */
607 public static function isDownForMaintenance()
608 {
609 return \Illuminate\Foundation\Application::isDownForMaintenance();
610 }
611
612 /**
613 * Throw an HttpException with the given data.
614 *
615 * @param int $code
616 * @param string $message
617 * @param array $headers
618 * @return void
619 * @throws \Symfony\Component\HttpKernel\Exception\HttpException
620 * @static
621 */
622 public static function abort($code, $message = '', $headers = array())
623 {
624 \Illuminate\Foundation\Application::abort($code, $message, $headers);
625 }
626
627 /**
628 * Register a terminating callback with the application.
629 *
630 * @param \Closure $callback
631 * @return $this
632 * @static
633 */
634 public static function terminating($callback)
635 {
636 return \Illuminate\Foundation\Application::terminating($callback);
637 }
638
639 /**
640 * Terminate the application.
641 *
642 * @return void
643 * @static
644 */
645 public static function terminate()
646 {
647 \Illuminate\Foundation\Application::terminate();
648 }
649
650 /**
651 * Get the service providers that have been loaded.
652 *
653 * @return array
654 * @static
655 */
656 public static function getLoadedProviders()
657 {
658 return \Illuminate\Foundation\Application::getLoadedProviders();
659 }
660
661 /**
662 * Get the application's deferred services.
663 *
664 * @return array
665 * @static
666 */
667 public static function getDeferredServices()
668 {
669 return \Illuminate\Foundation\Application::getDeferredServices();
670 }
671
672 /**
673 * Set the application's deferred services.
674 *
675 * @param array $services
676 * @return void
677 * @static
678 */
679 public static function setDeferredServices($services)
680 {
681 \Illuminate\Foundation\Application::setDeferredServices($services);
682 }
683
684 /**
685 * Add an array of services to the application's deferred services.
686 *
687 * @param array $services
688 * @return void
689 * @static
690 */
691 public static function addDeferredServices($services)
692 {
693 \Illuminate\Foundation\Application::addDeferredServices($services);
694 }
695
696 /**
697 * Determine if the given service is a deferred service.
698 *
699 * @param string $service
700 * @return bool
701 * @static
702 */
703 public static function isDeferredService($service)
704 {
705 return \Illuminate\Foundation\Application::isDeferredService($service);
706 }
707
708 /**
709 * Configure the real-time facade namespace.
710 *
711 * @param string $namespace
712 * @return void
713 * @static
714 */
715 public static function provideFacades($namespace)
716 {
717 \Illuminate\Foundation\Application::provideFacades($namespace);
718 }
719
720 /**
721 * Get the current application locale.
722 *
723 * @return string
724 * @static
725 */
726 public static function getLocale()
727 {
728 return \Illuminate\Foundation\Application::getLocale();
729 }
730
731 /**
732 * Set the current application locale.
733 *
734 * @param string $locale
735 * @return void
736 * @static
737 */
738 public static function setLocale($locale)
739 {
740 \Illuminate\Foundation\Application::setLocale($locale);
741 }
742
743 /**
744 * Determine if application locale is the given locale.
745 *
746 * @param string $locale
747 * @return bool
748 * @static
749 */
750 public static function isLocale($locale)
751 {
752 return \Illuminate\Foundation\Application::isLocale($locale);
753 }
754
755 /**
756 * Register the core class aliases in the container.
757 *
758 * @return void
759 * @static
760 */
761 public static function registerCoreContainerAliases()
762 {
763 \Illuminate\Foundation\Application::registerCoreContainerAliases();
764 }
765
766 /**
767 * Flush the container of all bindings and resolved instances.
768 *
769 * @return void
770 * @static
771 */
772 public static function flush()
773 {
774 \Illuminate\Foundation\Application::flush();
775 }
776
777 /**
778 * Get the application namespace.
779 *
780 * @return string
781 * @throws \RuntimeException
782 * @static
783 */
784 public static function getNamespace()
785 {
786 return \Illuminate\Foundation\Application::getNamespace();
787 }
788
789 /**
790 * Define a contextual binding.
791 *
792 * @param string $concrete
793 * @return \Illuminate\Contracts\Container\ContextualBindingBuilder
794 * @static
795 */
796 public static function when($concrete)
797 {
798 //Method inherited from \Illuminate\Container\Container
799 return \Illuminate\Foundation\Application::when($concrete);
800 }
801
802 /**
803 * Returns true if the container can return an entry for the given identifier.
804 *
805 * Returns false otherwise.
806 *
807 * `has($id)` returning true does not mean that `get($id)` will not throw an exception.
808 * It does however mean that `get($id)` will not throw a `NotFoundExceptionInterface`.
809 *
810 * @param string $id Identifier of the entry to look for.
811 * @return bool
812 * @static
813 */
814 public static function has($id)
815 {
816 //Method inherited from \Illuminate\Container\Container
817 return \Illuminate\Foundation\Application::has($id);
818 }
819
820 /**
821 * Determine if the given abstract type has been resolved.
822 *
823 * @param string $abstract
824 * @return bool
825 * @static
826 */
827 public static function resolved($abstract)
828 {
829 //Method inherited from \Illuminate\Container\Container
830 return \Illuminate\Foundation\Application::resolved($abstract);
831 }
832
833 /**
834 * Determine if a given type is shared.
835 *
836 * @param string $abstract
837 * @return bool
838 * @static
839 */
840 public static function isShared($abstract)
841 {
842 //Method inherited from \Illuminate\Container\Container
843 return \Illuminate\Foundation\Application::isShared($abstract);
844 }
845
846 /**
847 * Determine if a given string is an alias.
848 *
849 * @param string $name
850 * @return bool
851 * @static
852 */
853 public static function isAlias($name)
854 {
855 //Method inherited from \Illuminate\Container\Container
856 return \Illuminate\Foundation\Application::isAlias($name);
857 }
858
859 /**
860 * Register a binding with the container.
861 *
862 * @param string $abstract
863 * @param \Closure|string|null $concrete
864 * @param bool $shared
865 * @return void
866 * @static
867 */
868 public static function bind($abstract, $concrete = null, $shared = false)
869 {
870 //Method inherited from \Illuminate\Container\Container
871 \Illuminate\Foundation\Application::bind($abstract, $concrete, $shared);
872 }
873
874 /**
875 * Determine if the container has a method binding.
876 *
877 * @param string $method
878 * @return bool
879 * @static
880 */
881 public static function hasMethodBinding($method)
882 {
883 //Method inherited from \Illuminate\Container\Container
884 return \Illuminate\Foundation\Application::hasMethodBinding($method);
885 }
886
887 /**
888 * Bind a callback to resolve with Container::call.
889 *
890 * @param array|string $method
891 * @param \Closure $callback
892 * @return void
893 * @static
894 */
895 public static function bindMethod($method, $callback)
896 {
897 //Method inherited from \Illuminate\Container\Container
898 \Illuminate\Foundation\Application::bindMethod($method, $callback);
899 }
900
901 /**
902 * Get the method binding for the given method.
903 *
904 * @param string $method
905 * @param mixed $instance
906 * @return mixed
907 * @static
908 */
909 public static function callMethodBinding($method, $instance)
910 {
911 //Method inherited from \Illuminate\Container\Container
912 return \Illuminate\Foundation\Application::callMethodBinding($method, $instance);
913 }
914
915 /**
916 * Add a contextual binding to the container.
917 *
918 * @param string $concrete
919 * @param string $abstract
920 * @param \Closure|string $implementation
921 * @return void
922 * @static
923 */
924 public static function addContextualBinding($concrete, $abstract, $implementation)
925 {
926 //Method inherited from \Illuminate\Container\Container
927 \Illuminate\Foundation\Application::addContextualBinding($concrete, $abstract, $implementation);
928 }
929
930 /**
931 * Register a binding if it hasn't already been registered.
932 *
933 * @param string $abstract
934 * @param \Closure|string|null $concrete
935 * @param bool $shared
936 * @return void
937 * @static
938 */
939 public static function bindIf($abstract, $concrete = null, $shared = false)
940 {
941 //Method inherited from \Illuminate\Container\Container
942 \Illuminate\Foundation\Application::bindIf($abstract, $concrete, $shared);
943 }
944
945 /**
946 * Register a shared binding in the container.
947 *
948 * @param string $abstract
949 * @param \Closure|string|null $concrete
950 * @return void
951 * @static
952 */
953 public static function singleton($abstract, $concrete = null)
954 {
955 //Method inherited from \Illuminate\Container\Container
956 \Illuminate\Foundation\Application::singleton($abstract, $concrete);
957 }
958
959 /**
960 * "Extend" an abstract type in the container.
961 *
962 * @param string $abstract
963 * @param \Closure $closure
964 * @return void
965 * @throws \InvalidArgumentException
966 * @static
967 */
968 public static function extend($abstract, $closure)
969 {
970 //Method inherited from \Illuminate\Container\Container
971 \Illuminate\Foundation\Application::extend($abstract, $closure);
972 }
973
974 /**
975 * Register an existing instance as shared in the container.
976 *
977 * @param string $abstract
978 * @param mixed $instance
979 * @return mixed
980 * @static
981 */
982 public static function instance($abstract, $instance)
983 {
984 //Method inherited from \Illuminate\Container\Container
985 return \Illuminate\Foundation\Application::instance($abstract, $instance);
986 }
987
988 /**
989 * Assign a set of tags to a given binding.
990 *
991 * @param array|string $abstracts
992 * @param array|mixed $tags
993 * @return void
994 * @static
995 */
996 public static function tag($abstracts, $tags)
997 {
998 //Method inherited from \Illuminate\Container\Container
999 \Illuminate\Foundation\Application::tag($abstracts, $tags);
1000 }
1001
1002 /**
1003 * Resolve all of the bindings for a given tag.
1004 *
1005 * @param string $tag
1006 * @return array
1007 * @static
1008 */
1009 public static function tagged($tag)
1010 {
1011 //Method inherited from \Illuminate\Container\Container
1012 return \Illuminate\Foundation\Application::tagged($tag);
1013 }
1014
1015 /**
1016 * Alias a type to a different name.
1017 *
1018 * @param string $abstract
1019 * @param string $alias
1020 * @return void
1021 * @static
1022 */
1023 public static function alias($abstract, $alias)
1024 {
1025 //Method inherited from \Illuminate\Container\Container
1026 \Illuminate\Foundation\Application::alias($abstract, $alias);
1027 }
1028
1029 /**
1030 * Bind a new callback to an abstract's rebind event.
1031 *
1032 * @param string $abstract
1033 * @param \Closure $callback
1034 * @return mixed
1035 * @static
1036 */
1037 public static function rebinding($abstract, $callback)
1038 {
1039 //Method inherited from \Illuminate\Container\Container
1040 return \Illuminate\Foundation\Application::rebinding($abstract, $callback);
1041 }
1042
1043 /**
1044 * Refresh an instance on the given target and method.
1045 *
1046 * @param string $abstract
1047 * @param mixed $target
1048 * @param string $method
1049 * @return mixed
1050 * @static
1051 */
1052 public static function refresh($abstract, $target, $method)
1053 {
1054 //Method inherited from \Illuminate\Container\Container
1055 return \Illuminate\Foundation\Application::refresh($abstract, $target, $method);
1056 }
1057
1058 /**
1059 * Wrap the given closure such that its dependencies will be injected when executed.
1060 *
1061 * @param \Closure $callback
1062 * @param array $parameters
1063 * @return \Closure
1064 * @static
1065 */
1066 public static function wrap($callback, $parameters = array())
1067 {
1068 //Method inherited from \Illuminate\Container\Container
1069 return \Illuminate\Foundation\Application::wrap($callback, $parameters);
1070 }
1071
1072 /**
1073 * Call the given Closure / class@method and inject its dependencies.
1074 *
1075 * @param callable|string $callback
1076 * @param array $parameters
1077 * @param string|null $defaultMethod
1078 * @return mixed
1079 * @static
1080 */
1081 public static function call($callback, $parameters = array(), $defaultMethod = null)
1082 {
1083 //Method inherited from \Illuminate\Container\Container
1084 return \Illuminate\Foundation\Application::call($callback, $parameters, $defaultMethod);
1085 }
1086
1087 /**
1088 * Get a closure to resolve the given type from the container.
1089 *
1090 * @param string $abstract
1091 * @return \Closure
1092 * @static
1093 */
1094 public static function factory($abstract)
1095 {
1096 //Method inherited from \Illuminate\Container\Container
1097 return \Illuminate\Foundation\Application::factory($abstract);
1098 }
1099
1100 /**
1101 * An alias function name for make().
1102 *
1103 * @param string $abstract
1104 * @param array $parameters
1105 * @return mixed
1106 * @static
1107 */
1108 public static function makeWith($abstract, $parameters = array())
1109 {
1110 //Method inherited from \Illuminate\Container\Container
1111 return \Illuminate\Foundation\Application::makeWith($abstract, $parameters);
1112 }
1113
1114 /**
1115 * Finds an entry of the container by its identifier and returns it.
1116 *
1117 * @param string $id Identifier of the entry to look for.
1118 * @throws NotFoundExceptionInterface No entry was found for **this** identifier.
1119 * @throws ContainerExceptionInterface Error while retrieving the entry.
1120 * @return mixed Entry.
1121 * @static
1122 */
1123 public static function get($id)
1124 {
1125 //Method inherited from \Illuminate\Container\Container
1126 return \Illuminate\Foundation\Application::get($id);
1127 }
1128
1129 /**
1130 * Instantiate a concrete instance of the given type.
1131 *
1132 * @param string $concrete
1133 * @return mixed
1134 * @throws \Illuminate\Contracts\Container\BindingResolutionException
1135 * @static
1136 */
1137 public static function build($concrete)
1138 {
1139 //Method inherited from \Illuminate\Container\Container
1140 return \Illuminate\Foundation\Application::build($concrete);
1141 }
1142
1143 /**
1144 * Register a new resolving callback.
1145 *
1146 * @param \Closure|string $abstract
1147 * @param \Closure|null $callback
1148 * @return void
1149 * @static
1150 */
1151 public static function resolving($abstract, $callback = null)
1152 {
1153 //Method inherited from \Illuminate\Container\Container
1154 \Illuminate\Foundation\Application::resolving($abstract, $callback);
1155 }
1156
1157 /**
1158 * Register a new after resolving callback for all types.
1159 *
1160 * @param \Closure|string $abstract
1161 * @param \Closure|null $callback
1162 * @return void
1163 * @static
1164 */
1165 public static function afterResolving($abstract, $callback = null)
1166 {
1167 //Method inherited from \Illuminate\Container\Container
1168 \Illuminate\Foundation\Application::afterResolving($abstract, $callback);
1169 }
1170
1171 /**
1172 * Get the container's bindings.
1173 *
1174 * @return array
1175 * @static
1176 */
1177 public static function getBindings()
1178 {
1179 //Method inherited from \Illuminate\Container\Container
1180 return \Illuminate\Foundation\Application::getBindings();
1181 }
1182
1183 /**
1184 * Get the alias for an abstract if available.
1185 *
1186 * @param string $abstract
1187 * @return string
1188 * @throws \LogicException
1189 * @static
1190 */
1191 public static function getAlias($abstract)
1192 {
1193 //Method inherited from \Illuminate\Container\Container
1194 return \Illuminate\Foundation\Application::getAlias($abstract);
1195 }
1196
1197 /**
1198 * Remove all of the extender callbacks for a given type.
1199 *
1200 * @param string $abstract
1201 * @return void
1202 * @static
1203 */
1204 public static function forgetExtenders($abstract)
1205 {
1206 //Method inherited from \Illuminate\Container\Container
1207 \Illuminate\Foundation\Application::forgetExtenders($abstract);
1208 }
1209
1210 /**
1211 * Remove a resolved instance from the instance cache.
1212 *
1213 * @param string $abstract
1214 * @return void
1215 * @static
1216 */
1217 public static function forgetInstance($abstract)
1218 {
1219 //Method inherited from \Illuminate\Container\Container
1220 \Illuminate\Foundation\Application::forgetInstance($abstract);
1221 }
1222
1223 /**
1224 * Clear all of the instances from the container.
1225 *
1226 * @return void
1227 * @static
1228 */
1229 public static function forgetInstances()
1230 {
1231 //Method inherited from \Illuminate\Container\Container
1232 \Illuminate\Foundation\Application::forgetInstances();
1233 }
1234
1235 /**
1236 * Set the globally available instance of the container.
1237 *
1238 * @return static
1239 * @static
1240 */
1241 public static function getInstance()
1242 {
1243 //Method inherited from \Illuminate\Container\Container
1244 return \Illuminate\Foundation\Application::getInstance();
1245 }
1246
1247 /**
1248 * Set the shared instance of the container.
1249 *
1250 * @param \Illuminate\Contracts\Container\Container|null $container
1251 * @return static
1252 * @static
1253 */
1254 public static function setInstance($container = null)
1255 {
1256 //Method inherited from \Illuminate\Container\Container
1257 return \Illuminate\Foundation\Application::setInstance($container);
1258 }
1259
1260 /**
1261 * Determine if a given offset exists.
1262 *
1263 * @param string $key
1264 * @return bool
1265 * @static
1266 */
1267 public static function offsetExists($key)
1268 {
1269 //Method inherited from \Illuminate\Container\Container
1270 return \Illuminate\Foundation\Application::offsetExists($key);
1271 }
1272
1273 /**
1274 * Get the value at a given offset.
1275 *
1276 * @param string $key
1277 * @return mixed
1278 * @static
1279 */
1280 public static function offsetGet($key)
1281 {
1282 //Method inherited from \Illuminate\Container\Container
1283 return \Illuminate\Foundation\Application::offsetGet($key);
1284 }
1285
1286 /**
1287 * Set the value at a given offset.
1288 *
1289 * @param string $key
1290 * @param mixed $value
1291 * @return void
1292 * @static
1293 */
1294 public static function offsetSet($key, $value)
1295 {
1296 //Method inherited from \Illuminate\Container\Container
1297 \Illuminate\Foundation\Application::offsetSet($key, $value);
1298 }
1299
1300 /**
1301 * Unset the value at a given offset.
1302 *
1303 * @param string $key
1304 * @return void
1305 * @static
1306 */
1307 public static function offsetUnset($key)
1308 {
1309 //Method inherited from \Illuminate\Container\Container
1310 \Illuminate\Foundation\Application::offsetUnset($key);
1311 }
1312
1313 }
1314
1315 class Artisan {
1316
1317 /**
1318 * Run the console application.
1319 *
1320 * @param \Symfony\Component\Console\Input\InputInterface $input
1321 * @param \Symfony\Component\Console\Output\OutputInterface $output
1322 * @return int
1323 * @static
1324 */
1325 public static function handle($input, $output = null)
1326 {
1327 //Method inherited from \Illuminate\Foundation\Console\Kernel
1328 return \App\Console\Kernel::handle($input, $output);
1329 }
1330
1331 /**
1332 * Terminate the application.
1333 *
1334 * @param \Symfony\Component\Console\Input\InputInterface $input
1335 * @param int $status
1336 * @return void
1337 * @static
1338 */
1339 public static function terminate($input, $status)
1340 {
1341 //Method inherited from \Illuminate\Foundation\Console\Kernel
1342 \App\Console\Kernel::terminate($input, $status);
1343 }
1344
1345 /**
1346 * Register a Closure based command with the application.
1347 *
1348 * @param string $signature
1349 * @param \Closure $callback
1350 * @return \Illuminate\Foundation\Console\ClosureCommand
1351 * @static
1352 */
1353 public static function command($signature, $callback)
1354 {
1355 //Method inherited from \Illuminate\Foundation\Console\Kernel
1356 return \App\Console\Kernel::command($signature, $callback);
1357 }
1358
1359 /**
1360 * Register the given command with the console application.
1361 *
1362 * @param \Symfony\Component\Console\Command\Command $command
1363 * @return void
1364 * @static
1365 */
1366 public static function registerCommand($command)
1367 {
1368 //Method inherited from \Illuminate\Foundation\Console\Kernel
1369 \App\Console\Kernel::registerCommand($command);
1370 }
1371
1372 /**
1373 * Run an Artisan console command by name.
1374 *
1375 * @param string $command
1376 * @param array $parameters
1377 * @param \Symfony\Component\Console\Output\OutputInterface $outputBuffer
1378 * @return int
1379 * @static
1380 */
1381 public static function call($command, $parameters = array(), $outputBuffer = null)
1382 {
1383 //Method inherited from \Illuminate\Foundation\Console\Kernel
1384 return \App\Console\Kernel::call($command, $parameters, $outputBuffer);
1385 }
1386
1387 /**
1388 * Queue the given console command.
1389 *
1390 * @param string $command
1391 * @param array $parameters
1392 * @return \Illuminate\Foundation\Bus\PendingDispatch
1393 * @static
1394 */
1395 public static function queue($command, $parameters = array())
1396 {
1397 //Method inherited from \Illuminate\Foundation\Console\Kernel
1398 return \App\Console\Kernel::queue($command, $parameters);
1399 }
1400
1401 /**
1402 * Get all of the commands registered with the console.
1403 *
1404 * @return array
1405 * @static
1406 */
1407 public static function all()
1408 {
1409 //Method inherited from \Illuminate\Foundation\Console\Kernel
1410 return \App\Console\Kernel::all();
1411 }
1412
1413 /**
1414 * Get the output for the last run command.
1415 *
1416 * @return string
1417 * @static
1418 */
1419 public static function output()
1420 {
1421 //Method inherited from \Illuminate\Foundation\Console\Kernel
1422 return \App\Console\Kernel::output();
1423 }
1424
1425 /**
1426 * Bootstrap the application for artisan commands.
1427 *
1428 * @return void
1429 * @static
1430 */
1431 public static function bootstrap()
1432 {
1433 //Method inherited from \Illuminate\Foundation\Console\Kernel
1434 \App\Console\Kernel::bootstrap();
1435 }
1436
1437 /**
1438 * Set the Artisan application instance.
1439 *
1440 * @param \Illuminate\Console\Application $artisan
1441 * @return void
1442 * @static
1443 */
1444 public static function setArtisan($artisan)
1445 {
1446 //Method inherited from \Illuminate\Foundation\Console\Kernel
1447 \App\Console\Kernel::setArtisan($artisan);
1448 }
1449
1450 }
1451
1452 class Auth {
1453
1454 /**
1455 * Attempt to get the guard from the local cache.
1456 *
1457 * @param string $name
1458 * @return \Illuminate\Contracts\Auth\Guard|\Illuminate\Contracts\Auth\StatefulGuard
1459 * @static
1460 */
1461 public static function guard($name = null)
1462 {
1463 return \Illuminate\Auth\AuthManager::guard($name);
1464 }
1465
1466 /**
1467 * Create a session based authentication guard.
1468 *
1469 * @param string $name
1470 * @param array $config
1471 * @return \Illuminate\Auth\SessionGuard
1472 * @static
1473 */
1474 public static function createSessionDriver($name, $config)
1475 {
1476 return \Illuminate\Auth\AuthManager::createSessionDriver($name, $config);
1477 }
1478
1479 /**
1480 * Create a token based authentication guard.
1481 *
1482 * @param string $name
1483 * @param array $config
1484 * @return \Illuminate\Auth\TokenGuard
1485 * @static
1486 */
1487 public static function createTokenDriver($name, $config)
1488 {
1489 return \Illuminate\Auth\AuthManager::createTokenDriver($name, $config);
1490 }
1491
1492 /**
1493 * Get the default authentication driver name.
1494 *
1495 * @return string
1496 * @static
1497 */
1498 public static function getDefaultDriver()
1499 {
1500 return \Illuminate\Auth\AuthManager::getDefaultDriver();
1501 }
1502
1503 /**
1504 * Set the default guard driver the factory should serve.
1505 *
1506 * @param string $name
1507 * @return void
1508 * @static
1509 */
1510 public static function shouldUse($name)
1511 {
1512 \Illuminate\Auth\AuthManager::shouldUse($name);
1513 }
1514
1515 /**
1516 * Set the default authentication driver name.
1517 *
1518 * @param string $name
1519 * @return void
1520 * @static
1521 */
1522 public static function setDefaultDriver($name)
1523 {
1524 \Illuminate\Auth\AuthManager::setDefaultDriver($name);
1525 }
1526
1527 /**
1528 * Register a new callback based request guard.
1529 *
1530 * @param string $driver
1531 * @param callable $callback
1532 * @return $this
1533 * @static
1534 */
1535 public static function viaRequest($driver, $callback)
1536 {
1537 return \Illuminate\Auth\AuthManager::viaRequest($driver, $callback);
1538 }
1539
1540 /**
1541 * Get the user resolver callback.
1542 *
1543 * @return \Closure
1544 * @static
1545 */
1546 public static function userResolver()
1547 {
1548 return \Illuminate\Auth\AuthManager::userResolver();
1549 }
1550
1551 /**
1552 * Set the callback to be used to resolve users.
1553 *
1554 * @param \Closure $userResolver
1555 * @return $this
1556 * @static
1557 */
1558 public static function resolveUsersUsing($userResolver)
1559 {
1560 return \Illuminate\Auth\AuthManager::resolveUsersUsing($userResolver);
1561 }
1562
1563 /**
1564 * Register a custom driver creator Closure.
1565 *
1566 * @param string $driver
1567 * @param \Closure $callback
1568 * @return $this
1569 * @static
1570 */
1571 public static function extend($driver, $callback)
1572 {
1573 return \Illuminate\Auth\AuthManager::extend($driver, $callback);
1574 }
1575
1576 /**
1577 * Register a custom provider creator Closure.
1578 *
1579 * @param string $name
1580 * @param \Closure $callback
1581 * @return $this
1582 * @static
1583 */
1584 public static function provider($name, $callback)
1585 {
1586 return \Illuminate\Auth\AuthManager::provider($name, $callback);
1587 }
1588
1589 /**
1590 * Create the user provider implementation for the driver.
1591 *
1592 * @param string|null $provider
1593 * @return \Illuminate\Contracts\Auth\UserProvider|null
1594 * @throws \InvalidArgumentException
1595 * @static
1596 */
1597 public static function createUserProvider($provider = null)
1598 {
1599 return \Illuminate\Auth\AuthManager::createUserProvider($provider);
1600 }
1601
1602 /**
1603 * Get the default user provider name.
1604 *
1605 * @return string
1606 * @static
1607 */
1608 public static function getDefaultUserProvider()
1609 {
1610 return \Illuminate\Auth\AuthManager::getDefaultUserProvider();
1611 }
1612
1613 /**
1614 * Get the currently authenticated user.
1615 *
1616 * @return \App\User|null
1617 * @static
1618 */
1619 public static function user()
1620 {
1621 return \Illuminate\Auth\SessionGuard::user();
1622 }
1623
1624 /**
1625 * Get the ID for the currently authenticated user.
1626 *
1627 * @return int|null
1628 * @static
1629 */
1630 public static function id()
1631 {
1632 return \Illuminate\Auth\SessionGuard::id();
1633 }
1634
1635 /**
1636 * Log a user into the application without sessions or cookies.
1637 *
1638 * @param array $credentials
1639 * @return bool
1640 * @static
1641 */
1642 public static function once($credentials = array())
1643 {
1644 return \Illuminate\Auth\SessionGuard::once($credentials);
1645 }
1646
1647 /**
1648 * Log the given user ID into the application without sessions or cookies.
1649 *
1650 * @param mixed $id
1651 * @return \App\User|false
1652 * @static
1653 */
1654 public static function onceUsingId($id)
1655 {
1656 return \Illuminate\Auth\SessionGuard::onceUsingId($id);
1657 }
1658
1659 /**
1660 * Validate a user's credentials.
1661 *
1662 * @param array $credentials
1663 * @return bool
1664 * @static
1665 */
1666 public static function validate($credentials = array())
1667 {
1668 return \Illuminate\Auth\SessionGuard::validate($credentials);
1669 }
1670
1671 /**
1672 * Attempt to authenticate using HTTP Basic Auth.
1673 *
1674 * @param string $field
1675 * @param array $extraConditions
1676 * @return \Symfony\Component\HttpFoundation\Response|null
1677 * @static
1678 */
1679 public static function basic($field = 'email', $extraConditions = array())
1680 {
1681 return \Illuminate\Auth\SessionGuard::basic($field, $extraConditions);
1682 }
1683
1684 /**
1685 * Perform a stateless HTTP Basic login attempt.
1686 *
1687 * @param string $field
1688 * @param array $extraConditions
1689 * @return \Symfony\Component\HttpFoundation\Response|null
1690 * @static
1691 */
1692 public static function onceBasic($field = 'email', $extraConditions = array())
1693 {
1694 return \Illuminate\Auth\SessionGuard::onceBasic($field, $extraConditions);
1695 }
1696
1697 /**
1698 * Attempt to authenticate a user using the given credentials.
1699 *
1700 * @param array $credentials
1701 * @param bool $remember
1702 * @return bool
1703 * @static
1704 */
1705 public static function attempt($credentials = array(), $remember = false)
1706 {
1707 return \Illuminate\Auth\SessionGuard::attempt($credentials, $remember);
1708 }
1709
1710 /**
1711 * Log the given user ID into the application.
1712 *
1713 * @param mixed $id
1714 * @param bool $remember
1715 * @return \App\User|false
1716 * @static
1717 */
1718 public static function loginUsingId($id, $remember = false)
1719 {
1720 return \Illuminate\Auth\SessionGuard::loginUsingId($id, $remember);
1721 }
1722
1723 /**
1724 * Log a user into the application.
1725 *
1726 * @param \Illuminate\Contracts\Auth\Authenticatable $user
1727 * @param bool $remember
1728 * @return void
1729 * @static
1730 */
1731 public static function login($user, $remember = false)
1732 {
1733 \Illuminate\Auth\SessionGuard::login($user, $remember);
1734 }
1735
1736 /**
1737 * Log the user out of the application.
1738 *
1739 * @return void
1740 * @static
1741 */
1742 public static function logout()
1743 {
1744 \Illuminate\Auth\SessionGuard::logout();
1745 }
1746
1747 /**
1748 * Invalid other sessions for the current user.
1749 *
1750 * The application must be using the AuthenticateSession middleware.
1751 *
1752 * @param string $password
1753 * @param string $attribute
1754 * @return $this
1755 * @static
1756 */
1757 public static function logoutOtherDevices($password, $attribute = 'password')
1758 {
1759 return \Illuminate\Auth\SessionGuard::logoutOtherDevices($password, $attribute);
1760 }
1761
1762 /**
1763 * Register an authentication attempt event listener.
1764 *
1765 * @param mixed $callback
1766 * @return void
1767 * @static
1768 */
1769 public static function attempting($callback)
1770 {
1771 \Illuminate\Auth\SessionGuard::attempting($callback);
1772 }
1773
1774 /**
1775 * Get the last user we attempted to authenticate.
1776 *
1777 * @return \App\User
1778 * @static
1779 */
1780 public static function getLastAttempted()
1781 {
1782 return \Illuminate\Auth\SessionGuard::getLastAttempted();
1783 }
1784
1785 /**
1786 * Get a unique identifier for the auth session value.
1787 *
1788 * @return string
1789 * @static
1790 */
1791 public static function getName()
1792 {
1793 return \Illuminate\Auth\SessionGuard::getName();
1794 }
1795
1796 /**
1797 * Get the name of the cookie used to store the "recaller".
1798 *
1799 * @return string
1800 * @static
1801 */
1802 public static function getRecallerName()
1803 {
1804 return \Illuminate\Auth\SessionGuard::getRecallerName();
1805 }
1806
1807 /**
1808 * Determine if the user was authenticated via "remember me" cookie.
1809 *
1810 * @return bool
1811 * @static
1812 */
1813 public static function viaRemember()
1814 {
1815 return \Illuminate\Auth\SessionGuard::viaRemember();
1816 }
1817
1818 /**
1819 * Get the cookie creator instance used by the guard.
1820 *
1821 * @return \Illuminate\Contracts\Cookie\QueueingFactory
1822 * @throws \RuntimeException
1823 * @static
1824 */
1825 public static function getCookieJar()
1826 {
1827 return \Illuminate\Auth\SessionGuard::getCookieJar();
1828 }
1829
1830 /**
1831 * Set the cookie creator instance used by the guard.
1832 *
1833 * @param \Illuminate\Contracts\Cookie\QueueingFactory $cookie
1834 * @return void
1835 * @static
1836 */
1837 public static function setCookieJar($cookie)
1838 {
1839 \Illuminate\Auth\SessionGuard::setCookieJar($cookie);
1840 }
1841
1842 /**
1843 * Get the event dispatcher instance.
1844 *
1845 * @return \Illuminate\Contracts\Events\Dispatcher
1846 * @static
1847 */
1848 public static function getDispatcher()
1849 {
1850 return \Illuminate\Auth\SessionGuard::getDispatcher();
1851 }
1852
1853 /**
1854 * Set the event dispatcher instance.
1855 *
1856 * @param \Illuminate\Contracts\Events\Dispatcher $events
1857 * @return void
1858 * @static
1859 */
1860 public static function setDispatcher($events)
1861 {
1862 \Illuminate\Auth\SessionGuard::setDispatcher($events);
1863 }
1864
1865 /**
1866 * Get the session store used by the guard.
1867 *
1868 * @return \Illuminate\Contracts\Session\Session
1869 * @static
1870 */
1871 public static function getSession()
1872 {
1873 return \Illuminate\Auth\SessionGuard::getSession();
1874 }
1875
1876 /**
1877 * Return the currently cached user.
1878 *
1879 * @return \App\User|null
1880 * @static
1881 */
1882 public static function getUser()
1883 {
1884 return \Illuminate\Auth\SessionGuard::getUser();
1885 }
1886
1887 /**
1888 * Set the current user.
1889 *
1890 * @param \Illuminate\Contracts\Auth\Authenticatable $user
1891 * @return $this
1892 * @static
1893 */
1894 public static function setUser($user)
1895 {
1896 return \Illuminate\Auth\SessionGuard::setUser($user);
1897 }
1898
1899 /**
1900 * Get the current request instance.
1901 *
1902 * @return \Symfony\Component\HttpFoundation\Request
1903 * @static
1904 */
1905 public static function getRequest()
1906 {
1907 return \Illuminate\Auth\SessionGuard::getRequest();
1908 }
1909
1910 /**
1911 * Set the current request instance.
1912 *
1913 * @param \Symfony\Component\HttpFoundation\Request $request
1914 * @return $this
1915 * @static
1916 */
1917 public static function setRequest($request)
1918 {
1919 return \Illuminate\Auth\SessionGuard::setRequest($request);
1920 }
1921
1922 /**
1923 * Determine if the current user is authenticated.
1924 *
1925 * @return \App\User
1926 * @throws \Illuminate\Auth\AuthenticationException
1927 * @static
1928 */
1929 public static function authenticate()
1930 {
1931 return \Illuminate\Auth\SessionGuard::authenticate();
1932 }
1933
1934 /**
1935 * Determine if the current user is authenticated.
1936 *
1937 * @return bool
1938 * @static
1939 */
1940 public static function check()
1941 {
1942 return \Illuminate\Auth\SessionGuard::check();
1943 }
1944
1945 /**
1946 * Determine if the current user is a guest.
1947 *
1948 * @return bool
1949 * @static
1950 */
1951 public static function guest()
1952 {
1953 return \Illuminate\Auth\SessionGuard::guest();
1954 }
1955
1956 /**
1957 * Get the user provider used by the guard.
1958 *
1959 * @return \Illuminate\Contracts\Auth\UserProvider
1960 * @static
1961 */
1962 public static function getProvider()
1963 {
1964 return \Illuminate\Auth\SessionGuard::getProvider();
1965 }
1966
1967 /**
1968 * Set the user provider used by the guard.
1969 *
1970 * @param \Illuminate\Contracts\Auth\UserProvider $provider
1971 * @return void
1972 * @static
1973 */
1974 public static function setProvider($provider)
1975 {
1976 \Illuminate\Auth\SessionGuard::setProvider($provider);
1977 }
1978
1979 /**
1980 * Register a custom macro.
1981 *
1982 * @param string $name
1983 * @param object|callable $macro
1984 * @return void
1985 * @static
1986 */
1987 public static function macro($name, $macro)
1988 {
1989 \Illuminate\Auth\SessionGuard::macro($name, $macro);
1990 }
1991
1992 /**
1993 * Mix another object into the class.
1994 *
1995 * @param object $mixin
1996 * @return void
1997 * @throws \ReflectionException
1998 * @static
1999 */
2000 public static function mixin($mixin)
2001 {
2002 \Illuminate\Auth\SessionGuard::mixin($mixin);
2003 }
2004
2005 /**
2006 * Checks if macro is registered.
2007 *
2008 * @param string $name
2009 * @return bool
2010 * @static
2011 */
2012 public static function hasMacro($name)
2013 {
2014 return \Illuminate\Auth\SessionGuard::hasMacro($name);
2015 }
2016
2017 }
2018
2019 class Blade {
2020
2021 /**
2022 * Compile the view at the given path.
2023 *
2024 * @param string $path
2025 * @return void
2026 * @static
2027 */
2028 public static function compile($path = null)
2029 {
2030 \Illuminate\View\Compilers\BladeCompiler::compile($path);
2031 }
2032
2033 /**
2034 * Get the path currently being compiled.
2035 *
2036 * @return string
2037 * @static
2038 */
2039 public static function getPath()
2040 {
2041 return \Illuminate\View\Compilers\BladeCompiler::getPath();
2042 }
2043
2044 /**
2045 * Set the path currently being compiled.
2046 *
2047 * @param string $path
2048 * @return void
2049 * @static
2050 */
2051 public static function setPath($path)
2052 {
2053 \Illuminate\View\Compilers\BladeCompiler::setPath($path);
2054 }
2055
2056 /**
2057 * Compile the given Blade template contents.
2058 *
2059 * @param string $value
2060 * @return string
2061 * @static
2062 */
2063 public static function compileString($value)
2064 {
2065 return \Illuminate\View\Compilers\BladeCompiler::compileString($value);
2066 }
2067
2068 /**
2069 * Strip the parentheses from the given expression.
2070 *
2071 * @param string $expression
2072 * @return string
2073 * @static
2074 */
2075 public static function stripParentheses($expression)
2076 {
2077 return \Illuminate\View\Compilers\BladeCompiler::stripParentheses($expression);
2078 }
2079
2080 /**
2081 * Register a custom Blade compiler.
2082 *
2083 * @param callable $compiler
2084 * @return void
2085 * @static
2086 */
2087 public static function extend($compiler)
2088 {
2089 \Illuminate\View\Compilers\BladeCompiler::extend($compiler);
2090 }
2091
2092 /**
2093 * Get the extensions used by the compiler.
2094 *
2095 * @return array
2096 * @static
2097 */
2098 public static function getExtensions()
2099 {
2100 return \Illuminate\View\Compilers\BladeCompiler::getExtensions();
2101 }
2102
2103 /**
2104 * Register an "if" statement directive.
2105 *
2106 * @param string $name
2107 * @param callable $callback
2108 * @return void
2109 * @static
2110 */
2111 public static function if($name, $callback)
2112 {
2113 \Illuminate\View\Compilers\BladeCompiler::if($name, $callback);
2114 }
2115
2116 /**
2117 * Check the result of a condition.
2118 *
2119 * @param string $name
2120 * @param array $parameters
2121 * @return bool
2122 * @static
2123 */
2124 public static function check($name, $parameters = null)
2125 {
2126 return \Illuminate\View\Compilers\BladeCompiler::check($name, $parameters);
2127 }
2128
2129 /**
2130 * Register a component alias directive.
2131 *
2132 * @param string $path
2133 * @param string $alias
2134 * @return void
2135 * @static
2136 */
2137 public static function component($path, $alias = null)
2138 {
2139 \Illuminate\View\Compilers\BladeCompiler::component($path, $alias);
2140 }
2141
2142 /**
2143 * Register an include alias directive.
2144 *
2145 * @param string $path
2146 * @param string $alias
2147 * @return void
2148 * @static
2149 */
2150 public static function include($path, $alias = null)
2151 {
2152 \Illuminate\View\Compilers\BladeCompiler::include($path, $alias);
2153 }
2154
2155 /**
2156 * Register a handler for custom directives.
2157 *
2158 * @param string $name
2159 * @param callable $handler
2160 * @return void
2161 * @static
2162 */
2163 public static function directive($name, $handler)
2164 {
2165 \Illuminate\View\Compilers\BladeCompiler::directive($name, $handler);
2166 }
2167
2168 /**
2169 * Get the list of custom directives.
2170 *
2171 * @return array
2172 * @static
2173 */
2174 public static function getCustomDirectives()
2175 {
2176 return \Illuminate\View\Compilers\BladeCompiler::getCustomDirectives();
2177 }
2178
2179 /**
2180 * Set the echo format to be used by the compiler.
2181 *
2182 * @param string $format
2183 * @return void
2184 * @static
2185 */
2186 public static function setEchoFormat($format)
2187 {
2188 \Illuminate\View\Compilers\BladeCompiler::setEchoFormat($format);
2189 }
2190
2191 /**
2192 * Set the "echo" format to double encode entities.
2193 *
2194 * @return void
2195 * @static
2196 */
2197 public static function withDoubleEncoding()
2198 {
2199 \Illuminate\View\Compilers\BladeCompiler::withDoubleEncoding();
2200 }
2201
2202 /**
2203 * Set the "echo" format to not double encode entities.
2204 *
2205 * @return void
2206 * @static
2207 */
2208 public static function withoutDoubleEncoding()
2209 {
2210 \Illuminate\View\Compilers\BladeCompiler::withoutDoubleEncoding();
2211 }
2212
2213 /**
2214 * Get the path to the compiled version of a view.
2215 *
2216 * @param string $path
2217 * @return string
2218 * @static
2219 */
2220 public static function getCompiledPath($path)
2221 {
2222 //Method inherited from \Illuminate\View\Compilers\Compiler
2223 return \Illuminate\View\Compilers\BladeCompiler::getCompiledPath($path);
2224 }
2225
2226 /**
2227 * Determine if the view at the given path is expired.
2228 *
2229 * @param string $path
2230 * @return bool
2231 * @static
2232 */
2233 public static function isExpired($path)
2234 {
2235 //Method inherited from \Illuminate\View\Compilers\Compiler
2236 return \Illuminate\View\Compilers\BladeCompiler::isExpired($path);
2237 }
2238
2239 /**
2240 * Compile the default values for the echo statement.
2241 *
2242 * @param string $value
2243 * @return string
2244 * @static
2245 */
2246 public static function compileEchoDefaults($value)
2247 {
2248 return \Illuminate\View\Compilers\BladeCompiler::compileEchoDefaults($value);
2249 }
2250
2251 }
2252
2253 class Broadcast {
2254
2255 /**
2256 * Register the routes for handling broadcast authentication and sockets.
2257 *
2258 * @param array|null $attributes
2259 * @return void
2260 * @static
2261 */
2262 public static function routes($attributes = null)
2263 {
2264 \Illuminate\Broadcasting\BroadcastManager::routes($attributes);
2265 }
2266
2267 /**
2268 * Get the socket ID for the given request.
2269 *
2270 * @param \Illuminate\Http\Request|null $request
2271 * @return string|null
2272 * @static
2273 */
2274 public static function socket($request = null)
2275 {
2276 return \Illuminate\Broadcasting\BroadcastManager::socket($request);
2277 }
2278
2279 /**
2280 * Begin broadcasting an event.
2281 *
2282 * @param mixed|null $event
2283 * @return \Illuminate\Broadcasting\PendingBroadcast|void
2284 * @static
2285 */
2286 public static function event($event = null)
2287 {
2288 return \Illuminate\Broadcasting\BroadcastManager::event($event);
2289 }
2290
2291 /**
2292 * Queue the given event for broadcast.
2293 *
2294 * @param mixed $event
2295 * @return void
2296 * @static
2297 */
2298 public static function queue($event)
2299 {
2300 \Illuminate\Broadcasting\BroadcastManager::queue($event);
2301 }
2302
2303 /**
2304 * Get a driver instance.
2305 *
2306 * @param string $driver
2307 * @return mixed
2308 * @static
2309 */
2310 public static function connection($driver = null)
2311 {
2312 return \Illuminate\Broadcasting\BroadcastManager::connection($driver);
2313 }
2314
2315 /**
2316 * Get a driver instance.
2317 *
2318 * @param string|null $name
2319 * @return mixed
2320 * @static
2321 */
2322 public static function driver($name = null)
2323 {
2324 return \Illuminate\Broadcasting\BroadcastManager::driver($name);
2325 }
2326
2327 /**
2328 * Get the default driver name.
2329 *
2330 * @return string
2331 * @static
2332 */
2333 public static function getDefaultDriver()
2334 {
2335 return \Illuminate\Broadcasting\BroadcastManager::getDefaultDriver();
2336 }
2337
2338 /**
2339 * Set the default driver name.
2340 *
2341 * @param string $name
2342 * @return void
2343 * @static
2344 */
2345 public static function setDefaultDriver($name)
2346 {
2347 \Illuminate\Broadcasting\BroadcastManager::setDefaultDriver($name);
2348 }
2349
2350 /**
2351 * Register a custom driver creator Closure.
2352 *
2353 * @param string $driver
2354 * @param \Closure $callback
2355 * @return $this
2356 * @static
2357 */
2358 public static function extend($driver, $callback)
2359 {
2360 return \Illuminate\Broadcasting\BroadcastManager::extend($driver, $callback);
2361 }
2362
2363 }
2364
2365 class Bus {
2366
2367 /**
2368 * Dispatch a command to its appropriate handler.
2369 *
2370 * @param mixed $command
2371 * @return mixed
2372 * @static
2373 */
2374 public static function dispatch($command)
2375 {
2376 return \Illuminate\Bus\Dispatcher::dispatch($command);
2377 }
2378
2379 /**
2380 * Dispatch a command to its appropriate handler in the current process.
2381 *
2382 * @param mixed $command
2383 * @param mixed $handler
2384 * @return mixed
2385 * @static
2386 */
2387 public static function dispatchNow($command, $handler = null)
2388 {
2389 return \Illuminate\Bus\Dispatcher::dispatchNow($command, $handler);
2390 }
2391
2392 /**
2393 * Determine if the given command has a handler.
2394 *
2395 * @param mixed $command
2396 * @return bool
2397 * @static
2398 */
2399 public static function hasCommandHandler($command)
2400 {
2401 return \Illuminate\Bus\Dispatcher::hasCommandHandler($command);
2402 }
2403
2404 /**
2405 * Retrieve the handler for a command.
2406 *
2407 * @param mixed $command
2408 * @return bool|mixed
2409 * @static
2410 */
2411 public static function getCommandHandler($command)
2412 {
2413 return \Illuminate\Bus\Dispatcher::getCommandHandler($command);
2414 }
2415
2416 /**
2417 * Dispatch a command to its appropriate handler behind a queue.
2418 *
2419 * @param mixed $command
2420 * @return mixed
2421 * @throws \RuntimeException
2422 * @static
2423 */
2424 public static function dispatchToQueue($command)
2425 {
2426 return \Illuminate\Bus\Dispatcher::dispatchToQueue($command);
2427 }
2428
2429 /**
2430 * Set the pipes through which commands should be piped before dispatching.
2431 *
2432 * @param array $pipes
2433 * @return $this
2434 * @static
2435 */
2436 public static function pipeThrough($pipes)
2437 {
2438 return \Illuminate\Bus\Dispatcher::pipeThrough($pipes);
2439 }
2440
2441 /**
2442 * Map a command to a handler.
2443 *
2444 * @param array $map
2445 * @return $this
2446 * @static
2447 */
2448 public static function map($map)
2449 {
2450 return \Illuminate\Bus\Dispatcher::map($map);
2451 }
2452
2453 }
2454
2455 class Cache {
2456
2457 /**
2458 * Get a cache store instance by name.
2459 *
2460 * @param string|null $name
2461 * @return \Illuminate\Contracts\Cache\Repository
2462 * @static
2463 */
2464 public static function store($name = null)
2465 {
2466 return \Illuminate\Cache\CacheManager::store($name);
2467 }
2468
2469 /**
2470 * Get a cache driver instance.
2471 *
2472 * @param string|null $driver
2473 * @return mixed
2474 * @static
2475 */
2476 public static function driver($driver = null)
2477 {
2478 return \Illuminate\Cache\CacheManager::driver($driver);
2479 }
2480
2481 /**
2482 * Create a new cache repository with the given implementation.
2483 *
2484 * @param \Illuminate\Contracts\Cache\Store $store
2485 * @return \Illuminate\Cache\Repository
2486 * @static
2487 */
2488 public static function repository($store)
2489 {
2490 return \Illuminate\Cache\CacheManager::repository($store);
2491 }
2492
2493 /**
2494 * Get the default cache driver name.
2495 *
2496 * @return string
2497 * @static
2498 */
2499 public static function getDefaultDriver()
2500 {
2501 return \Illuminate\Cache\CacheManager::getDefaultDriver();
2502 }
2503
2504 /**
2505 * Set the default cache driver name.
2506 *
2507 * @param string $name
2508 * @return void
2509 * @static
2510 */
2511 public static function setDefaultDriver($name)
2512 {
2513 \Illuminate\Cache\CacheManager::setDefaultDriver($name);
2514 }
2515
2516 /**
2517 * Register a custom driver creator Closure.
2518 *
2519 * @param string $driver
2520 * @param \Closure $callback
2521 * @return $this
2522 * @static
2523 */
2524 public static function extend($driver, $callback)
2525 {
2526 return \Illuminate\Cache\CacheManager::extend($driver, $callback);
2527 }
2528
2529 /**
2530 * Determine if an item exists in the cache.
2531 *
2532 * @param string $key
2533 * @return bool
2534 * @static
2535 */
2536 public static function has($key)
2537 {
2538 return \Illuminate\Cache\Repository::has($key);
2539 }
2540
2541 /**
2542 * Retrieve an item from the cache by key.
2543 *
2544 * @param string $key
2545 * @param mixed $default
2546 * @return mixed
2547 * @static
2548 */
2549 public static function get($key, $default = null)
2550 {
2551 return \Illuminate\Cache\Repository::get($key, $default);
2552 }
2553
2554 /**
2555 * Retrieve multiple items from the cache by key.
2556 *
2557 * Items not found in the cache will have a null value.
2558 *
2559 * @param array $keys
2560 * @return array
2561 * @static
2562 */
2563 public static function many($keys)
2564 {
2565 return \Illuminate\Cache\Repository::many($keys);
2566 }
2567
2568 /**
2569 * Obtains multiple cache items by their unique keys.
2570 *
2571 * @param \Psr\SimpleCache\iterable $keys A list of keys that can obtained in a single operation.
2572 * @param mixed $default Default value to return for keys that do not exist.
2573 * @return \Psr\SimpleCache\iterable A list of key => value pairs. Cache keys that do not exist or are stale will have $default as value.
2574 * @throws \Psr\SimpleCache\InvalidArgumentException
2575 * MUST be thrown if $keys is neither an array nor a Traversable,
2576 * or if any of the $keys are not a legal value.
2577 * @static
2578 */
2579 public static function getMultiple($keys, $default = null)
2580 {
2581 return \Illuminate\Cache\Repository::getMultiple($keys, $default);
2582 }
2583
2584 /**
2585 * Retrieve an item from the cache and delete it.
2586 *
2587 * @param string $key
2588 * @param mixed $default
2589 * @return mixed
2590 * @static
2591 */
2592 public static function pull($key, $default = null)
2593 {
2594 return \Illuminate\Cache\Repository::pull($key, $default);
2595 }
2596
2597 /**
2598 * Store an item in the cache.
2599 *
2600 * @param string $key
2601 * @param mixed $value
2602 * @param \DateTimeInterface|\DateInterval|float|int|null $minutes
2603 * @return void
2604 * @static
2605 */
2606 public static function put($key, $value, $minutes = null)
2607 {
2608 \Illuminate\Cache\Repository::put($key, $value, $minutes);
2609 }
2610
2611 /**
2612 * Persists data in the cache, uniquely referenced by a key with an optional expiration TTL time.
2613 *
2614 * @param string $key The key of the item to store.
2615 * @param mixed $value The value of the item to store, must be serializable.
2616 * @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and
2617 * the driver supports TTL then the library may set a default value
2618 * for it or let the driver take care of that.
2619 * @return bool True on success and false on failure.
2620 * @throws \Psr\SimpleCache\InvalidArgumentException
2621 * MUST be thrown if the $key string is not a legal value.
2622 * @static
2623 */
2624 public static function set($key, $value, $ttl = null)
2625 {
2626 return \Illuminate\Cache\Repository::set($key, $value, $ttl);
2627 }
2628
2629 /**
2630 * Store multiple items in the cache for a given number of minutes.
2631 *
2632 * @param array $values
2633 * @param \DateTimeInterface|\DateInterval|float|int $minutes
2634 * @return void
2635 * @static
2636 */
2637 public static function putMany($values, $minutes)
2638 {
2639 \Illuminate\Cache\Repository::putMany($values, $minutes);
2640 }
2641
2642 /**
2643 * Persists a set of key => value pairs in the cache, with an optional TTL.
2644 *
2645 * @param \Psr\SimpleCache\iterable $values A list of key => value pairs for a multiple-set operation.
2646 * @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and
2647 * the driver supports TTL then the library may set a default value
2648 * for it or let the driver take care of that.
2649 * @return bool True on success and false on failure.
2650 * @throws \Psr\SimpleCache\InvalidArgumentException
2651 * MUST be thrown if $values is neither an array nor a Traversable,
2652 * or if any of the $values are not a legal value.
2653 * @static
2654 */
2655 public static function setMultiple($values, $ttl = null)
2656 {
2657 return \Illuminate\Cache\Repository::setMultiple($values, $ttl);
2658 }
2659
2660 /**
2661 * Store an item in the cache if the key does not exist.
2662 *
2663 * @param string $key
2664 * @param mixed $value
2665 * @param \DateTimeInterface|\DateInterval|float|int $minutes
2666 * @return bool
2667 * @static
2668 */
2669 public static function add($key, $value, $minutes)
2670 {
2671 return \Illuminate\Cache\Repository::add($key, $value, $minutes);
2672 }
2673
2674 /**
2675 * Increment the value of an item in the cache.
2676 *
2677 * @param string $key
2678 * @param mixed $value
2679 * @return int|bool
2680 * @static
2681 */
2682 public static function increment($key, $value = 1)
2683 {
2684 return \Illuminate\Cache\Repository::increment($key, $value);
2685 }
2686
2687 /**
2688 * Decrement the value of an item in the cache.
2689 *
2690 * @param string $key
2691 * @param mixed $value
2692 * @return int|bool
2693 * @static
2694 */
2695 public static function decrement($key, $value = 1)
2696 {
2697 return \Illuminate\Cache\Repository::decrement($key, $value);
2698 }
2699
2700 /**
2701 * Store an item in the cache indefinitely.
2702 *
2703 * @param string $key
2704 * @param mixed $value
2705 * @return void
2706 * @static
2707 */
2708 public static function forever($key, $value)
2709 {
2710 \Illuminate\Cache\Repository::forever($key, $value);
2711 }
2712
2713 /**
2714 * Get an item from the cache, or store the default value.
2715 *
2716 * @param string $key
2717 * @param \DateTimeInterface|\DateInterval|float|int $minutes
2718 * @param \Closure $callback
2719 * @return mixed
2720 * @static
2721 */
2722 public static function remember($key, $minutes, $callback)
2723 {
2724 return \Illuminate\Cache\Repository::remember($key, $minutes, $callback);
2725 }
2726
2727 /**
2728 * Get an item from the cache, or store the default value forever.
2729 *
2730 * @param string $key
2731 * @param \Closure $callback
2732 * @return mixed
2733 * @static
2734 */
2735 public static function sear($key, $callback)
2736 {
2737 return \Illuminate\Cache\Repository::sear($key, $callback);
2738 }
2739
2740 /**
2741 * Get an item from the cache, or store the default value forever.
2742 *
2743 * @param string $key
2744 * @param \Closure $callback
2745 * @return mixed
2746 * @static
2747 */
2748 public static function rememberForever($key, $callback)
2749 {
2750 return \Illuminate\Cache\Repository::rememberForever($key, $callback);
2751 }
2752
2753 /**
2754 * Remove an item from the cache.
2755 *
2756 * @param string $key
2757 * @return bool
2758 * @static
2759 */
2760 public static function forget($key)
2761 {
2762 return \Illuminate\Cache\Repository::forget($key);
2763 }
2764
2765 /**
2766 * Delete an item from the cache by its unique key.
2767 *
2768 * @param string $key The unique cache key of the item to delete.
2769 * @return bool True if the item was successfully removed. False if there was an error.
2770 * @throws \Psr\SimpleCache\InvalidArgumentException
2771 * MUST be thrown if the $key string is not a legal value.
2772 * @static
2773 */
2774 public static function delete($key)
2775 {
2776 return \Illuminate\Cache\Repository::delete($key);
2777 }
2778
2779 /**
2780 * Deletes multiple cache items in a single operation.
2781 *
2782 * @param \Psr\SimpleCache\iterable $keys A list of string-based keys to be deleted.
2783 * @return bool True if the items were successfully removed. False if there was an error.
2784 * @throws \Psr\SimpleCache\InvalidArgumentException
2785 * MUST be thrown if $keys is neither an array nor a Traversable,
2786 * or if any of the $keys are not a legal value.
2787 * @static
2788 */
2789 public static function deleteMultiple($keys)
2790 {
2791 return \Illuminate\Cache\Repository::deleteMultiple($keys);
2792 }
2793
2794 /**
2795 * Wipes clean the entire cache's keys.
2796 *
2797 * @return bool True on success and false on failure.
2798 * @static
2799 */
2800 public static function clear()
2801 {
2802 return \Illuminate\Cache\Repository::clear();
2803 }
2804
2805 /**
2806 * Begin executing a new tags operation if the store supports it.
2807 *
2808 * @param array|mixed $names
2809 * @return \Illuminate\Cache\TaggedCache
2810 * @throws \BadMethodCallException
2811 * @static
2812 */
2813 public static function tags($names)
2814 {
2815 return \Illuminate\Cache\Repository::tags($names);
2816 }
2817
2818 /**
2819 * Get the default cache time.
2820 *
2821 * @return float|int
2822 * @static
2823 */
2824 public static function getDefaultCacheTime()
2825 {
2826 return \Illuminate\Cache\Repository::getDefaultCacheTime();
2827 }
2828
2829 /**
2830 * Set the default cache time in minutes.
2831 *
2832 * @param float|int $minutes
2833 * @return $this
2834 * @static
2835 */
2836 public static function setDefaultCacheTime($minutes)
2837 {
2838 return \Illuminate\Cache\Repository::setDefaultCacheTime($minutes);
2839 }
2840
2841 /**
2842 * Get the cache store implementation.
2843 *
2844 * @return \Illuminate\Contracts\Cache\Store
2845 * @static
2846 */
2847 public static function getStore()
2848 {
2849 return \Illuminate\Cache\Repository::getStore();
2850 }
2851
2852 /**
2853 * Set the event dispatcher instance.
2854 *
2855 * @param \Illuminate\Contracts\Events\Dispatcher $events
2856 * @return void
2857 * @static
2858 */
2859 public static function setEventDispatcher($events)
2860 {
2861 \Illuminate\Cache\Repository::setEventDispatcher($events);
2862 }
2863
2864 /**
2865 * Determine if a cached value exists.
2866 *
2867 * @param string $key
2868 * @return bool
2869 * @static
2870 */
2871 public static function offsetExists($key)
2872 {
2873 return \Illuminate\Cache\Repository::offsetExists($key);
2874 }
2875
2876 /**
2877 * Retrieve an item from the cache by key.
2878 *
2879 * @param string $key
2880 * @return mixed
2881 * @static
2882 */
2883 public static function offsetGet($key)
2884 {
2885 return \Illuminate\Cache\Repository::offsetGet($key);
2886 }
2887
2888 /**
2889 * Store an item in the cache for the default time.
2890 *
2891 * @param string $key
2892 * @param mixed $value
2893 * @return void
2894 * @static
2895 */
2896 public static function offsetSet($key, $value)
2897 {
2898 \Illuminate\Cache\Repository::offsetSet($key, $value);
2899 }
2900
2901 /**
2902 * Remove an item from the cache.
2903 *
2904 * @param string $key
2905 * @return void
2906 * @static
2907 */
2908 public static function offsetUnset($key)
2909 {
2910 \Illuminate\Cache\Repository::offsetUnset($key);
2911 }
2912
2913 /**
2914 * Register a custom macro.
2915 *
2916 * @param string $name
2917 * @param object|callable $macro
2918 * @return void
2919 * @static
2920 */
2921 public static function macro($name, $macro)
2922 {
2923 \Illuminate\Cache\Repository::macro($name, $macro);
2924 }
2925
2926 /**
2927 * Mix another object into the class.
2928 *
2929 * @param object $mixin
2930 * @return void
2931 * @throws \ReflectionException
2932 * @static
2933 */
2934 public static function mixin($mixin)
2935 {
2936 \Illuminate\Cache\Repository::mixin($mixin);
2937 }
2938
2939 /**
2940 * Checks if macro is registered.
2941 *
2942 * @param string $name
2943 * @return bool
2944 * @static
2945 */
2946 public static function hasMacro($name)
2947 {
2948 return \Illuminate\Cache\Repository::hasMacro($name);
2949 }
2950
2951 /**
2952 * Dynamically handle calls to the class.
2953 *
2954 * @param string $method
2955 * @param array $parameters
2956 * @return mixed
2957 * @throws \BadMethodCallException
2958 * @static
2959 */
2960 public static function macroCall($method, $parameters)
2961 {
2962 return \Illuminate\Cache\Repository::macroCall($method, $parameters);
2963 }
2964
2965 /**
2966 * Remove all items from the cache.
2967 *
2968 * @return bool
2969 * @static
2970 */
2971 public static function flush()
2972 {
2973 return \Illuminate\Cache\FileStore::flush();
2974 }
2975
2976 /**
2977 * Get the Filesystem instance.
2978 *
2979 * @return \Illuminate\Filesystem\Filesystem
2980 * @static
2981 */
2982 public static function getFilesystem()
2983 {
2984 return \Illuminate\Cache\FileStore::getFilesystem();
2985 }
2986
2987 /**
2988 * Get the working directory of the cache.
2989 *
2990 * @return string
2991 * @static
2992 */
2993 public static function getDirectory()
2994 {
2995 return \Illuminate\Cache\FileStore::getDirectory();
2996 }
2997
2998 /**
2999 * Get the cache key prefix.
3000 *
3001 * @return string
3002 * @static
3003 */
3004 public static function getPrefix()
3005 {
3006 return \Illuminate\Cache\FileStore::getPrefix();
3007 }
3008
3009 }
3010
3011 class Config {
3012
3013 /**
3014 * Determine if the given configuration value exists.
3015 *
3016 * @param string $key
3017 * @return bool
3018 * @static
3019 */
3020 public static function has($key)
3021 {
3022 return \Illuminate\Config\Repository::has($key);
3023 }
3024
3025 /**
3026 * Get the specified configuration value.
3027 *
3028 * @param array|string $key
3029 * @param mixed $default
3030 * @return mixed
3031 * @static
3032 */
3033 public static function get($key, $default = null)
3034 {
3035 return \Illuminate\Config\Repository::get($key, $default);
3036 }
3037
3038 /**
3039 * Get many configuration values.
3040 *
3041 * @param array $keys
3042 * @return array
3043 * @static
3044 */
3045 public static function getMany($keys)
3046 {
3047 return \Illuminate\Config\Repository::getMany($keys);
3048 }
3049
3050 /**
3051 * Set a given configuration value.
3052 *
3053 * @param array|string $key
3054 * @param mixed $value
3055 * @return void
3056 * @static
3057 */
3058 public static function set($key, $value = null)
3059 {
3060 \Illuminate\Config\Repository::set($key, $value);
3061 }
3062
3063 /**
3064 * Prepend a value onto an array configuration value.
3065 *
3066 * @param string $key
3067 * @param mixed $value
3068 * @return void
3069 * @static
3070 */
3071 public static function prepend($key, $value)
3072 {
3073 \Illuminate\Config\Repository::prepend($key, $value);
3074 }
3075
3076 /**
3077 * Push a value onto an array configuration value.
3078 *
3079 * @param string $key
3080 * @param mixed $value
3081 * @return void
3082 * @static
3083 */
3084 public static function push($key, $value)
3085 {
3086 \Illuminate\Config\Repository::push($key, $value);
3087 }
3088
3089 /**
3090 * Get all of the configuration items for the application.
3091 *
3092 * @return array
3093 * @static
3094 */
3095 public static function all()
3096 {
3097 return \Illuminate\Config\Repository::all();
3098 }
3099
3100 /**
3101 * Determine if the given configuration option exists.
3102 *
3103 * @param string $key
3104 * @return bool
3105 * @static
3106 */
3107 public static function offsetExists($key)
3108 {
3109 return \Illuminate\Config\Repository::offsetExists($key);
3110 }
3111
3112 /**
3113 * Get a configuration option.
3114 *
3115 * @param string $key
3116 * @return mixed
3117 * @static
3118 */
3119 public static function offsetGet($key)
3120 {
3121 return \Illuminate\Config\Repository::offsetGet($key);
3122 }
3123
3124 /**
3125 * Set a configuration option.
3126 *
3127 * @param string $key
3128 * @param mixed $value
3129 * @return void
3130 * @static
3131 */
3132 public static function offsetSet($key, $value)
3133 {
3134 \Illuminate\Config\Repository::offsetSet($key, $value);
3135 }
3136
3137 /**
3138 * Unset a configuration option.
3139 *
3140 * @param string $key
3141 * @return void
3142 * @static
3143 */
3144 public static function offsetUnset($key)
3145 {
3146 \Illuminate\Config\Repository::offsetUnset($key);
3147 }
3148
3149 }
3150
3151 class Cookie {
3152
3153 /**
3154 * Create a new cookie instance.
3155 *
3156 * @param string $name
3157 * @param string $value
3158 * @param int $minutes
3159 * @param string $path
3160 * @param string $domain
3161 * @param bool|null $secure
3162 * @param bool $httpOnly
3163 * @param bool $raw
3164 * @param string|null $sameSite
3165 * @return \Symfony\Component\HttpFoundation\Cookie
3166 * @static
3167 */
3168 public static function make($name, $value, $minutes = 0, $path = null, $domain = null, $secure = null, $httpOnly = true, $raw = false, $sameSite = null)
3169 {
3170 return \Illuminate\Cookie\CookieJar::make($name, $value, $minutes, $path, $domain, $secure, $httpOnly, $raw, $sameSite);
3171 }
3172
3173 /**
3174 * Create a cookie that lasts "forever" (five years).
3175 *
3176 * @param string $name
3177 * @param string $value
3178 * @param string $path
3179 * @param string $domain
3180 * @param bool|null $secure
3181 * @param bool $httpOnly
3182 * @param bool $raw
3183 * @param string|null $sameSite
3184 * @return \Symfony\Component\HttpFoundation\Cookie
3185 * @static
3186 */
3187 public static function forever($name, $value, $path = null, $domain = null, $secure = null, $httpOnly = true, $raw = false, $sameSite = null)
3188 {
3189 return \Illuminate\Cookie\CookieJar::forever($name, $value, $path, $domain, $secure, $httpOnly, $raw, $sameSite);
3190 }
3191
3192 /**
3193 * Expire the given cookie.
3194 *
3195 * @param string $name
3196 * @param string $path
3197 * @param string $domain
3198 * @return \Symfony\Component\HttpFoundation\Cookie
3199 * @static
3200 */
3201 public static function forget($name, $path = null, $domain = null)
3202 {
3203 return \Illuminate\Cookie\CookieJar::forget($name, $path, $domain);
3204 }
3205
3206 /**
3207 * Determine if a cookie has been queued.
3208 *
3209 * @param string $key
3210 * @return bool
3211 * @static
3212 */
3213 public static function hasQueued($key)
3214 {
3215 return \Illuminate\Cookie\CookieJar::hasQueued($key);
3216 }
3217
3218 /**
3219 * Get a queued cookie instance.
3220 *
3221 * @param string $key
3222 * @param mixed $default
3223 * @return \Symfony\Component\HttpFoundation\Cookie
3224 * @static
3225 */
3226 public static function queued($key, $default = null)
3227 {
3228 return \Illuminate\Cookie\CookieJar::queued($key, $default);
3229 }
3230
3231 /**
3232 * Queue a cookie to send with the next response.
3233 *
3234 * @param array $parameters
3235 * @return void
3236 * @static
3237 */
3238 public static function queue($parameters = null)
3239 {
3240 \Illuminate\Cookie\CookieJar::queue($parameters);
3241 }
3242
3243 /**
3244 * Remove a cookie from the queue.
3245 *
3246 * @param string $name
3247 * @return void
3248 * @static
3249 */
3250 public static function unqueue($name)
3251 {
3252 \Illuminate\Cookie\CookieJar::unqueue($name);
3253 }
3254
3255 /**
3256 * Set the default path and domain for the jar.
3257 *
3258 * @param string $path
3259 * @param string $domain
3260 * @param bool $secure
3261 * @param string $sameSite
3262 * @return $this
3263 * @static
3264 */
3265 public static function setDefaultPathAndDomain($path, $domain, $secure = false, $sameSite = null)
3266 {
3267 return \Illuminate\Cookie\CookieJar::setDefaultPathAndDomain($path, $domain, $secure, $sameSite);
3268 }
3269
3270 /**
3271 * Get the cookies which have been queued for the next request.
3272 *
3273 * @return \Symfony\Component\HttpFoundation\Cookie[]
3274 * @static
3275 */
3276 public static function getQueuedCookies()
3277 {
3278 return \Illuminate\Cookie\CookieJar::getQueuedCookies();
3279 }
3280
3281 }
3282
3283 class Crypt {
3284
3285 /**
3286 * Determine if the given key and cipher combination is valid.
3287 *
3288 * @param string $key
3289 * @param string $cipher
3290 * @return bool
3291 * @static
3292 */
3293 public static function supported($key, $cipher)
3294 {
3295 return \Illuminate\Encryption\Encrypter::supported($key, $cipher);
3296 }
3297
3298 /**
3299 * Create a new encryption key for the given cipher.
3300 *
3301 * @param string $cipher
3302 * @return string
3303 * @static
3304 */
3305 public static function generateKey($cipher)
3306 {
3307 return \Illuminate\Encryption\Encrypter::generateKey($cipher);
3308 }
3309
3310 /**
3311 * Encrypt the given value.
3312 *
3313 * @param mixed $value
3314 * @param bool $serialize
3315 * @return string
3316 * @throws \Illuminate\Contracts\Encryption\EncryptException
3317 * @static
3318 */
3319 public static function encrypt($value, $serialize = true)
3320 {
3321 return \Illuminate\Encryption\Encrypter::encrypt($value, $serialize);
3322 }
3323
3324 /**
3325 * Encrypt a string without serialization.
3326 *
3327 * @param string $value
3328 * @return string
3329 * @static
3330 */
3331 public static function encryptString($value)
3332 {
3333 return \Illuminate\Encryption\Encrypter::encryptString($value);
3334 }
3335
3336 /**
3337 * Decrypt the given value.
3338 *
3339 * @param mixed $payload
3340 * @param bool $unserialize
3341 * @return string
3342 * @throws \Illuminate\Contracts\Encryption\DecryptException
3343 * @static
3344 */
3345 public static function decrypt($payload, $unserialize = true)
3346 {
3347 return \Illuminate\Encryption\Encrypter::decrypt($payload, $unserialize);
3348 }
3349
3350 /**
3351 * Decrypt the given string without unserialization.
3352 *
3353 * @param string $payload
3354 * @return string
3355 * @static
3356 */
3357 public static function decryptString($payload)
3358 {
3359 return \Illuminate\Encryption\Encrypter::decryptString($payload);
3360 }
3361
3362 /**
3363 * Get the encryption key.
3364 *
3365 * @return string
3366 * @static
3367 */
3368 public static function getKey()
3369 {
3370 return \Illuminate\Encryption\Encrypter::getKey();
3371 }
3372
3373 }
3374
3375 class DB {
3376
3377 /**
3378 * Get a database connection instance.
3379 *
3380 * @param string $name
3381 * @return \Illuminate\Database\Connection
3382 * @static
3383 */
3384 public static function connection($name = null)
3385 {
3386 return \Illuminate\Database\DatabaseManager::connection($name);
3387 }
3388
3389 /**
3390 * Disconnect from the given database and remove from local cache.
3391 *
3392 * @param string $name
3393 * @return void
3394 * @static
3395 */
3396 public static function purge($name = null)
3397 {
3398 \Illuminate\Database\DatabaseManager::purge($name);
3399 }
3400
3401 /**
3402 * Disconnect from the given database.
3403 *
3404 * @param string $name
3405 * @return void
3406 * @static
3407 */
3408 public static function disconnect($name = null)
3409 {
3410 \Illuminate\Database\DatabaseManager::disconnect($name);
3411 }
3412
3413 /**
3414 * Reconnect to the given database.
3415 *
3416 * @param string $name
3417 * @return \Illuminate\Database\Connection
3418 * @static
3419 */
3420 public static function reconnect($name = null)
3421 {
3422 return \Illuminate\Database\DatabaseManager::reconnect($name);
3423 }
3424
3425 /**
3426 * Get the default connection name.
3427 *
3428 * @return string
3429 * @static
3430 */
3431 public static function getDefaultConnection()
3432 {
3433 return \Illuminate\Database\DatabaseManager::getDefaultConnection();
3434 }
3435
3436 /**
3437 * Set the default connection name.
3438 *
3439 * @param string $name
3440 * @return void
3441 * @static
3442 */
3443 public static function setDefaultConnection($name)
3444 {
3445 \Illuminate\Database\DatabaseManager::setDefaultConnection($name);
3446 }
3447
3448 /**
3449 * Get all of the support drivers.
3450 *
3451 * @return array
3452 * @static
3453 */
3454 public static function supportedDrivers()
3455 {
3456 return \Illuminate\Database\DatabaseManager::supportedDrivers();
3457 }
3458
3459 /**
3460 * Get all of the drivers that are actually available.
3461 *
3462 * @return array
3463 * @static
3464 */
3465 public static function availableDrivers()
3466 {
3467 return \Illuminate\Database\DatabaseManager::availableDrivers();
3468 }
3469
3470 /**
3471 * Register an extension connection resolver.
3472 *
3473 * @param string $name
3474 * @param callable $resolver
3475 * @return void
3476 * @static
3477 */
3478 public static function extend($name, $resolver)
3479 {
3480 \Illuminate\Database\DatabaseManager::extend($name, $resolver);
3481 }
3482
3483 /**
3484 * Return all of the created connections.
3485 *
3486 * @return array
3487 * @static
3488 */
3489 public static function getConnections()
3490 {
3491 return \Illuminate\Database\DatabaseManager::getConnections();
3492 }
3493
3494 /**
3495 * Get a schema builder instance for the connection.
3496 *
3497 * @return \Illuminate\Database\Schema\MySqlBuilder
3498 * @static
3499 */
3500 public static function getSchemaBuilder()
3501 {
3502 return \Illuminate\Database\MySqlConnection::getSchemaBuilder();
3503 }
3504
3505 /**
3506 * Bind values to their parameters in the given statement.
3507 *
3508 * @param \PDOStatement $statement
3509 * @param array $bindings
3510 * @return void
3511 * @static
3512 */
3513 public static function bindValues($statement, $bindings)
3514 {
3515 \Illuminate\Database\MySqlConnection::bindValues($statement, $bindings);
3516 }
3517
3518 /**
3519 * Set the query grammar to the default implementation.
3520 *
3521 * @return void
3522 * @static
3523 */
3524 public static function useDefaultQueryGrammar()
3525 {
3526 //Method inherited from \Illuminate\Database\Connection
3527 \Illuminate\Database\MySqlConnection::useDefaultQueryGrammar();
3528 }
3529
3530 /**
3531 * Set the schema grammar to the default implementation.
3532 *
3533 * @return void
3534 * @static
3535 */
3536 public static function useDefaultSchemaGrammar()
3537 {
3538 //Method inherited from \Illuminate\Database\Connection
3539 \Illuminate\Database\MySqlConnection::useDefaultSchemaGrammar();
3540 }
3541
3542 /**
3543 * Set the query post processor to the default implementation.
3544 *
3545 * @return void
3546 * @static
3547 */
3548 public static function useDefaultPostProcessor()
3549 {
3550 //Method inherited from \Illuminate\Database\Connection
3551 \Illuminate\Database\MySqlConnection::useDefaultPostProcessor();
3552 }
3553
3554 /**
3555 * Begin a fluent query against a database table.
3556 *
3557 * @param string $table
3558 * @return \Illuminate\Database\Query\Builder
3559 * @static
3560 */
3561 public static function table($table)
3562 {
3563 //Method inherited from \Illuminate\Database\Connection
3564 return \Illuminate\Database\MySqlConnection::table($table);
3565 }
3566
3567 /**
3568 * Get a new query builder instance.
3569 *
3570 * @return \Illuminate\Database\Query\Builder
3571 * @static
3572 */
3573 public static function query()
3574 {
3575 //Method inherited from \Illuminate\Database\Connection
3576 return \Illuminate\Database\MySqlConnection::query();
3577 }
3578
3579 /**
3580 * Run a select statement and return a single result.
3581 *
3582 * @param string $query
3583 * @param array $bindings
3584 * @param bool $useReadPdo
3585 * @return mixed
3586 * @static
3587 */
3588 public static function selectOne($query, $bindings = array(), $useReadPdo = true)
3589 {
3590 //Method inherited from \Illuminate\Database\Connection
3591 return \Illuminate\Database\MySqlConnection::selectOne($query, $bindings, $useReadPdo);
3592 }
3593
3594 /**
3595 * Run a select statement against the database.
3596 *
3597 * @param string $query
3598 * @param array $bindings
3599 * @return array
3600 * @static
3601 */
3602 public static function selectFromWriteConnection($query, $bindings = array())
3603 {
3604 //Method inherited from \Illuminate\Database\Connection
3605 return \Illuminate\Database\MySqlConnection::selectFromWriteConnection($query, $bindings);
3606 }
3607
3608 /**
3609 * Run a select statement against the database.
3610 *
3611 * @param string $query
3612 * @param array $bindings
3613 * @param bool $useReadPdo
3614 * @return array
3615 * @static
3616 */
3617 public static function select($query, $bindings = array(), $useReadPdo = true)
3618 {
3619 //Method inherited from \Illuminate\Database\Connection
3620 return \Illuminate\Database\MySqlConnection::select($query, $bindings, $useReadPdo);
3621 }
3622
3623 /**
3624 * Run a select statement against the database and returns a generator.
3625 *
3626 * @param string $query
3627 * @param array $bindings
3628 * @param bool $useReadPdo
3629 * @return \Generator
3630 * @static
3631 */
3632 public static function cursor($query, $bindings = array(), $useReadPdo = true)
3633 {
3634 //Method inherited from \Illuminate\Database\Connection
3635 return \Illuminate\Database\MySqlConnection::cursor($query, $bindings, $useReadPdo);
3636 }
3637
3638 /**
3639 * Run an insert statement against the database.
3640 *
3641 * @param string $query
3642 * @param array $bindings
3643 * @return bool
3644 * @static
3645 */
3646 public static function insert($query, $bindings = array())
3647 {
3648 //Method inherited from \Illuminate\Database\Connection
3649 return \Illuminate\Database\MySqlConnection::insert($query, $bindings);
3650 }
3651
3652 /**
3653 * Run an update statement against the database.
3654 *
3655 * @param string $query
3656 * @param array $bindings
3657 * @return int
3658 * @static
3659 */
3660 public static function update($query, $bindings = array())
3661 {
3662 //Method inherited from \Illuminate\Database\Connection
3663 return \Illuminate\Database\MySqlConnection::update($query, $bindings);
3664 }
3665
3666 /**
3667 * Run a delete statement against the database.
3668 *
3669 * @param string $query
3670 * @param array $bindings
3671 * @return int
3672 * @static
3673 */
3674 public static function delete($query, $bindings = array())
3675 {
3676 //Method inherited from \Illuminate\Database\Connection
3677 return \Illuminate\Database\MySqlConnection::delete($query, $bindings);
3678 }
3679
3680 /**
3681 * Execute an SQL statement and return the boolean result.
3682 *
3683 * @param string $query
3684 * @param array $bindings
3685 * @return bool
3686 * @static
3687 */
3688 public static function statement($query, $bindings = array())
3689 {
3690 //Method inherited from \Illuminate\Database\Connection
3691 return \Illuminate\Database\MySqlConnection::statement($query, $bindings);
3692 }
3693
3694 /**
3695 * Run an SQL statement and get the number of rows affected.
3696 *
3697 * @param string $query
3698 * @param array $bindings
3699 * @return int
3700 * @static
3701 */
3702 public static function affectingStatement($query, $bindings = array())
3703 {
3704 //Method inherited from \Illuminate\Database\Connection
3705 return \Illuminate\Database\MySqlConnection::affectingStatement($query, $bindings);
3706 }
3707
3708 /**
3709 * Run a raw, unprepared query against the PDO connection.
3710 *
3711 * @param string $query
3712 * @return bool
3713 * @static
3714 */
3715 public static function unprepared($query)
3716 {
3717 //Method inherited from \Illuminate\Database\Connection
3718 return \Illuminate\Database\MySqlConnection::unprepared($query);
3719 }
3720
3721 /**
3722 * Execute the given callback in "dry run" mode.
3723 *
3724 * @param \Closure $callback
3725 * @return array
3726 * @static
3727 */
3728 public static function pretend($callback)
3729 {
3730 //Method inherited from \Illuminate\Database\Connection
3731 return \Illuminate\Database\MySqlConnection::pretend($callback);
3732 }
3733
3734 /**
3735 * Prepare the query bindings for execution.
3736 *
3737 * @param array $bindings
3738 * @return array
3739 * @static
3740 */
3741 public static function prepareBindings($bindings)
3742 {
3743 //Method inherited from \Illuminate\Database\Connection
3744 return \Illuminate\Database\MySqlConnection::prepareBindings($bindings);
3745 }
3746
3747 /**
3748 * Log a query in the connection's query log.
3749 *
3750 * @param string $query
3751 * @param array $bindings
3752 * @param float|null $time
3753 * @return void
3754 * @static
3755 */
3756 public static function logQuery($query, $bindings, $time = null)
3757 {
3758 //Method inherited from \Illuminate\Database\Connection
3759 \Illuminate\Database\MySqlConnection::logQuery($query, $bindings, $time);
3760 }
3761
3762 /**
3763 * Register a database query listener with the connection.
3764 *
3765 * @param \Closure $callback
3766 * @return void
3767 * @static
3768 */
3769 public static function listen($callback)
3770 {
3771 //Method inherited from \Illuminate\Database\Connection
3772 \Illuminate\Database\MySqlConnection::listen($callback);
3773 }
3774
3775 /**
3776 * Get a new raw query expression.
3777 *
3778 * @param mixed $value
3779 * @return \Illuminate\Database\Query\Expression
3780 * @static
3781 */
3782 public static function raw($value)
3783 {
3784 //Method inherited from \Illuminate\Database\Connection
3785 return \Illuminate\Database\MySqlConnection::raw($value);
3786 }
3787
3788 /**
3789 * Indicate if any records have been modified.
3790 *
3791 * @param bool $value
3792 * @return void
3793 * @static
3794 */
3795 public static function recordsHaveBeenModified($value = true)
3796 {
3797 //Method inherited from \Illuminate\Database\Connection
3798 \Illuminate\Database\MySqlConnection::recordsHaveBeenModified($value);
3799 }
3800
3801 /**
3802 * Is Doctrine available?
3803 *
3804 * @return bool
3805 * @static
3806 */
3807 public static function isDoctrineAvailable()
3808 {
3809 //Method inherited from \Illuminate\Database\Connection
3810 return \Illuminate\Database\MySqlConnection::isDoctrineAvailable();
3811 }
3812
3813 /**
3814 * Get a Doctrine Schema Column instance.
3815 *
3816 * @param string $table
3817 * @param string $column
3818 * @return \Doctrine\DBAL\Schema\Column
3819 * @static
3820 */
3821 public static function getDoctrineColumn($table, $column)
3822 {
3823 //Method inherited from \Illuminate\Database\Connection
3824 return \Illuminate\Database\MySqlConnection::getDoctrineColumn($table, $column);
3825 }
3826
3827 /**
3828 * Get the Doctrine DBAL schema manager for the connection.
3829 *
3830 * @return \Doctrine\DBAL\Schema\AbstractSchemaManager
3831 * @static
3832 */
3833 public static function getDoctrineSchemaManager()
3834 {
3835 //Method inherited from \Illuminate\Database\Connection
3836 return \Illuminate\Database\MySqlConnection::getDoctrineSchemaManager();
3837 }
3838
3839 /**
3840 * Get the Doctrine DBAL database connection instance.
3841 *
3842 * @return \Doctrine\DBAL\Connection
3843 * @static
3844 */
3845 public static function getDoctrineConnection()
3846 {
3847 //Method inherited from \Illuminate\Database\Connection
3848 return \Illuminate\Database\MySqlConnection::getDoctrineConnection();
3849 }
3850
3851 /**
3852 * Get the current PDO connection.
3853 *
3854 * @return \PDO
3855 * @static
3856 */
3857 public static function getPdo()
3858 {
3859 //Method inherited from \Illuminate\Database\Connection
3860 return \Illuminate\Database\MySqlConnection::getPdo();
3861 }
3862
3863 /**
3864 * Get the current PDO connection used for reading.
3865 *
3866 * @return \PDO
3867 * @static
3868 */
3869 public static function getReadPdo()
3870 {
3871 //Method inherited from \Illuminate\Database\Connection
3872 return \Illuminate\Database\MySqlConnection::getReadPdo();
3873 }
3874
3875 /**
3876 * Set the PDO connection.
3877 *
3878 * @param \PDO|\Closure|null $pdo
3879 * @return $this
3880 * @static
3881 */
3882 public static function setPdo($pdo)
3883 {
3884 //Method inherited from \Illuminate\Database\Connection
3885 return \Illuminate\Database\MySqlConnection::setPdo($pdo);
3886 }
3887
3888 /**
3889 * Set the PDO connection used for reading.
3890 *
3891 * @param \PDO|\Closure|null $pdo
3892 * @return $this
3893 * @static
3894 */
3895 public static function setReadPdo($pdo)
3896 {
3897 //Method inherited from \Illuminate\Database\Connection
3898 return \Illuminate\Database\MySqlConnection::setReadPdo($pdo);
3899 }
3900
3901 /**
3902 * Set the reconnect instance on the connection.
3903 *
3904 * @param callable $reconnector
3905 * @return $this
3906 * @static
3907 */
3908 public static function setReconnector($reconnector)
3909 {
3910 //Method inherited from \Illuminate\Database\Connection
3911 return \Illuminate\Database\MySqlConnection::setReconnector($reconnector);
3912 }
3913
3914 /**
3915 * Get the database connection name.
3916 *
3917 * @return string|null
3918 * @static
3919 */
3920 public static function getName()
3921 {
3922 //Method inherited from \Illuminate\Database\Connection
3923 return \Illuminate\Database\MySqlConnection::getName();
3924 }
3925
3926 /**
3927 * Get an option from the configuration options.
3928 *
3929 * @param string|null $option
3930 * @return mixed
3931 * @static
3932 */
3933 public static function getConfig($option = null)
3934 {
3935 //Method inherited from \Illuminate\Database\Connection
3936 return \Illuminate\Database\MySqlConnection::getConfig($option);
3937 }
3938
3939 /**
3940 * Get the PDO driver name.
3941 *
3942 * @return string
3943 * @static
3944 */
3945 public static function getDriverName()
3946 {
3947 //Method inherited from \Illuminate\Database\Connection
3948 return \Illuminate\Database\MySqlConnection::getDriverName();
3949 }
3950
3951 /**
3952 * Get the query grammar used by the connection.
3953 *
3954 * @return \Illuminate\Database\Query\Grammars\Grammar
3955 * @static
3956 */
3957 public static function getQueryGrammar()
3958 {
3959 //Method inherited from \Illuminate\Database\Connection
3960 return \Illuminate\Database\MySqlConnection::getQueryGrammar();
3961 }
3962
3963 /**
3964 * Set the query grammar used by the connection.
3965 *
3966 * @param \Illuminate\Database\Query\Grammars\Grammar $grammar
3967 * @return void
3968 * @static
3969 */
3970 public static function setQueryGrammar($grammar)
3971 {
3972 //Method inherited from \Illuminate\Database\Connection
3973 \Illuminate\Database\MySqlConnection::setQueryGrammar($grammar);
3974 }
3975
3976 /**
3977 * Get the schema grammar used by the connection.
3978 *
3979 * @return \Illuminate\Database\Schema\Grammars\Grammar
3980 * @static
3981 */
3982 public static function getSchemaGrammar()
3983 {
3984 //Method inherited from \Illuminate\Database\Connection
3985 return \Illuminate\Database\MySqlConnection::getSchemaGrammar();
3986 }
3987
3988 /**
3989 * Set the schema grammar used by the connection.
3990 *
3991 * @param \Illuminate\Database\Schema\Grammars\Grammar $grammar
3992 * @return void
3993 * @static
3994 */
3995 public static function setSchemaGrammar($grammar)
3996 {
3997 //Method inherited from \Illuminate\Database\Connection
3998 \Illuminate\Database\MySqlConnection::setSchemaGrammar($grammar);
3999 }
4000
4001 /**
4002 * Get the query post processor used by the connection.
4003 *
4004 * @return \Illuminate\Database\Query\Processors\Processor
4005 * @static
4006 */
4007 public static function getPostProcessor()
4008 {
4009 //Method inherited from \Illuminate\Database\Connection
4010 return \Illuminate\Database\MySqlConnection::getPostProcessor();
4011 }
4012
4013 /**
4014 * Set the query post processor used by the connection.
4015 *
4016 * @param \Illuminate\Database\Query\Processors\Processor $processor
4017 * @return void
4018 * @static
4019 */
4020 public static function setPostProcessor($processor)
4021 {
4022 //Method inherited from \Illuminate\Database\Connection
4023 \Illuminate\Database\MySqlConnection::setPostProcessor($processor);
4024 }
4025
4026 /**
4027 * Get the event dispatcher used by the connection.
4028 *
4029 * @return \Illuminate\Contracts\Events\Dispatcher
4030 * @static
4031 */
4032 public static function getEventDispatcher()
4033 {
4034 //Method inherited from \Illuminate\Database\Connection
4035 return \Illuminate\Database\MySqlConnection::getEventDispatcher();
4036 }
4037
4038 /**
4039 * Set the event dispatcher instance on the connection.
4040 *
4041 * @param \Illuminate\Contracts\Events\Dispatcher $events
4042 * @return void
4043 * @static
4044 */
4045 public static function setEventDispatcher($events)
4046 {
4047 //Method inherited from \Illuminate\Database\Connection
4048 \Illuminate\Database\MySqlConnection::setEventDispatcher($events);
4049 }
4050
4051 /**
4052 * Unset the event dispatcher for this connection.
4053 *
4054 * @return void
4055 * @static
4056 */
4057 public static function unsetEventDispatcher()
4058 {
4059 //Method inherited from \Illuminate\Database\Connection
4060 \Illuminate\Database\MySqlConnection::unsetEventDispatcher();
4061 }
4062
4063 /**
4064 * Determine if the connection in a "dry run".
4065 *
4066 * @return bool
4067 * @static
4068 */
4069 public static function pretending()
4070 {
4071 //Method inherited from \Illuminate\Database\Connection
4072 return \Illuminate\Database\MySqlConnection::pretending();
4073 }
4074
4075 /**
4076 * Get the connection query log.
4077 *
4078 * @return array
4079 * @static
4080 */
4081 public static function getQueryLog()
4082 {
4083 //Method inherited from \Illuminate\Database\Connection
4084 return \Illuminate\Database\MySqlConnection::getQueryLog();
4085 }
4086
4087 /**
4088 * Clear the query log.
4089 *
4090 * @return void
4091 * @static
4092 */
4093 public static function flushQueryLog()
4094 {
4095 //Method inherited from \Illuminate\Database\Connection
4096 \Illuminate\Database\MySqlConnection::flushQueryLog();
4097 }
4098
4099 /**
4100 * Enable the query log on the connection.
4101 *
4102 * @return void
4103 * @static
4104 */
4105 public static function enableQueryLog()
4106 {
4107 //Method inherited from \Illuminate\Database\Connection
4108 \Illuminate\Database\MySqlConnection::enableQueryLog();
4109 }
4110
4111 /**
4112 * Disable the query log on the connection.
4113 *
4114 * @return void
4115 * @static
4116 */
4117 public static function disableQueryLog()
4118 {
4119 //Method inherited from \Illuminate\Database\Connection
4120 \Illuminate\Database\MySqlConnection::disableQueryLog();
4121 }
4122
4123 /**
4124 * Determine whether we're logging queries.
4125 *
4126 * @return bool
4127 * @static
4128 */
4129 public static function logging()
4130 {
4131 //Method inherited from \Illuminate\Database\Connection
4132 return \Illuminate\Database\MySqlConnection::logging();
4133 }
4134
4135 /**
4136 * Get the name of the connected database.
4137 *
4138 * @return string
4139 * @static
4140 */
4141 public static function getDatabaseName()
4142 {
4143 //Method inherited from \Illuminate\Database\Connection
4144 return \Illuminate\Database\MySqlConnection::getDatabaseName();
4145 }
4146
4147 /**
4148 * Set the name of the connected database.
4149 *
4150 * @param string $database
4151 * @return string
4152 * @static
4153 */
4154 public static function setDatabaseName($database)
4155 {
4156 //Method inherited from \Illuminate\Database\Connection
4157 return \Illuminate\Database\MySqlConnection::setDatabaseName($database);
4158 }
4159
4160 /**
4161 * Get the table prefix for the connection.
4162 *
4163 * @return string
4164 * @static
4165 */
4166 public static function getTablePrefix()
4167 {
4168 //Method inherited from \Illuminate\Database\Connection
4169 return \Illuminate\Database\MySqlConnection::getTablePrefix();
4170 }
4171
4172 /**
4173 * Set the table prefix in use by the connection.
4174 *
4175 * @param string $prefix
4176 * @return void
4177 * @static
4178 */
4179 public static function setTablePrefix($prefix)
4180 {
4181 //Method inherited from \Illuminate\Database\Connection
4182 \Illuminate\Database\MySqlConnection::setTablePrefix($prefix);
4183 }
4184
4185 /**
4186 * Set the table prefix and return the grammar.
4187 *
4188 * @param \Illuminate\Database\Grammar $grammar
4189 * @return \Illuminate\Database\Grammar
4190 * @static
4191 */
4192 public static function withTablePrefix($grammar)
4193 {
4194 //Method inherited from \Illuminate\Database\Connection
4195 return \Illuminate\Database\MySqlConnection::withTablePrefix($grammar);
4196 }
4197
4198 /**
4199 * Register a connection resolver.
4200 *
4201 * @param string $driver
4202 * @param \Closure $callback
4203 * @return void
4204 * @static
4205 */
4206 public static function resolverFor($driver, $callback)
4207 {
4208 //Method inherited from \Illuminate\Database\Connection
4209 \Illuminate\Database\MySqlConnection::resolverFor($driver, $callback);
4210 }
4211
4212 /**
4213 * Get the connection resolver for the given driver.
4214 *
4215 * @param string $driver
4216 * @return mixed
4217 * @static
4218 */
4219 public static function getResolver($driver)
4220 {
4221 //Method inherited from \Illuminate\Database\Connection
4222 return \Illuminate\Database\MySqlConnection::getResolver($driver);
4223 }
4224
4225 /**
4226 * Execute a Closure within a transaction.
4227 *
4228 * @param \Closure $callback
4229 * @param int $attempts
4230 * @return mixed
4231 * @throws \Exception|\Throwable
4232 * @static
4233 */
4234 public static function transaction($callback, $attempts = 1)
4235 {
4236 //Method inherited from \Illuminate\Database\Connection
4237 return \Illuminate\Database\MySqlConnection::transaction($callback, $attempts);
4238 }
4239
4240 /**
4241 * Start a new database transaction.
4242 *
4243 * @return void
4244 * @throws \Exception
4245 * @static
4246 */
4247 public static function beginTransaction()
4248 {
4249 //Method inherited from \Illuminate\Database\Connection
4250 \Illuminate\Database\MySqlConnection::beginTransaction();
4251 }
4252
4253 /**
4254 * Commit the active database transaction.
4255 *
4256 * @return void
4257 * @static
4258 */
4259 public static function commit()
4260 {
4261 //Method inherited from \Illuminate\Database\Connection
4262 \Illuminate\Database\MySqlConnection::commit();
4263 }
4264
4265 /**
4266 * Rollback the active database transaction.
4267 *
4268 * @param int|null $toLevel
4269 * @return void
4270 * @static
4271 */
4272 public static function rollBack($toLevel = null)
4273 {
4274 //Method inherited from \Illuminate\Database\Connection
4275 \Illuminate\Database\MySqlConnection::rollBack($toLevel);
4276 }
4277
4278 /**
4279 * Get the number of active transactions.
4280 *
4281 * @return int
4282 * @static
4283 */
4284 public static function transactionLevel()
4285 {
4286 //Method inherited from \Illuminate\Database\Connection
4287 return \Illuminate\Database\MySqlConnection::transactionLevel();
4288 }
4289
4290 }
4291
4292 class Event {
4293
4294 /**
4295 * Register an event listener with the dispatcher.
4296 *
4297 * @param string|array $events
4298 * @param mixed $listener
4299 * @return void
4300 * @static
4301 */
4302 public static function listen($events, $listener)
4303 {
4304 \Illuminate\Events\Dispatcher::listen($events, $listener);
4305 }
4306
4307 /**
4308 * Determine if a given event has listeners.
4309 *
4310 * @param string $eventName
4311 * @return bool
4312 * @static
4313 */
4314 public static function hasListeners($eventName)
4315 {
4316 return \Illuminate\Events\Dispatcher::hasListeners($eventName);
4317 }
4318
4319 /**
4320 * Register an event and payload to be fired later.
4321 *
4322 * @param string $event
4323 * @param array $payload
4324 * @return void
4325 * @static
4326 */
4327 public static function push($event, $payload = array())
4328 {
4329 \Illuminate\Events\Dispatcher::push($event, $payload);
4330 }
4331
4332 /**
4333 * Flush a set of pushed events.
4334 *
4335 * @param string $event
4336 * @return void
4337 * @static
4338 */
4339 public static function flush($event)
4340 {
4341 \Illuminate\Events\Dispatcher::flush($event);
4342 }
4343
4344 /**
4345 * Register an event subscriber with the dispatcher.
4346 *
4347 * @param object|string $subscriber
4348 * @return void
4349 * @static
4350 */
4351 public static function subscribe($subscriber)
4352 {
4353 \Illuminate\Events\Dispatcher::subscribe($subscriber);
4354 }
4355
4356 /**
4357 * Fire an event until the first non-null response is returned.
4358 *
4359 * @param string|object $event
4360 * @param mixed $payload
4361 * @return array|null
4362 * @static
4363 */
4364 public static function until($event, $payload = array())
4365 {
4366 return \Illuminate\Events\Dispatcher::until($event, $payload);
4367 }
4368
4369 /**
4370 * Fire an event and call the listeners.
4371 *
4372 * @param string|object $event
4373 * @param mixed $payload
4374 * @param bool $halt
4375 * @return array|null
4376 * @static
4377 */
4378 public static function fire($event, $payload = array(), $halt = false)
4379 {
4380 return \Illuminate\Events\Dispatcher::fire($event, $payload, $halt);
4381 }
4382
4383 /**
4384 * Fire an event and call the listeners.
4385 *
4386 * @param string|object $event
4387 * @param mixed $payload
4388 * @param bool $halt
4389 * @return array|null
4390 * @static
4391 */
4392 public static function dispatch($event, $payload = array(), $halt = false)
4393 {
4394 return \Illuminate\Events\Dispatcher::dispatch($event, $payload, $halt);
4395 }
4396
4397 /**
4398 * Get all of the listeners for a given event name.
4399 *
4400 * @param string $eventName
4401 * @return array
4402 * @static
4403 */
4404 public static function getListeners($eventName)
4405 {
4406 return \Illuminate\Events\Dispatcher::getListeners($eventName);
4407 }
4408
4409 /**
4410 * Register an event listener with the dispatcher.
4411 *
4412 * @param \Closure|string $listener
4413 * @param bool $wildcard
4414 * @return \Closure
4415 * @static
4416 */
4417 public static function makeListener($listener, $wildcard = false)
4418 {
4419 return \Illuminate\Events\Dispatcher::makeListener($listener, $wildcard);
4420 }
4421
4422 /**
4423 * Create a class based listener using the IoC container.
4424 *
4425 * @param string $listener
4426 * @param bool $wildcard
4427 * @return \Closure
4428 * @static
4429 */
4430 public static function createClassListener($listener, $wildcard = false)
4431 {
4432 return \Illuminate\Events\Dispatcher::createClassListener($listener, $wildcard);
4433 }
4434
4435 /**
4436 * Remove a set of listeners from the dispatcher.
4437 *
4438 * @param string $event
4439 * @return void
4440 * @static
4441 */
4442 public static function forget($event)
4443 {
4444 \Illuminate\Events\Dispatcher::forget($event);
4445 }
4446
4447 /**
4448 * Forget all of the pushed listeners.
4449 *
4450 * @return void
4451 * @static
4452 */
4453 public static function forgetPushed()
4454 {
4455 \Illuminate\Events\Dispatcher::forgetPushed();
4456 }
4457
4458 /**
4459 * Set the queue resolver implementation.
4460 *
4461 * @param callable $resolver
4462 * @return $this
4463 * @static
4464 */
4465 public static function setQueueResolver($resolver)
4466 {
4467 return \Illuminate\Events\Dispatcher::setQueueResolver($resolver);
4468 }
4469
4470 }
4471
4472 class File {
4473
4474 /**
4475 * Determine if a file or directory exists.
4476 *
4477 * @param string $path
4478 * @return bool
4479 * @static
4480 */
4481 public static function exists($path)
4482 {
4483 return \Illuminate\Filesystem\Filesystem::exists($path);
4484 }
4485
4486 /**
4487 * Get the contents of a file.
4488 *
4489 * @param string $path
4490 * @param bool $lock
4491 * @return string
4492 * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
4493 * @static
4494 */
4495 public static function get($path, $lock = false)
4496 {
4497 return \Illuminate\Filesystem\Filesystem::get($path, $lock);
4498 }
4499
4500 /**
4501 * Get contents of a file with shared access.
4502 *
4503 * @param string $path
4504 * @return string
4505 * @static
4506 */
4507 public static function sharedGet($path)
4508 {
4509 return \Illuminate\Filesystem\Filesystem::sharedGet($path);
4510 }
4511
4512 /**
4513 * Get the returned value of a file.
4514 *
4515 * @param string $path
4516 * @return mixed
4517 * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
4518 * @static
4519 */
4520 public static function getRequire($path)
4521 {
4522 return \Illuminate\Filesystem\Filesystem::getRequire($path);
4523 }
4524
4525 /**
4526 * Require the given file once.
4527 *
4528 * @param string $file
4529 * @return mixed
4530 * @static
4531 */
4532 public static function requireOnce($file)
4533 {
4534 return \Illuminate\Filesystem\Filesystem::requireOnce($file);
4535 }
4536
4537 /**
4538 * Get the MD5 hash of the file at the given path.
4539 *
4540 * @param string $path
4541 * @return string
4542 * @static
4543 */
4544 public static function hash($path)
4545 {
4546 return \Illuminate\Filesystem\Filesystem::hash($path);
4547 }
4548
4549 /**
4550 * Write the contents of a file.
4551 *
4552 * @param string $path
4553 * @param string $contents
4554 * @param bool $lock
4555 * @return int
4556 * @static
4557 */
4558 public static function put($path, $contents, $lock = false)
4559 {
4560 return \Illuminate\Filesystem\Filesystem::put($path, $contents, $lock);
4561 }
4562
4563 /**
4564 * Prepend to a file.
4565 *
4566 * @param string $path
4567 * @param string $data
4568 * @return int
4569 * @static
4570 */
4571 public static function prepend($path, $data)
4572 {
4573 return \Illuminate\Filesystem\Filesystem::prepend($path, $data);
4574 }
4575
4576 /**
4577 * Append to a file.
4578 *
4579 * @param string $path
4580 * @param string $data
4581 * @return int
4582 * @static
4583 */
4584 public static function append($path, $data)
4585 {
4586 return \Illuminate\Filesystem\Filesystem::append($path, $data);
4587 }
4588
4589 /**
4590 * Get or set UNIX mode of a file or directory.
4591 *
4592 * @param string $path
4593 * @param int $mode
4594 * @return mixed
4595 * @static
4596 */
4597 public static function chmod($path, $mode = null)
4598 {
4599 return \Illuminate\Filesystem\Filesystem::chmod($path, $mode);
4600 }
4601
4602 /**
4603 * Delete the file at a given path.
4604 *
4605 * @param string|array $paths
4606 * @return bool
4607 * @static
4608 */
4609 public static function delete($paths)
4610 {
4611 return \Illuminate\Filesystem\Filesystem::delete($paths);
4612 }
4613
4614 /**
4615 * Move a file to a new location.
4616 *
4617 * @param string $path
4618 * @param string $target
4619 * @return bool
4620 * @static
4621 */
4622 public static function move($path, $target)
4623 {
4624 return \Illuminate\Filesystem\Filesystem::move($path, $target);
4625 }
4626
4627 /**
4628 * Copy a file to a new location.
4629 *
4630 * @param string $path
4631 * @param string $target
4632 * @return bool
4633 * @static
4634 */
4635 public static function copy($path, $target)
4636 {
4637 return \Illuminate\Filesystem\Filesystem::copy($path, $target);
4638 }
4639
4640 /**
4641 * Create a hard link to the target file or directory.
4642 *
4643 * @param string $target
4644 * @param string $link
4645 * @return void
4646 * @static
4647 */
4648 public static function link($target, $link)
4649 {
4650 \Illuminate\Filesystem\Filesystem::link($target, $link);
4651 }
4652
4653 /**
4654 * Extract the file name from a file path.
4655 *
4656 * @param string $path
4657 * @return string
4658 * @static
4659 */
4660 public static function name($path)
4661 {
4662 return \Illuminate\Filesystem\Filesystem::name($path);
4663 }
4664
4665 /**
4666 * Extract the trailing name component from a file path.
4667 *
4668 * @param string $path
4669 * @return string
4670 * @static
4671 */
4672 public static function basename($path)
4673 {
4674 return \Illuminate\Filesystem\Filesystem::basename($path);
4675 }
4676
4677 /**
4678 * Extract the parent directory from a file path.
4679 *
4680 * @param string $path
4681 * @return string
4682 * @static
4683 */
4684 public static function dirname($path)
4685 {
4686 return \Illuminate\Filesystem\Filesystem::dirname($path);
4687 }
4688
4689 /**
4690 * Extract the file extension from a file path.
4691 *
4692 * @param string $path
4693 * @return string
4694 * @static
4695 */
4696 public static function extension($path)
4697 {
4698 return \Illuminate\Filesystem\Filesystem::extension($path);
4699 }
4700
4701 /**
4702 * Get the file type of a given file.
4703 *
4704 * @param string $path
4705 * @return string
4706 * @static
4707 */
4708 public static function type($path)
4709 {
4710 return \Illuminate\Filesystem\Filesystem::type($path);
4711 }
4712
4713 /**
4714 * Get the mime-type of a given file.
4715 *
4716 * @param string $path
4717 * @return string|false
4718 * @static
4719 */
4720 public static function mimeType($path)
4721 {
4722 return \Illuminate\Filesystem\Filesystem::mimeType($path);
4723 }
4724
4725 /**
4726 * Get the file size of a given file.
4727 *
4728 * @param string $path
4729 * @return int
4730 * @static
4731 */
4732 public static function size($path)
4733 {
4734 return \Illuminate\Filesystem\Filesystem::size($path);
4735 }
4736
4737 /**
4738 * Get the file's last modification time.
4739 *
4740 * @param string $path
4741 * @return int
4742 * @static
4743 */
4744 public static function lastModified($path)
4745 {
4746 return \Illuminate\Filesystem\Filesystem::lastModified($path);
4747 }
4748
4749 /**
4750 * Determine if the given path is a directory.
4751 *
4752 * @param string $directory
4753 * @return bool
4754 * @static
4755 */
4756 public static function isDirectory($directory)
4757 {
4758 return \Illuminate\Filesystem\Filesystem::isDirectory($directory);
4759 }
4760
4761 /**
4762 * Determine if the given path is readable.
4763 *
4764 * @param string $path
4765 * @return bool
4766 * @static
4767 */
4768 public static function isReadable($path)
4769 {
4770 return \Illuminate\Filesystem\Filesystem::isReadable($path);
4771 }
4772
4773 /**
4774 * Determine if the given path is writable.
4775 *
4776 * @param string $path
4777 * @return bool
4778 * @static
4779 */
4780 public static function isWritable($path)
4781 {
4782 return \Illuminate\Filesystem\Filesystem::isWritable($path);
4783 }
4784
4785 /**
4786 * Determine if the given path is a file.
4787 *
4788 * @param string $file
4789 * @return bool
4790 * @static
4791 */
4792 public static function isFile($file)
4793 {
4794 return \Illuminate\Filesystem\Filesystem::isFile($file);
4795 }
4796
4797 /**
4798 * Find path names matching a given pattern.
4799 *
4800 * @param string $pattern
4801 * @param int $flags
4802 * @return array
4803 * @static
4804 */
4805 public static function glob($pattern, $flags = 0)
4806 {
4807 return \Illuminate\Filesystem\Filesystem::glob($pattern, $flags);
4808 }
4809
4810 /**
4811 * Get an array of all files in a directory.
4812 *
4813 * @param string $directory
4814 * @param bool $hidden
4815 * @return \Symfony\Component\Finder\SplFileInfo[]
4816 * @static
4817 */
4818 public static function files($directory, $hidden = false)
4819 {
4820 return \Illuminate\Filesystem\Filesystem::files($directory, $hidden);
4821 }
4822
4823 /**
4824 * Get all of the files from the given directory (recursive).
4825 *
4826 * @param string $directory
4827 * @param bool $hidden
4828 * @return \Symfony\Component\Finder\SplFileInfo[]
4829 * @static
4830 */
4831 public static function allFiles($directory, $hidden = false)
4832 {
4833 return \Illuminate\Filesystem\Filesystem::allFiles($directory, $hidden);
4834 }
4835
4836 /**
4837 * Get all of the directories within a given directory.
4838 *
4839 * @param string $directory
4840 * @return array
4841 * @static
4842 */
4843 public static function directories($directory)
4844 {
4845 return \Illuminate\Filesystem\Filesystem::directories($directory);
4846 }
4847
4848 /**
4849 * Create a directory.
4850 *
4851 * @param string $path
4852 * @param int $mode
4853 * @param bool $recursive
4854 * @param bool $force
4855 * @return bool
4856 * @static
4857 */
4858 public static function makeDirectory($path, $mode = 493, $recursive = false, $force = false)
4859 {
4860 return \Illuminate\Filesystem\Filesystem::makeDirectory($path, $mode, $recursive, $force);
4861 }
4862
4863 /**
4864 * Move a directory.
4865 *
4866 * @param string $from
4867 * @param string $to
4868 * @param bool $overwrite
4869 * @return bool
4870 * @static
4871 */
4872 public static function moveDirectory($from, $to, $overwrite = false)
4873 {
4874 return \Illuminate\Filesystem\Filesystem::moveDirectory($from, $to, $overwrite);
4875 }
4876
4877 /**
4878 * Copy a directory from one location to another.
4879 *
4880 * @param string $directory
4881 * @param string $destination
4882 * @param int $options
4883 * @return bool
4884 * @static
4885 */
4886 public static function copyDirectory($directory, $destination, $options = null)
4887 {
4888 return \Illuminate\Filesystem\Filesystem::copyDirectory($directory, $destination, $options);
4889 }
4890
4891 /**
4892 * Recursively delete a directory.
4893 *
4894 * The directory itself may be optionally preserved.
4895 *
4896 * @param string $directory
4897 * @param bool $preserve
4898 * @return bool
4899 * @static
4900 */
4901 public static function deleteDirectory($directory, $preserve = false)
4902 {
4903 return \Illuminate\Filesystem\Filesystem::deleteDirectory($directory, $preserve);
4904 }
4905
4906 /**
4907 * Empty the specified directory of all files and folders.
4908 *
4909 * @param string $directory
4910 * @return bool
4911 * @static
4912 */
4913 public static function cleanDirectory($directory)
4914 {
4915 return \Illuminate\Filesystem\Filesystem::cleanDirectory($directory);
4916 }
4917
4918 /**
4919 * Register a custom macro.
4920 *
4921 * @param string $name
4922 * @param object|callable $macro
4923 * @return void
4924 * @static
4925 */
4926 public static function macro($name, $macro)
4927 {
4928 \Illuminate\Filesystem\Filesystem::macro($name, $macro);
4929 }
4930
4931 /**
4932 * Mix another object into the class.
4933 *
4934 * @param object $mixin
4935 * @return void
4936 * @throws \ReflectionException
4937 * @static
4938 */
4939 public static function mixin($mixin)
4940 {
4941 \Illuminate\Filesystem\Filesystem::mixin($mixin);
4942 }
4943
4944 /**
4945 * Checks if macro is registered.
4946 *
4947 * @param string $name
4948 * @return bool
4949 * @static
4950 */
4951 public static function hasMacro($name)
4952 {
4953 return \Illuminate\Filesystem\Filesystem::hasMacro($name);
4954 }
4955
4956 }
4957
4958 class Gate {
4959
4960 /**
4961 * Determine if a given ability has been defined.
4962 *
4963 * @param string|array $ability
4964 * @return bool
4965 * @static
4966 */
4967 public static function has($ability)
4968 {
4969 return \Illuminate\Auth\Access\Gate::has($ability);
4970 }
4971
4972 /**
4973 * Define a new ability.
4974 *
4975 * @param string $ability
4976 * @param callable|string $callback
4977 * @return $this
4978 * @throws \InvalidArgumentException
4979 * @static
4980 */
4981 public static function define($ability, $callback)
4982 {
4983 return \Illuminate\Auth\Access\Gate::define($ability, $callback);
4984 }
4985
4986 /**
4987 * Define abilities for a resource.
4988 *
4989 * @param string $name
4990 * @param string $class
4991 * @param array|null $abilities
4992 * @return $this
4993 * @static
4994 */
4995 public static function resource($name, $class, $abilities = null)
4996 {
4997 return \Illuminate\Auth\Access\Gate::resource($name, $class, $abilities);
4998 }
4999
5000 /**
5001 * Define a policy class for a given class type.
5002 *
5003 * @param string $class
5004 * @param string $policy
5005 * @return $this
5006 * @static
5007 */
5008 public static function policy($class, $policy)
5009 {
5010 return \Illuminate\Auth\Access\Gate::policy($class, $policy);
5011 }
5012
5013 /**
5014 * Register a callback to run before all Gate checks.
5015 *
5016 * @param callable $callback
5017 * @return $this
5018 * @static
5019 */
5020 public static function before($callback)
5021 {
5022 return \Illuminate\Auth\Access\Gate::before($callback);
5023 }
5024
5025 /**
5026 * Register a callback to run after all Gate checks.
5027 *
5028 * @param callable $callback
5029 * @return $this
5030 * @static
5031 */
5032 public static function after($callback)
5033 {
5034 return \Illuminate\Auth\Access\Gate::after($callback);
5035 }
5036
5037 /**
5038 * Determine if the given ability should be granted for the current user.
5039 *
5040 * @param string $ability
5041 * @param array|mixed $arguments
5042 * @return bool
5043 * @static
5044 */
5045 public static function allows($ability, $arguments = array())
5046 {
5047 return \Illuminate\Auth\Access\Gate::allows($ability, $arguments);
5048 }
5049
5050 /**
5051 * Determine if the given ability should be denied for the current user.
5052 *
5053 * @param string $ability
5054 * @param array|mixed $arguments
5055 * @return bool
5056 * @static
5057 */
5058 public static function denies($ability, $arguments = array())
5059 {
5060 return \Illuminate\Auth\Access\Gate::denies($ability, $arguments);
5061 }
5062
5063 /**
5064 * Determine if all of the given abilities should be granted for the current user.
5065 *
5066 * @param \Illuminate\Auth\Access\iterable|string $abilities
5067 * @param array|mixed $arguments
5068 * @return bool
5069 * @static
5070 */
5071 public static function check($abilities, $arguments = array())
5072 {
5073 return \Illuminate\Auth\Access\Gate::check($abilities, $arguments);
5074 }
5075
5076 /**
5077 * Determine if any one of the given abilities should be granted for the current user.
5078 *
5079 * @param \Illuminate\Auth\Access\iterable|string $abilities
5080 * @param array|mixed $arguments
5081 * @return bool
5082 * @static
5083 */
5084 public static function any($abilities, $arguments = array())
5085 {
5086 return \Illuminate\Auth\Access\Gate::any($abilities, $arguments);
5087 }
5088
5089 /**
5090 * Determine if the given ability should be granted for the current user.
5091 *
5092 * @param string $ability
5093 * @param array|mixed $arguments
5094 * @return \Illuminate\Auth\Access\Response
5095 * @throws \Illuminate\Auth\Access\AuthorizationException
5096 * @static
5097 */
5098 public static function authorize($ability, $arguments = array())
5099 {
5100 return \Illuminate\Auth\Access\Gate::authorize($ability, $arguments);
5101 }
5102
5103 /**
5104 * Get a policy instance for a given class.
5105 *
5106 * @param object|string $class
5107 * @return mixed
5108 * @static
5109 */
5110 public static function getPolicyFor($class)
5111 {
5112 return \Illuminate\Auth\Access\Gate::getPolicyFor($class);
5113 }
5114
5115 /**
5116 * Build a policy class instance of the given type.
5117 *
5118 * @param object|string $class
5119 * @return mixed
5120 * @static
5121 */
5122 public static function resolvePolicy($class)
5123 {
5124 return \Illuminate\Auth\Access\Gate::resolvePolicy($class);
5125 }
5126
5127 /**
5128 * Get a gate instance for the given user.
5129 *
5130 * @param \Illuminate\Contracts\Auth\Authenticatable|mixed $user
5131 * @return static
5132 * @static
5133 */
5134 public static function forUser($user)
5135 {
5136 return \Illuminate\Auth\Access\Gate::forUser($user);
5137 }
5138
5139 /**
5140 * Get all of the defined abilities.
5141 *
5142 * @return array
5143 * @static
5144 */
5145 public static function abilities()
5146 {
5147 return \Illuminate\Auth\Access\Gate::abilities();
5148 }
5149
5150 /**
5151 * Get all of the defined policies.
5152 *
5153 * @return array
5154 * @static
5155 */
5156 public static function policies()
5157 {
5158 return \Illuminate\Auth\Access\Gate::policies();
5159 }
5160
5161 }
5162
5163 class Hash {
5164
5165 /**
5166 * Create an instance of the Bcrypt hash Driver.
5167 *
5168 * @return \Illuminate\Hashing\BcryptHasher
5169 * @static
5170 */
5171 public static function createBcryptDriver()
5172 {
5173 return \Illuminate\Hashing\HashManager::createBcryptDriver();
5174 }
5175
5176 /**
5177 * Create an instance of the Argon2 hash Driver.
5178 *
5179 * @return \Illuminate\Hashing\ArgonHasher
5180 * @static
5181 */
5182 public static function createArgonDriver()
5183 {
5184 return \Illuminate\Hashing\HashManager::createArgonDriver();
5185 }
5186
5187 /**
5188 * Get information about the given hashed value.
5189 *
5190 * @param string $hashedValue
5191 * @return array
5192 * @static
5193 */
5194 public static function info($hashedValue)
5195 {
5196 return \Illuminate\Hashing\HashManager::info($hashedValue);
5197 }
5198
5199 /**
5200 * Hash the given value.
5201 *
5202 * @param string $value
5203 * @param array $options
5204 * @return string
5205 * @static
5206 */
5207 public static function make($value, $options = array())
5208 {
5209 return \Illuminate\Hashing\HashManager::make($value, $options);
5210 }
5211
5212 /**
5213 * Check the given plain value against a hash.
5214 *
5215 * @param string $value
5216 * @param string $hashedValue
5217 * @param array $options
5218 * @return bool
5219 * @static
5220 */
5221 public static function check($value, $hashedValue, $options = array())
5222 {
5223 return \Illuminate\Hashing\HashManager::check($value, $hashedValue, $options);
5224 }
5225
5226 /**
5227 * Check if the given hash has been hashed using the given options.
5228 *
5229 * @param string $hashedValue
5230 * @param array $options
5231 * @return bool
5232 * @static
5233 */
5234 public static function needsRehash($hashedValue, $options = array())
5235 {
5236 return \Illuminate\Hashing\HashManager::needsRehash($hashedValue, $options);
5237 }
5238
5239 /**
5240 * Get the default driver name.
5241 *
5242 * @return string
5243 * @static
5244 */
5245 public static function getDefaultDriver()
5246 {
5247 return \Illuminate\Hashing\HashManager::getDefaultDriver();
5248 }
5249
5250 /**
5251 * Get a driver instance.
5252 *
5253 * @param string $driver
5254 * @return mixed
5255 * @static
5256 */
5257 public static function driver($driver = null)
5258 {
5259 //Method inherited from \Illuminate\Support\Manager
5260 return \Illuminate\Hashing\HashManager::driver($driver);
5261 }
5262
5263 /**
5264 * Register a custom driver creator Closure.
5265 *
5266 * @param string $driver
5267 * @param \Closure $callback
5268 * @return $this
5269 * @static
5270 */
5271 public static function extend($driver, $callback)
5272 {
5273 //Method inherited from \Illuminate\Support\Manager
5274 return \Illuminate\Hashing\HashManager::extend($driver, $callback);
5275 }
5276
5277 /**
5278 * Get all of the created "drivers".
5279 *
5280 * @return array
5281 * @static
5282 */
5283 public static function getDrivers()
5284 {
5285 //Method inherited from \Illuminate\Support\Manager
5286 return \Illuminate\Hashing\HashManager::getDrivers();
5287 }
5288
5289 }
5290
5291 class Lang {
5292
5293 /**
5294 * Determine if a translation exists for a given locale.
5295 *
5296 * @param string $key
5297 * @param string|null $locale
5298 * @return bool
5299 * @static
5300 */
5301 public static function hasForLocale($key, $locale = null)
5302 {
5303 return \Illuminate\Translation\Translator::hasForLocale($key, $locale);
5304 }
5305
5306 /**
5307 * Determine if a translation exists.
5308 *
5309 * @param string $key
5310 * @param string|null $locale
5311 * @param bool $fallback
5312 * @return bool
5313 * @static
5314 */
5315 public static function has($key, $locale = null, $fallback = true)
5316 {
5317 return \Illuminate\Translation\Translator::has($key, $locale, $fallback);
5318 }
5319
5320 /**
5321 * Get the translation for a given key.
5322 *
5323 * @param string $key
5324 * @param array $replace
5325 * @param string $locale
5326 * @return string|array|null
5327 * @static
5328 */
5329 public static function trans($key, $replace = array(), $locale = null)
5330 {
5331 return \Illuminate\Translation\Translator::trans($key, $replace, $locale);
5332 }
5333
5334 /**
5335 * Get the translation for the given key.
5336 *
5337 * @param string $key
5338 * @param array $replace
5339 * @param string|null $locale
5340 * @param bool $fallback
5341 * @return string|array|null
5342 * @static
5343 */
5344 public static function get($key, $replace = array(), $locale = null, $fallback = true)
5345 {
5346 return \Illuminate\Translation\Translator::get($key, $replace, $locale, $fallback);
5347 }
5348
5349 /**
5350 * Get the translation for a given key from the JSON translation files.
5351 *
5352 * @param string $key
5353 * @param array $replace
5354 * @param string $locale
5355 * @return string|array|null
5356 * @static
5357 */
5358 public static function getFromJson($key, $replace = array(), $locale = null)
5359 {
5360 return \Illuminate\Translation\Translator::getFromJson($key, $replace, $locale);
5361 }
5362
5363 /**
5364 * Get a translation according to an integer value.
5365 *
5366 * @param string $key
5367 * @param int|array|\Countable $number
5368 * @param array $replace
5369 * @param string $locale
5370 * @return string
5371 * @static
5372 */
5373 public static function transChoice($key, $number, $replace = array(), $locale = null)
5374 {
5375 return \Illuminate\Translation\Translator::transChoice($key, $number, $replace, $locale);
5376 }
5377
5378 /**
5379 * Get a translation according to an integer value.
5380 *
5381 * @param string $key
5382 * @param int|array|\Countable $number
5383 * @param array $replace
5384 * @param string $locale
5385 * @return string
5386 * @static
5387 */
5388 public static function choice($key, $number, $replace = array(), $locale = null)
5389 {
5390 return \Illuminate\Translation\Translator::choice($key, $number, $replace, $locale);
5391 }
5392
5393 /**
5394 * Add translation lines to the given locale.
5395 *
5396 * @param array $lines
5397 * @param string $locale
5398 * @param string $namespace
5399 * @return void
5400 * @static
5401 */
5402 public static function addLines($lines, $locale, $namespace = '*')
5403 {
5404 \Illuminate\Translation\Translator::addLines($lines, $locale, $namespace);
5405 }
5406
5407 /**
5408 * Load the specified language group.
5409 *
5410 * @param string $namespace
5411 * @param string $group
5412 * @param string $locale
5413 * @return void
5414 * @static
5415 */
5416 public static function load($namespace, $group, $locale)
5417 {
5418 \Illuminate\Translation\Translator::load($namespace, $group, $locale);
5419 }
5420
5421 /**
5422 * Add a new namespace to the loader.
5423 *
5424 * @param string $namespace
5425 * @param string $hint
5426 * @return void
5427 * @static
5428 */
5429 public static function addNamespace($namespace, $hint)
5430 {
5431 \Illuminate\Translation\Translator::addNamespace($namespace, $hint);
5432 }
5433
5434 /**
5435 * Add a new JSON path to the loader.
5436 *
5437 * @param string $path
5438 * @return void
5439 * @static
5440 */
5441 public static function addJsonPath($path)
5442 {
5443 \Illuminate\Translation\Translator::addJsonPath($path);
5444 }
5445
5446 /**
5447 * Parse a key into namespace, group, and item.
5448 *
5449 * @param string $key
5450 * @return array
5451 * @static
5452 */
5453 public static function parseKey($key)
5454 {
5455 return \Illuminate\Translation\Translator::parseKey($key);
5456 }
5457
5458 /**
5459 * Get the message selector instance.
5460 *
5461 * @return \Illuminate\Translation\MessageSelector
5462 * @static
5463 */
5464 public static function getSelector()
5465 {
5466 return \Illuminate\Translation\Translator::getSelector();
5467 }
5468
5469 /**
5470 * Set the message selector instance.
5471 *
5472 * @param \Illuminate\Translation\MessageSelector $selector
5473 * @return void
5474 * @static
5475 */
5476 public static function setSelector($selector)
5477 {
5478 \Illuminate\Translation\Translator::setSelector($selector);
5479 }
5480
5481 /**
5482 * Get the language line loader implementation.
5483 *
5484 * @return \Illuminate\Contracts\Translation\Loader
5485 * @static
5486 */
5487 public static function getLoader()
5488 {
5489 return \Illuminate\Translation\Translator::getLoader();
5490 }
5491
5492 /**
5493 * Get the default locale being used.
5494 *
5495 * @return string
5496 * @static
5497 */
5498 public static function locale()
5499 {
5500 return \Illuminate\Translation\Translator::locale();
5501 }
5502
5503 /**
5504 * Get the default locale being used.
5505 *
5506 * @return string
5507 * @static
5508 */
5509 public static function getLocale()
5510 {
5511 return \Illuminate\Translation\Translator::getLocale();
5512 }
5513
5514 /**
5515 * Set the default locale.
5516 *
5517 * @param string $locale
5518 * @return void
5519 * @static
5520 */
5521 public static function setLocale($locale)
5522 {
5523 \Illuminate\Translation\Translator::setLocale($locale);
5524 }
5525
5526 /**
5527 * Get the fallback locale being used.
5528 *
5529 * @return string
5530 * @static
5531 */
5532 public static function getFallback()
5533 {
5534 return \Illuminate\Translation\Translator::getFallback();
5535 }
5536
5537 /**
5538 * Set the fallback locale being used.
5539 *
5540 * @param string $fallback
5541 * @return void
5542 * @static
5543 */
5544 public static function setFallback($fallback)
5545 {
5546 \Illuminate\Translation\Translator::setFallback($fallback);
5547 }
5548
5549 /**
5550 * Set the loaded translation groups.
5551 *
5552 * @param array $loaded
5553 * @return void
5554 * @static
5555 */
5556 public static function setLoaded($loaded)
5557 {
5558 \Illuminate\Translation\Translator::setLoaded($loaded);
5559 }
5560
5561 /**
5562 * Set the parsed value of a key.
5563 *
5564 * @param string $key
5565 * @param array $parsed
5566 * @return void
5567 * @static
5568 */
5569 public static function setParsedKey($key, $parsed)
5570 {
5571 //Method inherited from \Illuminate\Support\NamespacedItemResolver
5572 \Illuminate\Translation\Translator::setParsedKey($key, $parsed);
5573 }
5574
5575 /**
5576 * Register a custom macro.
5577 *
5578 * @param string $name
5579 * @param object|callable $macro
5580 * @return void
5581 * @static
5582 */
5583 public static function macro($name, $macro)
5584 {
5585 \Illuminate\Translation\Translator::macro($name, $macro);
5586 }
5587
5588 /**
5589 * Mix another object into the class.
5590 *
5591 * @param object $mixin
5592 * @return void
5593 * @throws \ReflectionException
5594 * @static
5595 */
5596 public static function mixin($mixin)
5597 {
5598 \Illuminate\Translation\Translator::mixin($mixin);
5599 }
5600
5601 /**
5602 * Checks if macro is registered.
5603 *
5604 * @param string $name
5605 * @return bool
5606 * @static
5607 */
5608 public static function hasMacro($name)
5609 {
5610 return \Illuminate\Translation\Translator::hasMacro($name);
5611 }
5612
5613 }
5614
5615 class Log {
5616
5617 /**
5618 * Adds a log record at the DEBUG level.
5619 *
5620 * @param string $message The log message
5621 * @param array $context The log context
5622 * @return Boolean Whether the record has been processed
5623 * @static
5624 */
5625 public static function debug($message, $context = array())
5626 {
5627 return \Monolog\Logger::debug($message, $context);
5628 }
5629
5630 /**
5631 * Adds a log record at the INFO level.
5632 *
5633 * @param string $message The log message
5634 * @param array $context The log context
5635 * @return Boolean Whether the record has been processed
5636 * @static
5637 */
5638 public static function info($message, $context = array())
5639 {
5640 return \Monolog\Logger::info($message, $context);
5641 }
5642
5643 /**
5644 * Adds a log record at the NOTICE level.
5645 *
5646 * @param string $message The log message
5647 * @param array $context The log context
5648 * @return Boolean Whether the record has been processed
5649 * @static
5650 */
5651 public static function notice($message, $context = array())
5652 {
5653 return \Monolog\Logger::notice($message, $context);
5654 }
5655
5656 /**
5657 * Adds a log record at the WARNING level.
5658 *
5659 * @param string $message The log message
5660 * @param array $context The log context
5661 * @return Boolean Whether the record has been processed
5662 * @static
5663 */
5664 public static function warning($message, $context = array())
5665 {
5666 return \Monolog\Logger::warning($message, $context);
5667 }
5668
5669 /**
5670 * Adds a log record at the ERROR level.
5671 *
5672 * @param string $message The log message
5673 * @param array $context The log context
5674 * @return Boolean Whether the record has been processed
5675 * @static
5676 */
5677 public static function error($message, $context = array())
5678 {
5679 return \Monolog\Logger::error($message, $context);
5680 }
5681
5682 /**
5683 * Adds a log record at the CRITICAL level.
5684 *
5685 * @param string $message The log message
5686 * @param array $context The log context
5687 * @return Boolean Whether the record has been processed
5688 * @static
5689 */
5690 public static function critical($message, $context = array())
5691 {
5692 return \Monolog\Logger::critical($message, $context);
5693 }
5694
5695 /**
5696 * Adds a log record at the ALERT level.
5697 *
5698 * @param string $message The log message
5699 * @param array $context The log context
5700 * @return Boolean Whether the record has been processed
5701 * @static
5702 */
5703 public static function alert($message, $context = array())
5704 {
5705 return \Monolog\Logger::alert($message, $context);
5706 }
5707
5708 /**
5709 * Adds a log record at the EMERGENCY level.
5710 *
5711 * @param string $message The log message
5712 * @param array $context The log context
5713 * @return Boolean Whether the record has been processed
5714 * @static
5715 */
5716 public static function emergency($message, $context = array())
5717 {
5718 return \Monolog\Logger::emergency($message, $context);
5719 }
5720
5721 /**
5722 * Create a new, on-demand aggregate logger instance.
5723 *
5724 * @param array $channels
5725 * @param string|null $channel
5726 * @return \Psr\Log\LoggerInterface
5727 * @static
5728 */
5729 public static function stack($channels, $channel = null)
5730 {
5731 return \Illuminate\Log\LogManager::stack($channels, $channel);
5732 }
5733
5734 /**
5735 * Get a log channel instance.
5736 *
5737 * @param string|null $channel
5738 * @return mixed
5739 * @static
5740 */
5741 public static function channel($channel = null)
5742 {
5743 return \Illuminate\Log\LogManager::channel($channel);
5744 }
5745
5746 /**
5747 * Get a log driver instance.
5748 *
5749 * @param string|null $driver
5750 * @return mixed
5751 * @static
5752 */
5753 public static function driver($driver = null)
5754 {
5755 return \Illuminate\Log\LogManager::driver($driver);
5756 }
5757
5758 /**
5759 * Get the default log driver name.
5760 *
5761 * @return string
5762 * @static
5763 */
5764 public static function getDefaultDriver()
5765 {
5766 return \Illuminate\Log\LogManager::getDefaultDriver();
5767 }
5768
5769 /**
5770 * Set the default log driver name.
5771 *
5772 * @param string $name
5773 * @return void
5774 * @static
5775 */
5776 public static function setDefaultDriver($name)
5777 {
5778 \Illuminate\Log\LogManager::setDefaultDriver($name);
5779 }
5780
5781 /**
5782 * Register a custom driver creator Closure.
5783 *
5784 * @param string $driver
5785 * @param \Closure $callback
5786 * @return $this
5787 * @static
5788 */
5789 public static function extend($driver, $callback)
5790 {
5791 return \Illuminate\Log\LogManager::extend($driver, $callback);
5792 }
5793
5794 /**
5795 * Logs with an arbitrary level.
5796 *
5797 * @param mixed $level
5798 * @param string $message
5799 * @param array $context
5800 * @return void
5801 * @static
5802 */
5803 public static function log($level, $message, $context = array())
5804 {
5805 \Illuminate\Log\LogManager::log($level, $message, $context);
5806 }
5807
5808 }
5809
5810 class Mail {
5811
5812 /**
5813 * Set the global from address and name.
5814 *
5815 * @param string $address
5816 * @param string|null $name
5817 * @return void
5818 * @static
5819 */
5820 public static function alwaysFrom($address, $name = null)
5821 {
5822 \Illuminate\Mail\Mailer::alwaysFrom($address, $name);
5823 }
5824
5825 /**
5826 * Set the global reply-to address and name.
5827 *
5828 * @param string $address
5829 * @param string|null $name
5830 * @return void
5831 * @static
5832 */
5833 public static function alwaysReplyTo($address, $name = null)
5834 {
5835 \Illuminate\Mail\Mailer::alwaysReplyTo($address, $name);
5836 }
5837
5838 /**
5839 * Set the global to address and name.
5840 *
5841 * @param string $address
5842 * @param string|null $name
5843 * @return void
5844 * @static
5845 */
5846 public static function alwaysTo($address, $name = null)
5847 {
5848 \Illuminate\Mail\Mailer::alwaysTo($address, $name);
5849 }
5850
5851 /**
5852 * Begin the process of mailing a mailable class instance.
5853 *
5854 * @param mixed $users
5855 * @return \Illuminate\Mail\PendingMail
5856 * @static
5857 */
5858 public static function to($users)
5859 {
5860 return \Illuminate\Mail\Mailer::to($users);
5861 }
5862
5863 /**
5864 * Begin the process of mailing a mailable class instance.
5865 *
5866 * @param mixed $users
5867 * @return \Illuminate\Mail\PendingMail
5868 * @static
5869 */
5870 public static function bcc($users)
5871 {
5872 return \Illuminate\Mail\Mailer::bcc($users);
5873 }
5874
5875 /**
5876 * Send a new message with only an HTML part.
5877 *
5878 * @param string $html
5879 * @param mixed $callback
5880 * @return void
5881 * @static
5882 */
5883 public static function html($html, $callback)
5884 {
5885 \Illuminate\Mail\Mailer::html($html, $callback);
5886 }
5887
5888 /**
5889 * Send a new message when only a raw text part.
5890 *
5891 * @param string $text
5892 * @param mixed $callback
5893 * @return void
5894 * @static
5895 */
5896 public static function raw($text, $callback)
5897 {
5898 \Illuminate\Mail\Mailer::raw($text, $callback);
5899 }
5900
5901 /**
5902 * Send a new message when only a plain part.
5903 *
5904 * @param string $view
5905 * @param array $data
5906 * @param mixed $callback
5907 * @return void
5908 * @static
5909 */
5910 public static function plain($view, $data, $callback)
5911 {
5912 \Illuminate\Mail\Mailer::plain($view, $data, $callback);
5913 }
5914
5915 /**
5916 * Render the given message as a view.
5917 *
5918 * @param string|array $view
5919 * @param array $data
5920 * @return string
5921 * @static
5922 */
5923 public static function render($view, $data = array())
5924 {
5925 return \Illuminate\Mail\Mailer::render($view, $data);
5926 }
5927
5928 /**
5929 * Send a new message using a view.
5930 *
5931 * @param string|array|\Illuminate\Mail\MailableContract $view
5932 * @param array $data
5933 * @param \Closure|string $callback
5934 * @return void
5935 * @static
5936 */
5937 public static function send($view, $data = array(), $callback = null)
5938 {
5939 \Illuminate\Mail\Mailer::send($view, $data, $callback);
5940 }
5941
5942 /**
5943 * Queue a new e-mail message for sending.
5944 *
5945 * @param string|array|\Illuminate\Mail\MailableContract $view
5946 * @param string|null $queue
5947 * @return mixed
5948 * @static
5949 */
5950 public static function queue($view, $queue = null)
5951 {
5952 return \Illuminate\Mail\Mailer::queue($view, $queue);
5953 }
5954
5955 /**
5956 * Queue a new e-mail message for sending on the given queue.
5957 *
5958 * @param string $queue
5959 * @param string|array $view
5960 * @return mixed
5961 * @static
5962 */
5963 public static function onQueue($queue, $view)
5964 {
5965 return \Illuminate\Mail\Mailer::onQueue($queue, $view);
5966 }
5967
5968 /**
5969 * Queue a new e-mail message for sending on the given queue.
5970 *
5971 * This method didn't match rest of framework's "onQueue" phrasing. Added "onQueue".
5972 *
5973 * @param string $queue
5974 * @param string|array $view
5975 * @return mixed
5976 * @static
5977 */
5978 public static function queueOn($queue, $view)
5979 {
5980 return \Illuminate\Mail\Mailer::queueOn($queue, $view);
5981 }
5982
5983 /**
5984 * Queue a new e-mail message for sending after (n) seconds.
5985 *
5986 * @param \DateTimeInterface|\DateInterval|int $delay
5987 * @param string|array|\Illuminate\Mail\MailableContract $view
5988 * @param string|null $queue
5989 * @return mixed
5990 * @static
5991 */
5992 public static function later($delay, $view, $queue = null)
5993 {
5994 return \Illuminate\Mail\Mailer::later($delay, $view, $queue);
5995 }
5996
5997 /**
5998 * Queue a new e-mail message for sending after (n) seconds on the given queue.
5999 *
6000 * @param string $queue
6001 * @param \DateTimeInterface|\DateInterval|int $delay
6002 * @param string|array $view
6003 * @return mixed
6004 * @static
6005 */
6006 public static function laterOn($queue, $delay, $view)
6007 {
6008 return \Illuminate\Mail\Mailer::laterOn($queue, $delay, $view);
6009 }
6010
6011 /**
6012 * Get the view factory instance.
6013 *
6014 * @return \Illuminate\Contracts\View\Factory
6015 * @static
6016 */
6017 public static function getViewFactory()
6018 {
6019 return \Illuminate\Mail\Mailer::getViewFactory();
6020 }
6021
6022 /**
6023 * Get the Swift Mailer instance.
6024 *
6025 * @return \Swift_Mailer
6026 * @static
6027 */
6028 public static function getSwiftMailer()
6029 {
6030 return \Illuminate\Mail\Mailer::getSwiftMailer();
6031 }
6032
6033 /**
6034 * Get the array of failed recipients.
6035 *
6036 * @return array
6037 * @static
6038 */
6039 public static function failures()
6040 {
6041 return \Illuminate\Mail\Mailer::failures();
6042 }
6043
6044 /**
6045 * Set the Swift Mailer instance.
6046 *
6047 * @param \Swift_Mailer $swift
6048 * @return void
6049 * @static
6050 */
6051 public static function setSwiftMailer($swift)
6052 {
6053 \Illuminate\Mail\Mailer::setSwiftMailer($swift);
6054 }
6055
6056 /**
6057 * Set the queue manager instance.
6058 *
6059 * @param \Illuminate\Contracts\Queue\Factory $queue
6060 * @return $this
6061 * @static
6062 */
6063 public static function setQueue($queue)
6064 {
6065 return \Illuminate\Mail\Mailer::setQueue($queue);
6066 }
6067
6068 /**
6069 * Register a custom macro.
6070 *
6071 * @param string $name
6072 * @param object|callable $macro
6073 * @return void
6074 * @static
6075 */
6076 public static function macro($name, $macro)
6077 {
6078 \Illuminate\Mail\Mailer::macro($name, $macro);
6079 }
6080
6081 /**
6082 * Mix another object into the class.
6083 *
6084 * @param object $mixin
6085 * @return void
6086 * @throws \ReflectionException
6087 * @static
6088 */
6089 public static function mixin($mixin)
6090 {
6091 \Illuminate\Mail\Mailer::mixin($mixin);
6092 }
6093
6094 /**
6095 * Checks if macro is registered.
6096 *
6097 * @param string $name
6098 * @return bool
6099 * @static
6100 */
6101 public static function hasMacro($name)
6102 {
6103 return \Illuminate\Mail\Mailer::hasMacro($name);
6104 }
6105
6106 }
6107
6108 class Notification {
6109
6110 /**
6111 * Send the given notification to the given notifiable entities.
6112 *
6113 * @param \Illuminate\Support\Collection|array|mixed $notifiables
6114 * @param mixed $notification
6115 * @return void
6116 * @static
6117 */
6118 public static function send($notifiables, $notification)
6119 {
6120 \Illuminate\Notifications\ChannelManager::send($notifiables, $notification);
6121 }
6122
6123 /**
6124 * Send the given notification immediately.
6125 *
6126 * @param \Illuminate\Support\Collection|array|mixed $notifiables
6127 * @param mixed $notification
6128 * @param array|null $channels
6129 * @return void
6130 * @static
6131 */
6132 public static function sendNow($notifiables, $notification, $channels = null)
6133 {
6134 \Illuminate\Notifications\ChannelManager::sendNow($notifiables, $notification, $channels);
6135 }
6136
6137 /**
6138 * Get a channel instance.
6139 *
6140 * @param string|null $name
6141 * @return mixed
6142 * @static
6143 */
6144 public static function channel($name = null)
6145 {
6146 return \Illuminate\Notifications\ChannelManager::channel($name);
6147 }
6148
6149 /**
6150 * Get the default channel driver name.
6151 *
6152 * @return string
6153 * @static
6154 */
6155 public static function getDefaultDriver()
6156 {
6157 return \Illuminate\Notifications\ChannelManager::getDefaultDriver();
6158 }
6159
6160 /**
6161 * Get the default channel driver name.
6162 *
6163 * @return string
6164 * @static
6165 */
6166 public static function deliversVia()
6167 {
6168 return \Illuminate\Notifications\ChannelManager::deliversVia();
6169 }
6170
6171 /**
6172 * Set the default channel driver name.
6173 *
6174 * @param string $channel
6175 * @return void
6176 * @static
6177 */
6178 public static function deliverVia($channel)
6179 {
6180 \Illuminate\Notifications\ChannelManager::deliverVia($channel);
6181 }
6182
6183 /**
6184 * Get a driver instance.
6185 *
6186 * @param string $driver
6187 * @return mixed
6188 * @static
6189 */
6190 public static function driver($driver = null)
6191 {
6192 //Method inherited from \Illuminate\Support\Manager
6193 return \Illuminate\Notifications\ChannelManager::driver($driver);
6194 }
6195
6196 /**
6197 * Register a custom driver creator Closure.
6198 *
6199 * @param string $driver
6200 * @param \Closure $callback
6201 * @return $this
6202 * @static
6203 */
6204 public static function extend($driver, $callback)
6205 {
6206 //Method inherited from \Illuminate\Support\Manager
6207 return \Illuminate\Notifications\ChannelManager::extend($driver, $callback);
6208 }
6209
6210 /**
6211 * Get all of the created "drivers".
6212 *
6213 * @return array
6214 * @static
6215 */
6216 public static function getDrivers()
6217 {
6218 //Method inherited from \Illuminate\Support\Manager
6219 return \Illuminate\Notifications\ChannelManager::getDrivers();
6220 }
6221
6222 }
6223
6224 class Password {
6225
6226 /**
6227 * Attempt to get the broker from the local cache.
6228 *
6229 * @param string|null $name
6230 * @return \Illuminate\Contracts\Auth\PasswordBroker
6231 * @static
6232 */
6233 public static function broker($name = null)
6234 {
6235 return \Illuminate\Auth\Passwords\PasswordBrokerManager::broker($name);
6236 }
6237
6238 /**
6239 * Get the default password broker name.
6240 *
6241 * @return string
6242 * @static
6243 */
6244 public static function getDefaultDriver()
6245 {
6246 return \Illuminate\Auth\Passwords\PasswordBrokerManager::getDefaultDriver();
6247 }
6248
6249 /**
6250 * Set the default password broker name.
6251 *
6252 * @param string $name
6253 * @return void
6254 * @static
6255 */
6256 public static function setDefaultDriver($name)
6257 {
6258 \Illuminate\Auth\Passwords\PasswordBrokerManager::setDefaultDriver($name);
6259 }
6260
6261 }
6262
6263 class Queue {
6264
6265 /**
6266 * Register an event listener for the before job event.
6267 *
6268 * @param mixed $callback
6269 * @return void
6270 * @static
6271 */
6272 public static function before($callback)
6273 {
6274 \Illuminate\Queue\QueueManager::before($callback);
6275 }
6276
6277 /**
6278 * Register an event listener for the after job event.
6279 *
6280 * @param mixed $callback
6281 * @return void
6282 * @static
6283 */
6284 public static function after($callback)
6285 {
6286 \Illuminate\Queue\QueueManager::after($callback);
6287 }
6288
6289 /**
6290 * Register an event listener for the exception occurred job event.
6291 *
6292 * @param mixed $callback
6293 * @return void
6294 * @static
6295 */
6296 public static function exceptionOccurred($callback)
6297 {
6298 \Illuminate\Queue\QueueManager::exceptionOccurred($callback);
6299 }
6300
6301 /**
6302 * Register an event listener for the daemon queue loop.
6303 *
6304 * @param mixed $callback
6305 * @return void
6306 * @static
6307 */
6308 public static function looping($callback)
6309 {
6310 \Illuminate\Queue\QueueManager::looping($callback);
6311 }
6312
6313 /**
6314 * Register an event listener for the failed job event.
6315 *
6316 * @param mixed $callback
6317 * @return void
6318 * @static
6319 */
6320 public static function failing($callback)
6321 {
6322 \Illuminate\Queue\QueueManager::failing($callback);
6323 }
6324
6325 /**
6326 * Register an event listener for the daemon queue stopping.
6327 *
6328 * @param mixed $callback
6329 * @return void
6330 * @static
6331 */
6332 public static function stopping($callback)
6333 {
6334 \Illuminate\Queue\QueueManager::stopping($callback);
6335 }
6336
6337 /**
6338 * Determine if the driver is connected.
6339 *
6340 * @param string $name
6341 * @return bool
6342 * @static
6343 */
6344 public static function connected($name = null)
6345 {
6346 return \Illuminate\Queue\QueueManager::connected($name);
6347 }
6348
6349 /**
6350 * Resolve a queue connection instance.
6351 *
6352 * @param string $name
6353 * @return \Illuminate\Contracts\Queue\Queue
6354 * @static
6355 */
6356 public static function connection($name = null)
6357 {
6358 return \Illuminate\Queue\QueueManager::connection($name);
6359 }
6360
6361 /**
6362 * Add a queue connection resolver.
6363 *
6364 * @param string $driver
6365 * @param \Closure $resolver
6366 * @return void
6367 * @static
6368 */
6369 public static function extend($driver, $resolver)
6370 {
6371 \Illuminate\Queue\QueueManager::extend($driver, $resolver);
6372 }
6373
6374 /**
6375 * Add a queue connection resolver.
6376 *
6377 * @param string $driver
6378 * @param \Closure $resolver
6379 * @return void
6380 * @static
6381 */
6382 public static function addConnector($driver, $resolver)
6383 {
6384 \Illuminate\Queue\QueueManager::addConnector($driver, $resolver);
6385 }
6386
6387 /**
6388 * Get the name of the default queue connection.
6389 *
6390 * @return string
6391 * @static
6392 */
6393 public static function getDefaultDriver()
6394 {
6395 return \Illuminate\Queue\QueueManager::getDefaultDriver();
6396 }
6397
6398 /**
6399 * Set the name of the default queue connection.
6400 *
6401 * @param string $name
6402 * @return void
6403 * @static
6404 */
6405 public static function setDefaultDriver($name)
6406 {
6407 \Illuminate\Queue\QueueManager::setDefaultDriver($name);
6408 }
6409
6410 /**
6411 * Get the full name for the given connection.
6412 *
6413 * @param string $connection
6414 * @return string
6415 * @static
6416 */
6417 public static function getName($connection = null)
6418 {
6419 return \Illuminate\Queue\QueueManager::getName($connection);
6420 }
6421
6422 /**
6423 * Determine if the application is in maintenance mode.
6424 *
6425 * @return bool
6426 * @static
6427 */
6428 public static function isDownForMaintenance()
6429 {
6430 return \Illuminate\Queue\QueueManager::isDownForMaintenance();
6431 }
6432
6433 /**
6434 * Get the size of the queue.
6435 *
6436 * @param string $queue
6437 * @return int
6438 * @static
6439 */
6440 public static function size($queue = null)
6441 {
6442 return \Illuminate\Queue\SyncQueue::size($queue);
6443 }
6444
6445 /**
6446 * Push a new job onto the queue.
6447 *
6448 * @param string $job
6449 * @param mixed $data
6450 * @param string $queue
6451 * @return mixed
6452 * @throws \Exception|\Throwable
6453 * @static
6454 */
6455 public static function push($job, $data = '', $queue = null)
6456 {
6457 return \Illuminate\Queue\SyncQueue::push($job, $data, $queue);
6458 }
6459
6460 /**
6461 * Push a raw payload onto the queue.
6462 *
6463 * @param string $payload
6464 * @param string $queue
6465 * @param array $options
6466 * @return mixed
6467 * @static
6468 */
6469 public static function pushRaw($payload, $queue = null, $options = array())
6470 {
6471 return \Illuminate\Queue\SyncQueue::pushRaw($payload, $queue, $options);
6472 }
6473
6474 /**
6475 * Push a new job onto the queue after a delay.
6476 *
6477 * @param \DateTimeInterface|\DateInterval|int $delay
6478 * @param string $job
6479 * @param mixed $data
6480 * @param string $queue
6481 * @return mixed
6482 * @static
6483 */
6484 public static function later($delay, $job, $data = '', $queue = null)
6485 {
6486 return \Illuminate\Queue\SyncQueue::later($delay, $job, $data, $queue);
6487 }
6488
6489 /**
6490 * Pop the next job off of the queue.
6491 *
6492 * @param string $queue
6493 * @return \Illuminate\Contracts\Queue\Job|null
6494 * @static
6495 */
6496 public static function pop($queue = null)
6497 {
6498 return \Illuminate\Queue\SyncQueue::pop($queue);
6499 }
6500
6501 /**
6502 * Push a new job onto the queue.
6503 *
6504 * @param string $queue
6505 * @param string $job
6506 * @param mixed $data
6507 * @return mixed
6508 * @static
6509 */
6510 public static function pushOn($queue, $job, $data = '')
6511 {
6512 //Method inherited from \Illuminate\Queue\Queue
6513 return \Illuminate\Queue\SyncQueue::pushOn($queue, $job, $data);
6514 }
6515
6516 /**
6517 * Push a new job onto the queue after a delay.
6518 *
6519 * @param string $queue
6520 * @param \DateTimeInterface|\DateInterval|int $delay
6521 * @param string $job
6522 * @param mixed $data
6523 * @return mixed
6524 * @static
6525 */
6526 public static function laterOn($queue, $delay, $job, $data = '')
6527 {
6528 //Method inherited from \Illuminate\Queue\Queue
6529 return \Illuminate\Queue\SyncQueue::laterOn($queue, $delay, $job, $data);
6530 }
6531
6532 /**
6533 * Push an array of jobs onto the queue.
6534 *
6535 * @param array $jobs
6536 * @param mixed $data
6537 * @param string $queue
6538 * @return mixed
6539 * @static
6540 */
6541 public static function bulk($jobs, $data = '', $queue = null)
6542 {
6543 //Method inherited from \Illuminate\Queue\Queue
6544 return \Illuminate\Queue\SyncQueue::bulk($jobs, $data, $queue);
6545 }
6546
6547 /**
6548 * Get the expiration timestamp for an object-based queue handler.
6549 *
6550 * @param mixed $job
6551 * @return mixed
6552 * @static
6553 */
6554 public static function getJobExpiration($job)
6555 {
6556 //Method inherited from \Illuminate\Queue\Queue
6557 return \Illuminate\Queue\SyncQueue::getJobExpiration($job);
6558 }
6559
6560 /**
6561 * Get the connection name for the queue.
6562 *
6563 * @return string
6564 * @static
6565 */
6566 public static function getConnectionName()
6567 {
6568 //Method inherited from \Illuminate\Queue\Queue
6569 return \Illuminate\Queue\SyncQueue::getConnectionName();
6570 }
6571
6572 /**
6573 * Set the connection name for the queue.
6574 *
6575 * @param string $name
6576 * @return $this
6577 * @static
6578 */
6579 public static function setConnectionName($name)
6580 {
6581 //Method inherited from \Illuminate\Queue\Queue
6582 return \Illuminate\Queue\SyncQueue::setConnectionName($name);
6583 }
6584
6585 /**
6586 * Set the IoC container instance.
6587 *
6588 * @param \Illuminate\Container\Container $container
6589 * @return void
6590 * @static
6591 */
6592 public static function setContainer($container)
6593 {
6594 //Method inherited from \Illuminate\Queue\Queue
6595 \Illuminate\Queue\SyncQueue::setContainer($container);
6596 }
6597
6598 }
6599
6600 class Redirect {
6601
6602 /**
6603 * Create a new redirect response to the "home" route.
6604 *
6605 * @param int $status
6606 * @return \Illuminate\Http\RedirectResponse
6607 * @static
6608 */
6609 public static function home($status = 302)
6610 {
6611 return \Illuminate\Routing\Redirector::home($status);
6612 }
6613
6614 /**
6615 * Create a new redirect response to the previous location.
6616 *
6617 * @param int $status
6618 * @param array $headers
6619 * @param mixed $fallback
6620 * @return \Illuminate\Http\RedirectResponse
6621 * @static
6622 */
6623 public static function back($status = 302, $headers = array(), $fallback = false)
6624 {
6625 return \Illuminate\Routing\Redirector::back($status, $headers, $fallback);
6626 }
6627
6628 /**
6629 * Create a new redirect response to the current URI.
6630 *
6631 * @param int $status
6632 * @param array $headers
6633 * @return \Illuminate\Http\RedirectResponse
6634 * @static
6635 */
6636 public static function refresh($status = 302, $headers = array())
6637 {
6638 return \Illuminate\Routing\Redirector::refresh($status, $headers);
6639 }
6640
6641 /**
6642 * Create a new redirect response, while putting the current URL in the session.
6643 *
6644 * @param string $path
6645 * @param int $status
6646 * @param array $headers
6647 * @param bool $secure
6648 * @return \Illuminate\Http\RedirectResponse
6649 * @static
6650 */
6651 public static function guest($path, $status = 302, $headers = array(), $secure = null)
6652 {
6653 return \Illuminate\Routing\Redirector::guest($path, $status, $headers, $secure);
6654 }
6655
6656 /**
6657 * Create a new redirect response to the previously intended location.
6658 *
6659 * @param string $default
6660 * @param int $status
6661 * @param array $headers
6662 * @param bool $secure
6663 * @return \Illuminate\Http\RedirectResponse
6664 * @static
6665 */
6666 public static function intended($default = '/', $status = 302, $headers = array(), $secure = null)
6667 {
6668 return \Illuminate\Routing\Redirector::intended($default, $status, $headers, $secure);
6669 }
6670
6671 /**
6672 * Create a new redirect response to the given path.
6673 *
6674 * @param string $path
6675 * @param int $status
6676 * @param array $headers
6677 * @param bool $secure
6678 * @return \Illuminate\Http\RedirectResponse
6679 * @static
6680 */
6681 public static function to($path, $status = 302, $headers = array(), $secure = null)
6682 {
6683 return \Illuminate\Routing\Redirector::to($path, $status, $headers, $secure);
6684 }
6685
6686 /**
6687 * Create a new redirect response to an external URL (no validation).
6688 *
6689 * @param string $path
6690 * @param int $status
6691 * @param array $headers
6692 * @return \Illuminate\Http\RedirectResponse
6693 * @static
6694 */
6695 public static function away($path, $status = 302, $headers = array())
6696 {
6697 return \Illuminate\Routing\Redirector::away($path, $status, $headers);
6698 }
6699
6700 /**
6701 * Create a new redirect response to the given HTTPS path.
6702 *
6703 * @param string $path
6704 * @param int $status
6705 * @param array $headers
6706 * @return \Illuminate\Http\RedirectResponse
6707 * @static
6708 */
6709 public static function secure($path, $status = 302, $headers = array())
6710 {
6711 return \Illuminate\Routing\Redirector::secure($path, $status, $headers);
6712 }
6713
6714 /**
6715 * Create a new redirect response to a named route.
6716 *
6717 * @param string $route
6718 * @param array $parameters
6719 * @param int $status
6720 * @param array $headers
6721 * @return \Illuminate\Http\RedirectResponse
6722 * @static
6723 */
6724 public static function route($route, $parameters = array(), $status = 302, $headers = array())
6725 {
6726 return \Illuminate\Routing\Redirector::route($route, $parameters, $status, $headers);
6727 }
6728
6729 /**
6730 * Create a new redirect response to a controller action.
6731 *
6732 * @param string $action
6733 * @param array $parameters
6734 * @param int $status
6735 * @param array $headers
6736 * @return \Illuminate\Http\RedirectResponse
6737 * @static
6738 */
6739 public static function action($action, $parameters = array(), $status = 302, $headers = array())
6740 {
6741 return \Illuminate\Routing\Redirector::action($action, $parameters, $status, $headers);
6742 }
6743
6744 /**
6745 * Get the URL generator instance.
6746 *
6747 * @return \Illuminate\Routing\UrlGenerator
6748 * @static
6749 */
6750 public static function getUrlGenerator()
6751 {
6752 return \Illuminate\Routing\Redirector::getUrlGenerator();
6753 }
6754
6755 /**
6756 * Set the active session store.
6757 *
6758 * @param \Illuminate\Session\Store $session
6759 * @return void
6760 * @static
6761 */
6762 public static function setSession($session)
6763 {
6764 \Illuminate\Routing\Redirector::setSession($session);
6765 }
6766
6767 /**
6768 * Register a custom macro.
6769 *
6770 * @param string $name
6771 * @param object|callable $macro
6772 * @return void
6773 * @static
6774 */
6775 public static function macro($name, $macro)
6776 {
6777 \Illuminate\Routing\Redirector::macro($name, $macro);
6778 }
6779
6780 /**
6781 * Mix another object into the class.
6782 *
6783 * @param object $mixin
6784 * @return void
6785 * @throws \ReflectionException
6786 * @static
6787 */
6788 public static function mixin($mixin)
6789 {
6790 \Illuminate\Routing\Redirector::mixin($mixin);
6791 }
6792
6793 /**
6794 * Checks if macro is registered.
6795 *
6796 * @param string $name
6797 * @return bool
6798 * @static
6799 */
6800 public static function hasMacro($name)
6801 {
6802 return \Illuminate\Routing\Redirector::hasMacro($name);
6803 }
6804
6805 }
6806
6807 class Request {
6808
6809 /**
6810 * Create a new Illuminate HTTP request from server variables.
6811 *
6812 * @return static
6813 * @static
6814 */
6815 public static function capture()
6816 {
6817 return \Illuminate\Http\Request::capture();
6818 }
6819
6820 /**
6821 * Return the Request instance.
6822 *
6823 * @return $this
6824 * @static
6825 */
6826 public static function instance()
6827 {
6828 return \Illuminate\Http\Request::instance();
6829 }
6830
6831 /**
6832 * Get the request method.
6833 *
6834 * @return string
6835 * @static
6836 */
6837 public static function method()
6838 {
6839 return \Illuminate\Http\Request::method();
6840 }
6841
6842 /**
6843 * Get the root URL for the application.
6844 *
6845 * @return string
6846 * @static
6847 */
6848 public static function root()
6849 {
6850 return \Illuminate\Http\Request::root();
6851 }
6852
6853 /**
6854 * Get the URL (no query string) for the request.
6855 *
6856 * @return string
6857 * @static
6858 */
6859 public static function url()
6860 {
6861 return \Illuminate\Http\Request::url();
6862 }
6863
6864 /**
6865 * Get the full URL for the request.
6866 *
6867 * @return string
6868 * @static
6869 */
6870 public static function fullUrl()
6871 {
6872 return \Illuminate\Http\Request::fullUrl();
6873 }
6874
6875 /**
6876 * Get the full URL for the request with the added query string parameters.
6877 *
6878 * @param array $query
6879 * @return string
6880 * @static
6881 */
6882 public static function fullUrlWithQuery($query)
6883 {
6884 return \Illuminate\Http\Request::fullUrlWithQuery($query);
6885 }
6886
6887 /**
6888 * Get the current path info for the request.
6889 *
6890 * @return string
6891 * @static
6892 */
6893 public static function path()
6894 {
6895 return \Illuminate\Http\Request::path();
6896 }
6897
6898 /**
6899 * Get the current decoded path info for the request.
6900 *
6901 * @return string
6902 * @static
6903 */
6904 public static function decodedPath()
6905 {
6906 return \Illuminate\Http\Request::decodedPath();
6907 }
6908
6909 /**
6910 * Get a segment from the URI (1 based index).
6911 *
6912 * @param int $index
6913 * @param string|null $default
6914 * @return string|null
6915 * @static
6916 */
6917 public static function segment($index, $default = null)
6918 {
6919 return \Illuminate\Http\Request::segment($index, $default);
6920 }
6921
6922 /**
6923 * Get all of the segments for the request path.
6924 *
6925 * @return array
6926 * @static
6927 */
6928 public static function segments()
6929 {
6930 return \Illuminate\Http\Request::segments();
6931 }
6932
6933 /**
6934 * Determine if the current request URI matches a pattern.
6935 *
6936 * @param mixed $patterns
6937 * @return bool
6938 * @static
6939 */
6940 public static function is($patterns = null)
6941 {
6942 return \Illuminate\Http\Request::is($patterns);
6943 }
6944
6945 /**
6946 * Determine if the route name matches a given pattern.
6947 *
6948 * @param mixed $patterns
6949 * @return bool
6950 * @static
6951 */
6952 public static function routeIs($patterns = null)
6953 {
6954 return \Illuminate\Http\Request::routeIs($patterns);
6955 }
6956
6957 /**
6958 * Determine if the current request URL and query string matches a pattern.
6959 *
6960 * @param mixed $patterns
6961 * @return bool
6962 * @static
6963 */
6964 public static function fullUrlIs($patterns = null)
6965 {
6966 return \Illuminate\Http\Request::fullUrlIs($patterns);
6967 }
6968
6969 /**
6970 * Determine if the request is the result of an AJAX call.
6971 *
6972 * @return bool
6973 * @static
6974 */
6975 public static function ajax()
6976 {
6977 return \Illuminate\Http\Request::ajax();
6978 }
6979
6980 /**
6981 * Determine if the request is the result of an PJAX call.
6982 *
6983 * @return bool
6984 * @static
6985 */
6986 public static function pjax()
6987 {
6988 return \Illuminate\Http\Request::pjax();
6989 }
6990
6991 /**
6992 * Determine if the request is over HTTPS.
6993 *
6994 * @return bool
6995 * @static
6996 */
6997 public static function secure()
6998 {
6999 return \Illuminate\Http\Request::secure();
7000 }
7001
7002 /**
7003 * Get the client IP address.
7004 *
7005 * @return string
7006 * @static
7007 */
7008 public static function ip()
7009 {
7010 return \Illuminate\Http\Request::ip();
7011 }
7012
7013 /**
7014 * Get the client IP addresses.
7015 *
7016 * @return array
7017 * @static
7018 */
7019 public static function ips()
7020 {
7021 return \Illuminate\Http\Request::ips();
7022 }
7023
7024 /**
7025 * Get the client user agent.
7026 *
7027 * @return string
7028 * @static
7029 */
7030 public static function userAgent()
7031 {
7032 return \Illuminate\Http\Request::userAgent();
7033 }
7034
7035 /**
7036 * Merge new input into the current request's input array.
7037 *
7038 * @param array $input
7039 * @return \Illuminate\Http\Request
7040 * @static
7041 */
7042 public static function merge($input)
7043 {
7044 return \Illuminate\Http\Request::merge($input);
7045 }
7046
7047 /**
7048 * Replace the input for the current request.
7049 *
7050 * @param array $input
7051 * @return \Illuminate\Http\Request
7052 * @static
7053 */
7054 public static function replace($input)
7055 {
7056 return \Illuminate\Http\Request::replace($input);
7057 }
7058
7059 /**
7060 * Get the JSON payload for the request.
7061 *
7062 * @param string $key
7063 * @param mixed $default
7064 * @return \Symfony\Component\HttpFoundation\ParameterBag|mixed
7065 * @static
7066 */
7067 public static function json($key = null, $default = null)
7068 {
7069 return \Illuminate\Http\Request::json($key, $default);
7070 }
7071
7072 /**
7073 * Create a new request instance from the given Laravel request.
7074 *
7075 * @param \Illuminate\Http\Request $from
7076 * @param \Illuminate\Http\Request|null $to
7077 * @return static
7078 * @static
7079 */
7080 public static function createFrom($from, $to = null)
7081 {
7082 return \Illuminate\Http\Request::createFrom($from, $to);
7083 }
7084
7085 /**
7086 * Create an Illuminate request from a Symfony instance.
7087 *
7088 * @param \Symfony\Component\HttpFoundation\Request $request
7089 * @return \Illuminate\Http\Request
7090 * @static
7091 */
7092 public static function createFromBase($request)
7093 {
7094 return \Illuminate\Http\Request::createFromBase($request);
7095 }
7096
7097 /**
7098 * Clones a request and overrides some of its parameters.
7099 *
7100 * @param array $query The GET parameters
7101 * @param array $request The POST parameters
7102 * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
7103 * @param array $cookies The COOKIE parameters
7104 * @param array $files The FILES parameters
7105 * @param array $server The SERVER parameters
7106 * @return static
7107 * @static
7108 */
7109 public static function duplicate($query = null, $request = null, $attributes = null, $cookies = null, $files = null, $server = null)
7110 {
7111 return \Illuminate\Http\Request::duplicate($query, $request, $attributes, $cookies, $files, $server);
7112 }
7113
7114 /**
7115 * Get the session associated with the request.
7116 *
7117 * @return \Illuminate\Session\Store
7118 * @throws \RuntimeException
7119 * @static
7120 */
7121 public static function session()
7122 {
7123 return \Illuminate\Http\Request::session();
7124 }
7125
7126 /**
7127 * Get the session associated with the request.
7128 *
7129 * @return \Illuminate\Session\Store|null
7130 * @static
7131 */
7132 public static function getSession()
7133 {
7134 return \Illuminate\Http\Request::getSession();
7135 }
7136
7137 /**
7138 * Set the session instance on the request.
7139 *
7140 * @param \Illuminate\Contracts\Session\Session $session
7141 * @return void
7142 * @static
7143 */
7144 public static function setLaravelSession($session)
7145 {
7146 \Illuminate\Http\Request::setLaravelSession($session);
7147 }
7148
7149 /**
7150 * Get the user making the request.
7151 *
7152 * @param string|null $guard
7153 * @return mixed
7154 * @static
7155 */
7156 public static function user($guard = null)
7157 {
7158 return \Illuminate\Http\Request::user($guard);
7159 }
7160
7161 /**
7162 * Get the route handling the request.
7163 *
7164 * @param string|null $param
7165 * @return \Illuminate\Routing\Route|object|string
7166 * @static
7167 */
7168 public static function route($param = null)
7169 {
7170 return \Illuminate\Http\Request::route($param);
7171 }
7172
7173 /**
7174 * Get a unique fingerprint for the request / route / IP address.
7175 *
7176 * @return string
7177 * @throws \RuntimeException
7178 * @static
7179 */
7180 public static function fingerprint()
7181 {
7182 return \Illuminate\Http\Request::fingerprint();
7183 }
7184
7185 /**
7186 * Set the JSON payload for the request.
7187 *
7188 * @param \Symfony\Component\HttpFoundation\ParameterBag $json
7189 * @return $this
7190 * @static
7191 */
7192 public static function setJson($json)
7193 {
7194 return \Illuminate\Http\Request::setJson($json);
7195 }
7196
7197 /**
7198 * Get the user resolver callback.
7199 *
7200 * @return \Closure
7201 * @static
7202 */
7203 public static function getUserResolver()
7204 {
7205 return \Illuminate\Http\Request::getUserResolver();
7206 }
7207
7208 /**
7209 * Set the user resolver callback.
7210 *
7211 * @param \Closure $callback
7212 * @return $this
7213 * @static
7214 */
7215 public static function setUserResolver($callback)
7216 {
7217 return \Illuminate\Http\Request::setUserResolver($callback);
7218 }
7219
7220 /**
7221 * Get the route resolver callback.
7222 *
7223 * @return \Closure
7224 * @static
7225 */
7226 public static function getRouteResolver()
7227 {
7228 return \Illuminate\Http\Request::getRouteResolver();
7229 }
7230
7231 /**
7232 * Set the route resolver callback.
7233 *
7234 * @param \Closure $callback
7235 * @return $this
7236 * @static
7237 */
7238 public static function setRouteResolver($callback)
7239 {
7240 return \Illuminate\Http\Request::setRouteResolver($callback);
7241 }
7242
7243 /**
7244 * Get all of the input and files for the request.
7245 *
7246 * @return array
7247 * @static
7248 */
7249 public static function toArray()
7250 {
7251 return \Illuminate\Http\Request::toArray();
7252 }
7253
7254 /**
7255 * Determine if the given offset exists.
7256 *
7257 * @param string $offset
7258 * @return bool
7259 * @static
7260 */
7261 public static function offsetExists($offset)
7262 {
7263 return \Illuminate\Http\Request::offsetExists($offset);
7264 }
7265
7266 /**
7267 * Get the value at the given offset.
7268 *
7269 * @param string $offset
7270 * @return mixed
7271 * @static
7272 */
7273 public static function offsetGet($offset)
7274 {
7275 return \Illuminate\Http\Request::offsetGet($offset);
7276 }
7277
7278 /**
7279 * Set the value at the given offset.
7280 *
7281 * @param string $offset
7282 * @param mixed $value
7283 * @return void
7284 * @static
7285 */
7286 public static function offsetSet($offset, $value)
7287 {
7288 \Illuminate\Http\Request::offsetSet($offset, $value);
7289 }
7290
7291 /**
7292 * Remove the value at the given offset.
7293 *
7294 * @param string $offset
7295 * @return void
7296 * @static
7297 */
7298 public static function offsetUnset($offset)
7299 {
7300 \Illuminate\Http\Request::offsetUnset($offset);
7301 }
7302
7303 /**
7304 * Sets the parameters for this request.
7305 *
7306 * This method also re-initializes all properties.
7307 *
7308 * @param array $query The GET parameters
7309 * @param array $request The POST parameters
7310 * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
7311 * @param array $cookies The COOKIE parameters
7312 * @param array $files The FILES parameters
7313 * @param array $server The SERVER parameters
7314 * @param string|resource|null $content The raw body data
7315 * @static
7316 */
7317 public static function initialize($query = array(), $request = array(), $attributes = array(), $cookies = array(), $files = array(), $server = array(), $content = null)
7318 {
7319 //Method inherited from \Symfony\Component\HttpFoundation\Request
7320 return \Illuminate\Http\Request::initialize($query, $request, $attributes, $cookies, $files, $server, $content);
7321 }
7322
7323 /**
7324 * Creates a new request with values from PHP's super globals.
7325 *
7326 * @return static
7327 * @static
7328 */
7329 public static function createFromGlobals()
7330 {
7331 //Method inherited from \Symfony\Component\HttpFoundation\Request
7332 return \Illuminate\Http\Request::createFromGlobals();
7333 }
7334
7335 /**
7336 * Creates a Request based on a given URI and configuration.
7337 *
7338 * The information contained in the URI always take precedence
7339 * over the other information (server and parameters).
7340 *
7341 * @param string $uri The URI
7342 * @param string $method The HTTP method
7343 * @param array $parameters The query (GET) or request (POST) parameters
7344 * @param array $cookies The request cookies ($_COOKIE)
7345 * @param array $files The request files ($_FILES)
7346 * @param array $server The server parameters ($_SERVER)
7347 * @param string|resource|null $content The raw body data
7348 * @return static
7349 * @static
7350 */
7351 public static function create($uri, $method = 'GET', $parameters = array(), $cookies = array(), $files = array(), $server = array(), $content = null)
7352 {
7353 //Method inherited from \Symfony\Component\HttpFoundation\Request
7354 return \Illuminate\Http\Request::create($uri, $method, $parameters, $cookies, $files, $server, $content);
7355 }
7356
7357 /**
7358 * Sets a callable able to create a Request instance.
7359 *
7360 * This is mainly useful when you need to override the Request class
7361 * to keep BC with an existing system. It should not be used for any
7362 * other purpose.
7363 *
7364 * @param callable|null $callable A PHP callable
7365 * @static
7366 */
7367 public static function setFactory($callable)
7368 {
7369 //Method inherited from \Symfony\Component\HttpFoundation\Request
7370 return \Illuminate\Http\Request::setFactory($callable);
7371 }
7372
7373 /**
7374 * Overrides the PHP global variables according to this request instance.
7375 *
7376 * It overrides $_GET, $_POST, $_REQUEST, $_SERVER, $_COOKIE.
7377 * $_FILES is never overridden, see rfc1867
7378 *
7379 * @static
7380 */
7381 public static function overrideGlobals()
7382 {
7383 //Method inherited from \Symfony\Component\HttpFoundation\Request
7384 return \Illuminate\Http\Request::overrideGlobals();
7385 }
7386
7387 /**
7388 * Sets a list of trusted proxies.
7389 *
7390 * You should only list the reverse proxies that you manage directly.
7391 *
7392 * @param array $proxies A list of trusted proxies
7393 * @param int $trustedHeaderSet A bit field of Request::HEADER_*, to set which headers to trust from your proxies
7394 * @throws \InvalidArgumentException When $trustedHeaderSet is invalid
7395 * @static
7396 */
7397 public static function setTrustedProxies($proxies, $trustedHeaderSet)
7398 {
7399 //Method inherited from \Symfony\Component\HttpFoundation\Request
7400 return \Illuminate\Http\Request::setTrustedProxies($proxies, $trustedHeaderSet);
7401 }
7402
7403 /**
7404 * Gets the list of trusted proxies.
7405 *
7406 * @return array An array of trusted proxies
7407 * @static
7408 */
7409 public static function getTrustedProxies()
7410 {
7411 //Method inherited from \Symfony\Component\HttpFoundation\Request
7412 return \Illuminate\Http\Request::getTrustedProxies();
7413 }
7414
7415 /**
7416 * Gets the set of trusted headers from trusted proxies.
7417 *
7418 * @return int A bit field of Request::HEADER_* that defines which headers are trusted from your proxies
7419 * @static
7420 */
7421 public static function getTrustedHeaderSet()
7422 {
7423 //Method inherited from \Symfony\Component\HttpFoundation\Request
7424 return \Illuminate\Http\Request::getTrustedHeaderSet();
7425 }
7426
7427 /**
7428 * Sets a list of trusted host patterns.
7429 *
7430 * You should only list the hosts you manage using regexs.
7431 *
7432 * @param array $hostPatterns A list of trusted host patterns
7433 * @static
7434 */
7435 public static function setTrustedHosts($hostPatterns)
7436 {
7437 //Method inherited from \Symfony\Component\HttpFoundation\Request
7438 return \Illuminate\Http\Request::setTrustedHosts($hostPatterns);
7439 }
7440
7441 /**
7442 * Gets the list of trusted host patterns.
7443 *
7444 * @return array An array of trusted host patterns
7445 * @static
7446 */
7447 public static function getTrustedHosts()
7448 {
7449 //Method inherited from \Symfony\Component\HttpFoundation\Request
7450 return \Illuminate\Http\Request::getTrustedHosts();
7451 }
7452
7453 /**
7454 * Normalizes a query string.
7455 *
7456 * It builds a normalized query string, where keys/value pairs are alphabetized,
7457 * have consistent escaping and unneeded delimiters are removed.
7458 *
7459 * @param string $qs Query string
7460 * @return string A normalized query string for the Request
7461 * @static
7462 */
7463 public static function normalizeQueryString($qs)
7464 {
7465 //Method inherited from \Symfony\Component\HttpFoundation\Request
7466 return \Illuminate\Http\Request::normalizeQueryString($qs);
7467 }
7468
7469 /**
7470 * Enables support for the _method request parameter to determine the intended HTTP method.
7471 *
7472 * Be warned that enabling this feature might lead to CSRF issues in your code.
7473 * Check that you are using CSRF tokens when required.
7474 * If the HTTP method parameter override is enabled, an html-form with method "POST" can be altered
7475 * and used to send a "PUT" or "DELETE" request via the _method request parameter.
7476 * If these methods are not protected against CSRF, this presents a possible vulnerability.
7477 *
7478 * The HTTP method can only be overridden when the real HTTP method is POST.
7479 *
7480 * @static
7481 */
7482 public static function enableHttpMethodParameterOverride()
7483 {
7484 //Method inherited from \Symfony\Component\HttpFoundation\Request
7485 return \Illuminate\Http\Request::enableHttpMethodParameterOverride();
7486 }
7487
7488 /**
7489 * Checks whether support for the _method request parameter is enabled.
7490 *
7491 * @return bool True when the _method request parameter is enabled, false otherwise
7492 * @static
7493 */
7494 public static function getHttpMethodParameterOverride()
7495 {
7496 //Method inherited from \Symfony\Component\HttpFoundation\Request
7497 return \Illuminate\Http\Request::getHttpMethodParameterOverride();
7498 }
7499
7500 /**
7501 * Gets a "parameter" value from any bag.
7502 *
7503 * This method is mainly useful for libraries that want to provide some flexibility. If you don't need the
7504 * flexibility in controllers, it is better to explicitly get request parameters from the appropriate
7505 * public property instead (attributes, query, request).
7506 *
7507 * Order of precedence: PATH (routing placeholders or custom attributes), GET, BODY
7508 *
7509 * @param string $key The key
7510 * @param mixed $default The default value if the parameter key does not exist
7511 * @return mixed
7512 * @static
7513 */
7514 public static function get($key, $default = null)
7515 {
7516 //Method inherited from \Symfony\Component\HttpFoundation\Request
7517 return \Illuminate\Http\Request::get($key, $default);
7518 }
7519
7520 /**
7521 * Whether the request contains a Session which was started in one of the
7522 * previous requests.
7523 *
7524 * @return bool
7525 * @static
7526 */
7527 public static function hasPreviousSession()
7528 {
7529 //Method inherited from \Symfony\Component\HttpFoundation\Request
7530 return \Illuminate\Http\Request::hasPreviousSession();
7531 }
7532
7533 /**
7534 * Whether the request contains a Session object.
7535 *
7536 * This method does not give any information about the state of the session object,
7537 * like whether the session is started or not. It is just a way to check if this Request
7538 * is associated with a Session instance.
7539 *
7540 * @return bool true when the Request contains a Session object, false otherwise
7541 * @static
7542 */
7543 public static function hasSession()
7544 {
7545 //Method inherited from \Symfony\Component\HttpFoundation\Request
7546 return \Illuminate\Http\Request::hasSession();
7547 }
7548
7549 /**
7550 * Sets the Session.
7551 *
7552 * @param \Symfony\Component\HttpFoundation\SessionInterface $session The Session
7553 * @static
7554 */
7555 public static function setSession($session)
7556 {
7557 //Method inherited from \Symfony\Component\HttpFoundation\Request
7558 return \Illuminate\Http\Request::setSession($session);
7559 }
7560
7561 /**
7562 * Returns the client IP addresses.
7563 *
7564 * In the returned array the most trusted IP address is first, and the
7565 * least trusted one last. The "real" client IP address is the last one,
7566 * but this is also the least trusted one. Trusted proxies are stripped.
7567 *
7568 * Use this method carefully; you should use getClientIp() instead.
7569 *
7570 * @return array The client IP addresses
7571 * @see getClientIp()
7572 * @static
7573 */
7574 public static function getClientIps()
7575 {
7576 //Method inherited from \Symfony\Component\HttpFoundation\Request
7577 return \Illuminate\Http\Request::getClientIps();
7578 }
7579
7580 /**
7581 * Returns the client IP address.
7582 *
7583 * This method can read the client IP address from the "X-Forwarded-For" header
7584 * when trusted proxies were set via "setTrustedProxies()". The "X-Forwarded-For"
7585 * header value is a comma+space separated list of IP addresses, the left-most
7586 * being the original client, and each successive proxy that passed the request
7587 * adding the IP address where it received the request from.
7588 *
7589 * @return string|null The client IP address
7590 * @see getClientIps()
7591 * @see http://en.wikipedia.org/wiki/X-Forwarded-For
7592 * @static
7593 */
7594 public static function getClientIp()
7595 {
7596 //Method inherited from \Symfony\Component\HttpFoundation\Request
7597 return \Illuminate\Http\Request::getClientIp();
7598 }
7599
7600 /**
7601 * Returns current script name.
7602 *
7603 * @return string
7604 * @static
7605 */
7606 public static function getScriptName()
7607 {
7608 //Method inherited from \Symfony\Component\HttpFoundation\Request
7609 return \Illuminate\Http\Request::getScriptName();
7610 }
7611
7612 /**
7613 * Returns the path being requested relative to the executed script.
7614 *
7615 * The path info always starts with a /.
7616 *
7617 * Suppose this request is instantiated from /mysite on localhost:
7618 *
7619 * * http://localhost/mysite returns an empty string
7620 * * http://localhost/mysite/about returns '/about'
7621 * * http://localhost/mysite/enco%20ded returns '/enco%20ded'
7622 * * http://localhost/mysite/about?var=1 returns '/about'
7623 *
7624 * @return string The raw path (i.e. not urldecoded)
7625 * @static
7626 */
7627 public static function getPathInfo()
7628 {
7629 //Method inherited from \Symfony\Component\HttpFoundation\Request
7630 return \Illuminate\Http\Request::getPathInfo();
7631 }
7632
7633 /**
7634 * Returns the root path from which this request is executed.
7635 *
7636 * Suppose that an index.php file instantiates this request object:
7637 *
7638 * * http://localhost/index.php returns an empty string
7639 * * http://localhost/index.php/page returns an empty string
7640 * * http://localhost/web/index.php returns '/web'
7641 * * http://localhost/we%20b/index.php returns '/we%20b'
7642 *
7643 * @return string The raw path (i.e. not urldecoded)
7644 * @static
7645 */
7646 public static function getBasePath()
7647 {
7648 //Method inherited from \Symfony\Component\HttpFoundation\Request
7649 return \Illuminate\Http\Request::getBasePath();
7650 }
7651
7652 /**
7653 * Returns the root URL from which this request is executed.
7654 *
7655 * The base URL never ends with a /.
7656 *
7657 * This is similar to getBasePath(), except that it also includes the
7658 * script filename (e.g. index.php) if one exists.
7659 *
7660 * @return string The raw URL (i.e. not urldecoded)
7661 * @static
7662 */
7663 public static function getBaseUrl()
7664 {
7665 //Method inherited from \Symfony\Component\HttpFoundation\Request
7666 return \Illuminate\Http\Request::getBaseUrl();
7667 }
7668
7669 /**
7670 * Gets the request's scheme.
7671 *
7672 * @return string
7673 * @static
7674 */
7675 public static function getScheme()
7676 {
7677 //Method inherited from \Symfony\Component\HttpFoundation\Request
7678 return \Illuminate\Http\Request::getScheme();
7679 }
7680
7681 /**
7682 * Returns the port on which the request is made.
7683 *
7684 * This method can read the client port from the "X-Forwarded-Port" header
7685 * when trusted proxies were set via "setTrustedProxies()".
7686 *
7687 * The "X-Forwarded-Port" header must contain the client port.
7688 *
7689 * @return int|string can be a string if fetched from the server bag
7690 * @static
7691 */
7692 public static function getPort()
7693 {
7694 //Method inherited from \Symfony\Component\HttpFoundation\Request
7695 return \Illuminate\Http\Request::getPort();
7696 }
7697
7698 /**
7699 * Returns the user.
7700 *
7701 * @return string|null
7702 * @static
7703 */
7704 public static function getUser()
7705 {
7706 //Method inherited from \Symfony\Component\HttpFoundation\Request
7707 return \Illuminate\Http\Request::getUser();
7708 }
7709
7710 /**
7711 * Returns the password.
7712 *
7713 * @return string|null
7714 * @static
7715 */
7716 public static function getPassword()
7717 {
7718 //Method inherited from \Symfony\Component\HttpFoundation\Request
7719 return \Illuminate\Http\Request::getPassword();
7720 }
7721
7722 /**
7723 * Gets the user info.
7724 *
7725 * @return string A user name and, optionally, scheme-specific information about how to gain authorization to access the server
7726 * @static
7727 */
7728 public static function getUserInfo()
7729 {
7730 //Method inherited from \Symfony\Component\HttpFoundation\Request
7731 return \Illuminate\Http\Request::getUserInfo();
7732 }
7733
7734 /**
7735 * Returns the HTTP host being requested.
7736 *
7737 * The port name will be appended to the host if it's non-standard.
7738 *
7739 * @return string
7740 * @static
7741 */
7742 public static function getHttpHost()
7743 {
7744 //Method inherited from \Symfony\Component\HttpFoundation\Request
7745 return \Illuminate\Http\Request::getHttpHost();
7746 }
7747
7748 /**
7749 * Returns the requested URI (path and query string).
7750 *
7751 * @return string The raw URI (i.e. not URI decoded)
7752 * @static
7753 */
7754 public static function getRequestUri()
7755 {
7756 //Method inherited from \Symfony\Component\HttpFoundation\Request
7757 return \Illuminate\Http\Request::getRequestUri();
7758 }
7759
7760 /**
7761 * Gets the scheme and HTTP host.
7762 *
7763 * If the URL was called with basic authentication, the user
7764 * and the password are not added to the generated string.
7765 *
7766 * @return string The scheme and HTTP host
7767 * @static
7768 */
7769 public static function getSchemeAndHttpHost()
7770 {
7771 //Method inherited from \Symfony\Component\HttpFoundation\Request
7772 return \Illuminate\Http\Request::getSchemeAndHttpHost();
7773 }
7774
7775 /**
7776 * Generates a normalized URI (URL) for the Request.
7777 *
7778 * @return string A normalized URI (URL) for the Request
7779 * @see getQueryString()
7780 * @static
7781 */
7782 public static function getUri()
7783 {
7784 //Method inherited from \Symfony\Component\HttpFoundation\Request
7785 return \Illuminate\Http\Request::getUri();
7786 }
7787
7788 /**
7789 * Generates a normalized URI for the given path.
7790 *
7791 * @param string $path A path to use instead of the current one
7792 * @return string The normalized URI for the path
7793 * @static
7794 */
7795 public static function getUriForPath($path)
7796 {
7797 //Method inherited from \Symfony\Component\HttpFoundation\Request
7798 return \Illuminate\Http\Request::getUriForPath($path);
7799 }
7800
7801 /**
7802 * Returns the path as relative reference from the current Request path.
7803 *
7804 * Only the URIs path component (no schema, host etc.) is relevant and must be given.
7805 * Both paths must be absolute and not contain relative parts.
7806 * Relative URLs from one resource to another are useful when generating self-contained downloadable document archives.
7807 * Furthermore, they can be used to reduce the link size in documents.
7808 *
7809 * Example target paths, given a base path of "/a/b/c/d":
7810 * - "/a/b/c/d" -> ""
7811 * - "/a/b/c/" -> "./"
7812 * - "/a/b/" -> "../"
7813 * - "/a/b/c/other" -> "other"
7814 * - "/a/x/y" -> "../../x/y"
7815 *
7816 * @param string $path The target path
7817 * @return string The relative target path
7818 * @static
7819 */
7820 public static function getRelativeUriForPath($path)
7821 {
7822 //Method inherited from \Symfony\Component\HttpFoundation\Request
7823 return \Illuminate\Http\Request::getRelativeUriForPath($path);
7824 }
7825
7826 /**
7827 * Generates the normalized query string for the Request.
7828 *
7829 * It builds a normalized query string, where keys/value pairs are alphabetized
7830 * and have consistent escaping.
7831 *
7832 * @return string|null A normalized query string for the Request
7833 * @static
7834 */
7835 public static function getQueryString()
7836 {
7837 //Method inherited from \Symfony\Component\HttpFoundation\Request
7838 return \Illuminate\Http\Request::getQueryString();
7839 }
7840
7841 /**
7842 * Checks whether the request is secure or not.
7843 *
7844 * This method can read the client protocol from the "X-Forwarded-Proto" header
7845 * when trusted proxies were set via "setTrustedProxies()".
7846 *
7847 * The "X-Forwarded-Proto" header must contain the protocol: "https" or "http".
7848 *
7849 * @return bool
7850 * @static
7851 */
7852 public static function isSecure()
7853 {
7854 //Method inherited from \Symfony\Component\HttpFoundation\Request
7855 return \Illuminate\Http\Request::isSecure();
7856 }
7857
7858 /**
7859 * Returns the host name.
7860 *
7861 * This method can read the client host name from the "X-Forwarded-Host" header
7862 * when trusted proxies were set via "setTrustedProxies()".
7863 *
7864 * The "X-Forwarded-Host" header must contain the client host name.
7865 *
7866 * @return string
7867 * @throws SuspiciousOperationException when the host name is invalid or not trusted
7868 * @static
7869 */
7870 public static function getHost()
7871 {
7872 //Method inherited from \Symfony\Component\HttpFoundation\Request
7873 return \Illuminate\Http\Request::getHost();
7874 }
7875
7876 /**
7877 * Sets the request method.
7878 *
7879 * @param string $method
7880 * @static
7881 */
7882 public static function setMethod($method)
7883 {
7884 //Method inherited from \Symfony\Component\HttpFoundation\Request
7885 return \Illuminate\Http\Request::setMethod($method);
7886 }
7887
7888 /**
7889 * Gets the request "intended" method.
7890 *
7891 * If the X-HTTP-Method-Override header is set, and if the method is a POST,
7892 * then it is used to determine the "real" intended HTTP method.
7893 *
7894 * The _method request parameter can also be used to determine the HTTP method,
7895 * but only if enableHttpMethodParameterOverride() has been called.
7896 *
7897 * The method is always an uppercased string.
7898 *
7899 * @return string The request method
7900 * @see getRealMethod()
7901 * @static
7902 */
7903 public static function getMethod()
7904 {
7905 //Method inherited from \Symfony\Component\HttpFoundation\Request
7906 return \Illuminate\Http\Request::getMethod();
7907 }
7908
7909 /**
7910 * Gets the "real" request method.
7911 *
7912 * @return string The request method
7913 * @see getMethod()
7914 * @static
7915 */
7916 public static function getRealMethod()
7917 {
7918 //Method inherited from \Symfony\Component\HttpFoundation\Request
7919 return \Illuminate\Http\Request::getRealMethod();
7920 }
7921
7922 /**
7923 * Gets the mime type associated with the format.
7924 *
7925 * @param string $format The format
7926 * @return string The associated mime type (null if not found)
7927 * @static
7928 */
7929 public static function getMimeType($format)
7930 {
7931 //Method inherited from \Symfony\Component\HttpFoundation\Request
7932 return \Illuminate\Http\Request::getMimeType($format);
7933 }
7934
7935 /**
7936 * Gets the mime types associated with the format.
7937 *
7938 * @param string $format The format
7939 * @return array The associated mime types
7940 * @static
7941 */
7942 public static function getMimeTypes($format)
7943 {
7944 //Method inherited from \Symfony\Component\HttpFoundation\Request
7945 return \Illuminate\Http\Request::getMimeTypes($format);
7946 }
7947
7948 /**
7949 * Gets the format associated with the mime type.
7950 *
7951 * @param string $mimeType The associated mime type
7952 * @return string|null The format (null if not found)
7953 * @static
7954 */
7955 public static function getFormat($mimeType)
7956 {
7957 //Method inherited from \Symfony\Component\HttpFoundation\Request
7958 return \Illuminate\Http\Request::getFormat($mimeType);
7959 }
7960
7961 /**
7962 * Associates a format with mime types.
7963 *
7964 * @param string $format The format
7965 * @param string|array $mimeTypes The associated mime types (the preferred one must be the first as it will be used as the content type)
7966 * @static
7967 */
7968 public static function setFormat($format, $mimeTypes)
7969 {
7970 //Method inherited from \Symfony\Component\HttpFoundation\Request
7971 return \Illuminate\Http\Request::setFormat($format, $mimeTypes);
7972 }
7973
7974 /**
7975 * Gets the request format.
7976 *
7977 * Here is the process to determine the format:
7978 *
7979 * * format defined by the user (with setRequestFormat())
7980 * * _format request attribute
7981 * * $default
7982 *
7983 * @param string $default The default format
7984 * @return string The request format
7985 * @static
7986 */
7987 public static function getRequestFormat($default = 'html')
7988 {
7989 //Method inherited from \Symfony\Component\HttpFoundation\Request
7990 return \Illuminate\Http\Request::getRequestFormat($default);
7991 }
7992
7993 /**
7994 * Sets the request format.
7995 *
7996 * @param string $format The request format
7997 * @static
7998 */
7999 public static function setRequestFormat($format)
8000 {
8001 //Method inherited from \Symfony\Component\HttpFoundation\Request
8002 return \Illuminate\Http\Request::setRequestFormat($format);
8003 }
8004
8005 /**
8006 * Gets the format associated with the request.
8007 *
8008 * @return string|null The format (null if no content type is present)
8009 * @static
8010 */
8011 public static function getContentType()
8012 {
8013 //Method inherited from \Symfony\Component\HttpFoundation\Request
8014 return \Illuminate\Http\Request::getContentType();
8015 }
8016
8017 /**
8018 * Sets the default locale.
8019 *
8020 * @param string $locale
8021 * @static
8022 */
8023 public static function setDefaultLocale($locale)
8024 {
8025 //Method inherited from \Symfony\Component\HttpFoundation\Request
8026 return \Illuminate\Http\Request::setDefaultLocale($locale);
8027 }
8028
8029 /**
8030 * Get the default locale.
8031 *
8032 * @return string
8033 * @static
8034 */
8035 public static function getDefaultLocale()
8036 {
8037 //Method inherited from \Symfony\Component\HttpFoundation\Request
8038 return \Illuminate\Http\Request::getDefaultLocale();
8039 }
8040
8041 /**
8042 * Sets the locale.
8043 *
8044 * @param string $locale
8045 * @static
8046 */
8047 public static function setLocale($locale)
8048 {
8049 //Method inherited from \Symfony\Component\HttpFoundation\Request
8050 return \Illuminate\Http\Request::setLocale($locale);
8051 }
8052
8053 /**
8054 * Get the locale.
8055 *
8056 * @return string
8057 * @static
8058 */
8059 public static function getLocale()
8060 {
8061 //Method inherited from \Symfony\Component\HttpFoundation\Request
8062 return \Illuminate\Http\Request::getLocale();
8063 }
8064
8065 /**
8066 * Checks if the request method is of specified type.
8067 *
8068 * @param string $method Uppercase request method (GET, POST etc)
8069 * @return bool
8070 * @static
8071 */
8072 public static function isMethod($method)
8073 {
8074 //Method inherited from \Symfony\Component\HttpFoundation\Request
8075 return \Illuminate\Http\Request::isMethod($method);
8076 }
8077
8078 /**
8079 * Checks whether or not the method is safe.
8080 *
8081 * @see https://tools.ietf.org/html/rfc7231#section-4.2.1
8082 * @param bool $andCacheable Adds the additional condition that the method should be cacheable. True by default.
8083 * @return bool
8084 * @static
8085 */
8086 public static function isMethodSafe()
8087 {
8088 //Method inherited from \Symfony\Component\HttpFoundation\Request
8089 return \Illuminate\Http\Request::isMethodSafe();
8090 }
8091
8092 /**
8093 * Checks whether or not the method is idempotent.
8094 *
8095 * @return bool
8096 * @static
8097 */
8098 public static function isMethodIdempotent()
8099 {
8100 //Method inherited from \Symfony\Component\HttpFoundation\Request
8101 return \Illuminate\Http\Request::isMethodIdempotent();
8102 }
8103
8104 /**
8105 * Checks whether the method is cacheable or not.
8106 *
8107 * @see https://tools.ietf.org/html/rfc7231#section-4.2.3
8108 * @return bool
8109 * @static
8110 */
8111 public static function isMethodCacheable()
8112 {
8113 //Method inherited from \Symfony\Component\HttpFoundation\Request
8114 return \Illuminate\Http\Request::isMethodCacheable();
8115 }
8116
8117 /**
8118 * Returns the protocol version.
8119 *
8120 * If the application is behind a proxy, the protocol version used in the
8121 * requests between the client and the proxy and between the proxy and the
8122 * server might be different. This returns the former (from the "Via" header)
8123 * if the proxy is trusted (see "setTrustedProxies()"), otherwise it returns
8124 * the latter (from the "SERVER_PROTOCOL" server parameter).
8125 *
8126 * @return string
8127 * @static
8128 */
8129 public static function getProtocolVersion()
8130 {
8131 //Method inherited from \Symfony\Component\HttpFoundation\Request
8132 return \Illuminate\Http\Request::getProtocolVersion();
8133 }
8134
8135 /**
8136 * Returns the request body content.
8137 *
8138 * @param bool $asResource If true, a resource will be returned
8139 * @return string|resource The request body content or a resource to read the body stream
8140 * @throws \LogicException
8141 * @static
8142 */
8143 public static function getContent($asResource = false)
8144 {
8145 //Method inherited from \Symfony\Component\HttpFoundation\Request
8146 return \Illuminate\Http\Request::getContent($asResource);
8147 }
8148
8149 /**
8150 * Gets the Etags.
8151 *
8152 * @return array The entity tags
8153 * @static
8154 */
8155 public static function getETags()
8156 {
8157 //Method inherited from \Symfony\Component\HttpFoundation\Request
8158 return \Illuminate\Http\Request::getETags();
8159 }
8160
8161 /**
8162 *
8163 *
8164 * @return bool
8165 * @static
8166 */
8167 public static function isNoCache()
8168 {
8169 //Method inherited from \Symfony\Component\HttpFoundation\Request
8170 return \Illuminate\Http\Request::isNoCache();
8171 }
8172
8173 /**
8174 * Returns the preferred language.
8175 *
8176 * @param array $locales An array of ordered available locales
8177 * @return string|null The preferred locale
8178 * @static
8179 */
8180 public static function getPreferredLanguage($locales = null)
8181 {
8182 //Method inherited from \Symfony\Component\HttpFoundation\Request
8183 return \Illuminate\Http\Request::getPreferredLanguage($locales);
8184 }
8185
8186 /**
8187 * Gets a list of languages acceptable by the client browser.
8188 *
8189 * @return array Languages ordered in the user browser preferences
8190 * @static
8191 */
8192 public static function getLanguages()
8193 {
8194 //Method inherited from \Symfony\Component\HttpFoundation\Request
8195 return \Illuminate\Http\Request::getLanguages();
8196 }
8197
8198 /**
8199 * Gets a list of charsets acceptable by the client browser.
8200 *
8201 * @return array List of charsets in preferable order
8202 * @static
8203 */
8204 public static function getCharsets()
8205 {
8206 //Method inherited from \Symfony\Component\HttpFoundation\Request
8207 return \Illuminate\Http\Request::getCharsets();
8208 }
8209
8210 /**
8211 * Gets a list of encodings acceptable by the client browser.
8212 *
8213 * @return array List of encodings in preferable order
8214 * @static
8215 */
8216 public static function getEncodings()
8217 {
8218 //Method inherited from \Symfony\Component\HttpFoundation\Request
8219 return \Illuminate\Http\Request::getEncodings();
8220 }
8221
8222 /**
8223 * Gets a list of content types acceptable by the client browser.
8224 *
8225 * @return array List of content types in preferable order
8226 * @static
8227 */
8228 public static function getAcceptableContentTypes()
8229 {
8230 //Method inherited from \Symfony\Component\HttpFoundation\Request
8231 return \Illuminate\Http\Request::getAcceptableContentTypes();
8232 }
8233
8234 /**
8235 * Returns true if the request is a XMLHttpRequest.
8236 *
8237 * It works if your JavaScript library sets an X-Requested-With HTTP header.
8238 * It is known to work with common JavaScript frameworks:
8239 *
8240 * @see http://en.wikipedia.org/wiki/List_of_Ajax_frameworks#JavaScript
8241 * @return bool true if the request is an XMLHttpRequest, false otherwise
8242 * @static
8243 */
8244 public static function isXmlHttpRequest()
8245 {
8246 //Method inherited from \Symfony\Component\HttpFoundation\Request
8247 return \Illuminate\Http\Request::isXmlHttpRequest();
8248 }
8249
8250 /**
8251 * Indicates whether this request originated from a trusted proxy.
8252 *
8253 * This can be useful to determine whether or not to trust the
8254 * contents of a proxy-specific header.
8255 *
8256 * @return bool true if the request came from a trusted proxy, false otherwise
8257 * @static
8258 */
8259 public static function isFromTrustedProxy()
8260 {
8261 //Method inherited from \Symfony\Component\HttpFoundation\Request
8262 return \Illuminate\Http\Request::isFromTrustedProxy();
8263 }
8264
8265 /**
8266 * Determine if the given content types match.
8267 *
8268 * @param string $actual
8269 * @param string $type
8270 * @return bool
8271 * @static
8272 */
8273 public static function matchesType($actual, $type)
8274 {
8275 return \Illuminate\Http\Request::matchesType($actual, $type);
8276 }
8277
8278 /**
8279 * Determine if the request is sending JSON.
8280 *
8281 * @return bool
8282 * @static
8283 */
8284 public static function isJson()
8285 {
8286 return \Illuminate\Http\Request::isJson();
8287 }
8288
8289 /**
8290 * Determine if the current request probably expects a JSON response.
8291 *
8292 * @return bool
8293 * @static
8294 */
8295 public static function expectsJson()
8296 {
8297 return \Illuminate\Http\Request::expectsJson();
8298 }
8299
8300 /**
8301 * Determine if the current request is asking for JSON.
8302 *
8303 * @return bool
8304 * @static
8305 */
8306 public static function wantsJson()
8307 {
8308 return \Illuminate\Http\Request::wantsJson();
8309 }
8310
8311 /**
8312 * Determines whether the current requests accepts a given content type.
8313 *
8314 * @param string|array $contentTypes
8315 * @return bool
8316 * @static
8317 */
8318 public static function accepts($contentTypes)
8319 {
8320 return \Illuminate\Http\Request::accepts($contentTypes);
8321 }
8322
8323 /**
8324 * Return the most suitable content type from the given array based on content negotiation.
8325 *
8326 * @param string|array $contentTypes
8327 * @return string|null
8328 * @static
8329 */
8330 public static function prefers($contentTypes)
8331 {
8332 return \Illuminate\Http\Request::prefers($contentTypes);
8333 }
8334
8335 /**
8336 * Determine if the current request accepts any content type.
8337 *
8338 * @return bool
8339 * @static
8340 */
8341 public static function acceptsAnyContentType()
8342 {
8343 return \Illuminate\Http\Request::acceptsAnyContentType();
8344 }
8345
8346 /**
8347 * Determines whether a request accepts JSON.
8348 *
8349 * @return bool
8350 * @static
8351 */
8352 public static function acceptsJson()
8353 {
8354 return \Illuminate\Http\Request::acceptsJson();
8355 }
8356
8357 /**
8358 * Determines whether a request accepts HTML.
8359 *
8360 * @return bool
8361 * @static
8362 */
8363 public static function acceptsHtml()
8364 {
8365 return \Illuminate\Http\Request::acceptsHtml();
8366 }
8367
8368 /**
8369 * Get the data format expected in the response.
8370 *
8371 * @param string $default
8372 * @return string
8373 * @static
8374 */
8375 public static function format($default = 'html')
8376 {
8377 return \Illuminate\Http\Request::format($default);
8378 }
8379
8380 /**
8381 * Retrieve an old input item.
8382 *
8383 * @param string $key
8384 * @param string|array|null $default
8385 * @return string|array
8386 * @static
8387 */
8388 public static function old($key = null, $default = null)
8389 {
8390 return \Illuminate\Http\Request::old($key, $default);
8391 }
8392
8393 /**
8394 * Flash the input for the current request to the session.
8395 *
8396 * @return void
8397 * @static
8398 */
8399 public static function flash()
8400 {
8401 \Illuminate\Http\Request::flash();
8402 }
8403
8404 /**
8405 * Flash only some of the input to the session.
8406 *
8407 * @param array|mixed $keys
8408 * @return void
8409 * @static
8410 */
8411 public static function flashOnly($keys)
8412 {
8413 \Illuminate\Http\Request::flashOnly($keys);
8414 }
8415
8416 /**
8417 * Flash only some of the input to the session.
8418 *
8419 * @param array|mixed $keys
8420 * @return void
8421 * @static
8422 */
8423 public static function flashExcept($keys)
8424 {
8425 \Illuminate\Http\Request::flashExcept($keys);
8426 }
8427
8428 /**
8429 * Flush all of the old input from the session.
8430 *
8431 * @return void
8432 * @static
8433 */
8434 public static function flush()
8435 {
8436 \Illuminate\Http\Request::flush();
8437 }
8438
8439 /**
8440 * Retrieve a server variable from the request.
8441 *
8442 * @param string $key
8443 * @param string|array|null $default
8444 * @return string|array
8445 * @static
8446 */
8447 public static function server($key = null, $default = null)
8448 {
8449 return \Illuminate\Http\Request::server($key, $default);
8450 }
8451
8452 /**
8453 * Determine if a header is set on the request.
8454 *
8455 * @param string $key
8456 * @return bool
8457 * @static
8458 */
8459 public static function hasHeader($key)
8460 {
8461 return \Illuminate\Http\Request::hasHeader($key);
8462 }
8463
8464 /**
8465 * Retrieve a header from the request.
8466 *
8467 * @param string $key
8468 * @param string|array|null $default
8469 * @return string|array
8470 * @static
8471 */
8472 public static function header($key = null, $default = null)
8473 {
8474 return \Illuminate\Http\Request::header($key, $default);
8475 }
8476
8477 /**
8478 * Get the bearer token from the request headers.
8479 *
8480 * @return string|null
8481 * @static
8482 */
8483 public static function bearerToken()
8484 {
8485 return \Illuminate\Http\Request::bearerToken();
8486 }
8487
8488 /**
8489 * Determine if the request contains a given input item key.
8490 *
8491 * @param string|array $key
8492 * @return bool
8493 * @static
8494 */
8495 public static function exists($key)
8496 {
8497 return \Illuminate\Http\Request::exists($key);
8498 }
8499
8500 /**
8501 * Determine if the request contains a given input item key.
8502 *
8503 * @param string|array $key
8504 * @return bool
8505 * @static
8506 */
8507 public static function has($key)
8508 {
8509 return \Illuminate\Http\Request::has($key);
8510 }
8511
8512 /**
8513 * Determine if the request contains any of the given inputs.
8514 *
8515 * @param string|array $key
8516 * @return bool
8517 * @static
8518 */
8519 public static function hasAny($keys)
8520 {
8521 return \Illuminate\Http\Request::hasAny($keys);
8522 }
8523
8524 /**
8525 * Determine if the request contains a non-empty value for an input item.
8526 *
8527 * @param string|array $key
8528 * @return bool
8529 * @static
8530 */
8531 public static function filled($key)
8532 {
8533 return \Illuminate\Http\Request::filled($key);
8534 }
8535
8536 /**
8537 * Determine if the request contains a non-empty value for any of the given inputs.
8538 *
8539 * @param string|array $keys
8540 * @return bool
8541 * @static
8542 */
8543 public static function anyFilled($keys)
8544 {
8545 return \Illuminate\Http\Request::anyFilled($keys);
8546 }
8547
8548 /**
8549 * Get the keys for all of the input and files.
8550 *
8551 * @return array
8552 * @static
8553 */
8554 public static function keys()
8555 {
8556 return \Illuminate\Http\Request::keys();
8557 }
8558
8559 /**
8560 * Get all of the input and files for the request.
8561 *
8562 * @param array|mixed $keys
8563 * @return array
8564 * @static
8565 */
8566 public static function all($keys = null)
8567 {
8568 return \Illuminate\Http\Request::all($keys);
8569 }
8570
8571 /**
8572 * Retrieve an input item from the request.
8573 *
8574 * @param string|null $key
8575 * @param string|array|null $default
8576 * @return string|array|null
8577 * @static
8578 */
8579 public static function input($key = null, $default = null)
8580 {
8581 return \Illuminate\Http\Request::input($key, $default);
8582 }
8583
8584 /**
8585 * Get a subset containing the provided keys with values from the input data.
8586 *
8587 * @param array|mixed $keys
8588 * @return array
8589 * @static
8590 */
8591 public static function only($keys)
8592 {
8593 return \Illuminate\Http\Request::only($keys);
8594 }
8595
8596 /**
8597 * Get all of the input except for a specified array of items.
8598 *
8599 * @param array|mixed $keys
8600 * @return array
8601 * @static
8602 */
8603 public static function except($keys)
8604 {
8605 return \Illuminate\Http\Request::except($keys);
8606 }
8607
8608 /**
8609 * Retrieve a query string item from the request.
8610 *
8611 * @param string $key
8612 * @param string|array|null $default
8613 * @return string|array
8614 * @static
8615 */
8616 public static function query($key = null, $default = null)
8617 {
8618 return \Illuminate\Http\Request::query($key, $default);
8619 }
8620
8621 /**
8622 * Retrieve a request payload item from the request.
8623 *
8624 * @param string $key
8625 * @param string|array|null $default
8626 * @return string|array
8627 * @static
8628 */
8629 public static function post($key = null, $default = null)
8630 {
8631 return \Illuminate\Http\Request::post($key, $default);
8632 }
8633
8634 /**
8635 * Determine if a cookie is set on the request.
8636 *
8637 * @param string $key
8638 * @return bool
8639 * @static
8640 */
8641 public static function hasCookie($key)
8642 {
8643 return \Illuminate\Http\Request::hasCookie($key);
8644 }
8645
8646 /**
8647 * Retrieve a cookie from the request.
8648 *
8649 * @param string $key
8650 * @param string|array|null $default
8651 * @return string|array
8652 * @static
8653 */
8654 public static function cookie($key = null, $default = null)
8655 {
8656 return \Illuminate\Http\Request::cookie($key, $default);
8657 }
8658
8659 /**
8660 * Get an array of all of the files on the request.
8661 *
8662 * @return array
8663 * @static
8664 */
8665 public static function allFiles()
8666 {
8667 return \Illuminate\Http\Request::allFiles();
8668 }
8669
8670 /**
8671 * Determine if the uploaded data contains a file.
8672 *
8673 * @param string $key
8674 * @return bool
8675 * @static
8676 */
8677 public static function hasFile($key)
8678 {
8679 return \Illuminate\Http\Request::hasFile($key);
8680 }
8681
8682 /**
8683 * Retrieve a file from the request.
8684 *
8685 * @param string $key
8686 * @param mixed $default
8687 * @return \Illuminate\Http\UploadedFile|array|null
8688 * @static
8689 */
8690 public static function file($key = null, $default = null)
8691 {
8692 return \Illuminate\Http\Request::file($key, $default);
8693 }
8694
8695 /**
8696 * Register a custom macro.
8697 *
8698 * @param string $name
8699 * @param object|callable $macro
8700 * @return void
8701 * @static
8702 */
8703 public static function macro($name, $macro)
8704 {
8705 \Illuminate\Http\Request::macro($name, $macro);
8706 }
8707
8708 /**
8709 * Mix another object into the class.
8710 *
8711 * @param object $mixin
8712 * @return void
8713 * @throws \ReflectionException
8714 * @static
8715 */
8716 public static function mixin($mixin)
8717 {
8718 \Illuminate\Http\Request::mixin($mixin);
8719 }
8720
8721 /**
8722 * Checks if macro is registered.
8723 *
8724 * @param string $name
8725 * @return bool
8726 * @static
8727 */
8728 public static function hasMacro($name)
8729 {
8730 return \Illuminate\Http\Request::hasMacro($name);
8731 }
8732
8733 /**
8734 *
8735 *
8736 * @static
8737 */
8738 public static function validate($rules, $params = null)
8739 {
8740 return \Illuminate\Http\Request::validate($rules, $params);
8741 }
8742
8743 /**
8744 *
8745 *
8746 * @static
8747 */
8748 public static function hasValidSignature()
8749 {
8750 return \Illuminate\Http\Request::hasValidSignature();
8751 }
8752
8753 }
8754
8755 class Response {
8756
8757 /**
8758 * Return a new response from the application.
8759 *
8760 * @param string $content
8761 * @param int $status
8762 * @param array $headers
8763 * @return \Illuminate\Http\Response
8764 * @static
8765 */
8766 public static function make($content = '', $status = 200, $headers = array())
8767 {
8768 return \Illuminate\Routing\ResponseFactory::make($content, $status, $headers);
8769 }
8770
8771 /**
8772 * Return a new view response from the application.
8773 *
8774 * @param string $view
8775 * @param array $data
8776 * @param int $status
8777 * @param array $headers
8778 * @return \Illuminate\Http\Response
8779 * @static
8780 */
8781 public static function view($view, $data = array(), $status = 200, $headers = array())
8782 {
8783 return \Illuminate\Routing\ResponseFactory::view($view, $data, $status, $headers);
8784 }
8785
8786 /**
8787 * Return a new JSON response from the application.
8788 *
8789 * @param mixed $data
8790 * @param int $status
8791 * @param array $headers
8792 * @param int $options
8793 * @return \Illuminate\Http\JsonResponse
8794 * @static
8795 */
8796 public static function json($data = array(), $status = 200, $headers = array(), $options = 0)
8797 {
8798 return \Illuminate\Routing\ResponseFactory::json($data, $status, $headers, $options);
8799 }
8800
8801 /**
8802 * Return a new JSONP response from the application.
8803 *
8804 * @param string $callback
8805 * @param mixed $data
8806 * @param int $status
8807 * @param array $headers
8808 * @param int $options
8809 * @return \Illuminate\Http\JsonResponse
8810 * @static
8811 */
8812 public static function jsonp($callback, $data = array(), $status = 200, $headers = array(), $options = 0)
8813 {
8814 return \Illuminate\Routing\ResponseFactory::jsonp($callback, $data, $status, $headers, $options);
8815 }
8816
8817 /**
8818 * Return a new streamed response from the application.
8819 *
8820 * @param \Closure $callback
8821 * @param int $status
8822 * @param array $headers
8823 * @return \Symfony\Component\HttpFoundation\StreamedResponse
8824 * @static
8825 */
8826 public static function stream($callback, $status = 200, $headers = array())
8827 {
8828 return \Illuminate\Routing\ResponseFactory::stream($callback, $status, $headers);
8829 }
8830
8831 /**
8832 * Return a new streamed response as a file download from the application.
8833 *
8834 * @param \Closure $callback
8835 * @param string|null $name
8836 * @param array $headers
8837 * @param string|null $disposition
8838 * @return \Symfony\Component\HttpFoundation\StreamedResponse
8839 * @static
8840 */
8841 public static function streamDownload($callback, $name = null, $headers = array(), $disposition = 'attachment')
8842 {
8843 return \Illuminate\Routing\ResponseFactory::streamDownload($callback, $name, $headers, $disposition);
8844 }
8845
8846 /**
8847 * Create a new file download response.
8848 *
8849 * @param \SplFileInfo|string $file
8850 * @param string|null $name
8851 * @param array $headers
8852 * @param string|null $disposition
8853 * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
8854 * @static
8855 */
8856 public static function download($file, $name = null, $headers = array(), $disposition = 'attachment')
8857 {
8858 return \Illuminate\Routing\ResponseFactory::download($file, $name, $headers, $disposition);
8859 }
8860
8861 /**
8862 * Return the raw contents of a binary file.
8863 *
8864 * @param \SplFileInfo|string $file
8865 * @param array $headers
8866 * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
8867 * @static
8868 */
8869 public static function file($file, $headers = array())
8870 {
8871 return \Illuminate\Routing\ResponseFactory::file($file, $headers);
8872 }
8873
8874 /**
8875 * Create a new redirect response to the given path.
8876 *
8877 * @param string $path
8878 * @param int $status
8879 * @param array $headers
8880 * @param bool|null $secure
8881 * @return \Illuminate\Http\RedirectResponse
8882 * @static
8883 */
8884 public static function redirectTo($path, $status = 302, $headers = array(), $secure = null)
8885 {
8886 return \Illuminate\Routing\ResponseFactory::redirectTo($path, $status, $headers, $secure);
8887 }
8888
8889 /**
8890 * Create a new redirect response to a named route.
8891 *
8892 * @param string $route
8893 * @param array $parameters
8894 * @param int $status
8895 * @param array $headers
8896 * @return \Illuminate\Http\RedirectResponse
8897 * @static
8898 */
8899 public static function redirectToRoute($route, $parameters = array(), $status = 302, $headers = array())
8900 {
8901 return \Illuminate\Routing\ResponseFactory::redirectToRoute($route, $parameters, $status, $headers);
8902 }
8903
8904 /**
8905 * Create a new redirect response to a controller action.
8906 *
8907 * @param string $action
8908 * @param array $parameters
8909 * @param int $status
8910 * @param array $headers
8911 * @return \Illuminate\Http\RedirectResponse
8912 * @static
8913 */
8914 public static function redirectToAction($action, $parameters = array(), $status = 302, $headers = array())
8915 {
8916 return \Illuminate\Routing\ResponseFactory::redirectToAction($action, $parameters, $status, $headers);
8917 }
8918
8919 /**
8920 * Create a new redirect response, while putting the current URL in the session.
8921 *
8922 * @param string $path
8923 * @param int $status
8924 * @param array $headers
8925 * @param bool|null $secure
8926 * @return \Illuminate\Http\RedirectResponse
8927 * @static
8928 */
8929 public static function redirectGuest($path, $status = 302, $headers = array(), $secure = null)
8930 {
8931 return \Illuminate\Routing\ResponseFactory::redirectGuest($path, $status, $headers, $secure);
8932 }
8933
8934 /**
8935 * Create a new redirect response to the previously intended location.
8936 *
8937 * @param string $default
8938 * @param int $status
8939 * @param array $headers
8940 * @param bool|null $secure
8941 * @return \Illuminate\Http\RedirectResponse
8942 * @static
8943 */
8944 public static function redirectToIntended($default = '/', $status = 302, $headers = array(), $secure = null)
8945 {
8946 return \Illuminate\Routing\ResponseFactory::redirectToIntended($default, $status, $headers, $secure);
8947 }
8948
8949 /**
8950 * Register a custom macro.
8951 *
8952 * @param string $name
8953 * @param object|callable $macro
8954 * @return void
8955 * @static
8956 */
8957 public static function macro($name, $macro)
8958 {
8959 \Illuminate\Routing\ResponseFactory::macro($name, $macro);
8960 }
8961
8962 /**
8963 * Mix another object into the class.
8964 *
8965 * @param object $mixin
8966 * @return void
8967 * @throws \ReflectionException
8968 * @static
8969 */
8970 public static function mixin($mixin)
8971 {
8972 \Illuminate\Routing\ResponseFactory::mixin($mixin);
8973 }
8974
8975 /**
8976 * Checks if macro is registered.
8977 *
8978 * @param string $name
8979 * @return bool
8980 * @static
8981 */
8982 public static function hasMacro($name)
8983 {
8984 return \Illuminate\Routing\ResponseFactory::hasMacro($name);
8985 }
8986
8987 }
8988
8989 class Route {
8990
8991 /**
8992 * Register a new GET route with the router.
8993 *
8994 * @param string $uri
8995 * @param \Closure|array|string|null $action
8996 * @return \Illuminate\Routing\Route
8997 * @static
8998 */
8999 public static function get($uri, $action = null)
9000 {
9001 return \Illuminate\Routing\Router::get($uri, $action);
9002 }
9003
9004 /**
9005 * Register a new POST route with the router.
9006 *
9007 * @param string $uri
9008 * @param \Closure|array|string|null $action
9009 * @return \Illuminate\Routing\Route
9010 * @static
9011 */
9012 public static function post($uri, $action = null)
9013 {
9014 return \Illuminate\Routing\Router::post($uri, $action);
9015 }
9016
9017 /**
9018 * Register a new PUT route with the router.
9019 *
9020 * @param string $uri
9021 * @param \Closure|array|string|null $action
9022 * @return \Illuminate\Routing\Route
9023 * @static
9024 */
9025 public static function put($uri, $action = null)
9026 {
9027 return \Illuminate\Routing\Router::put($uri, $action);
9028 }
9029
9030 /**
9031 * Register a new PATCH route with the router.
9032 *
9033 * @param string $uri
9034 * @param \Closure|array|string|null $action
9035 * @return \Illuminate\Routing\Route
9036 * @static
9037 */
9038 public static function patch($uri, $action = null)
9039 {
9040 return \Illuminate\Routing\Router::patch($uri, $action);
9041 }
9042
9043 /**
9044 * Register a new DELETE route with the router.
9045 *
9046 * @param string $uri
9047 * @param \Closure|array|string|null $action
9048 * @return \Illuminate\Routing\Route
9049 * @static
9050 */
9051 public static function delete($uri, $action = null)
9052 {
9053 return \Illuminate\Routing\Router::delete($uri, $action);
9054 }
9055
9056 /**
9057 * Register a new OPTIONS route with the router.
9058 *
9059 * @param string $uri
9060 * @param \Closure|array|string|null $action
9061 * @return \Illuminate\Routing\Route
9062 * @static
9063 */
9064 public static function options($uri, $action = null)
9065 {
9066 return \Illuminate\Routing\Router::options($uri, $action);
9067 }
9068
9069 /**
9070 * Register a new route responding to all verbs.
9071 *
9072 * @param string $uri
9073 * @param \Closure|array|string|null $action
9074 * @return \Illuminate\Routing\Route
9075 * @static
9076 */
9077 public static function any($uri, $action = null)
9078 {
9079 return \Illuminate\Routing\Router::any($uri, $action);
9080 }
9081
9082 /**
9083 * Register a new Fallback route with the router.
9084 *
9085 * @param \Closure|array|string|null $action
9086 * @return \Illuminate\Routing\Route
9087 * @static
9088 */
9089 public static function fallback($action)
9090 {
9091 return \Illuminate\Routing\Router::fallback($action);
9092 }
9093
9094 /**
9095 * Create a redirect from one URI to another.
9096 *
9097 * @param string $uri
9098 * @param string $destination
9099 * @param int $status
9100 * @return \Illuminate\Routing\Route
9101 * @static
9102 */
9103 public static function redirect($uri, $destination, $status = 301)
9104 {
9105 return \Illuminate\Routing\Router::redirect($uri, $destination, $status);
9106 }
9107
9108 /**
9109 * Register a new route that returns a view.
9110 *
9111 * @param string $uri
9112 * @param string $view
9113 * @param array $data
9114 * @return \Illuminate\Routing\Route
9115 * @static
9116 */
9117 public static function view($uri, $view, $data = array())
9118 {
9119 return \Illuminate\Routing\Router::view($uri, $view, $data);
9120 }
9121
9122 /**
9123 * Register a new route with the given verbs.
9124 *
9125 * @param array|string $methods
9126 * @param string $uri
9127 * @param \Closure|array|string|null $action
9128 * @return \Illuminate\Routing\Route
9129 * @static
9130 */
9131 public static function match($methods, $uri, $action = null)
9132 {
9133 return \Illuminate\Routing\Router::match($methods, $uri, $action);
9134 }
9135
9136 /**
9137 * Register an array of resource controllers.
9138 *
9139 * @param array $resources
9140 * @return void
9141 * @static
9142 */
9143 public static function resources($resources)
9144 {
9145 \Illuminate\Routing\Router::resources($resources);
9146 }
9147
9148 /**
9149 * Route a resource to a controller.
9150 *
9151 * @param string $name
9152 * @param string $controller
9153 * @param array $options
9154 * @return \Illuminate\Routing\PendingResourceRegistration
9155 * @static
9156 */
9157 public static function resource($name, $controller, $options = array())
9158 {
9159 return \Illuminate\Routing\Router::resource($name, $controller, $options);
9160 }
9161
9162 /**
9163 * Register an array of API resource controllers.
9164 *
9165 * @param array $resources
9166 * @return void
9167 * @static
9168 */
9169 public static function apiResources($resources)
9170 {
9171 \Illuminate\Routing\Router::apiResources($resources);
9172 }
9173
9174 /**
9175 * Route an API resource to a controller.
9176 *
9177 * @param string $name
9178 * @param string $controller
9179 * @param array $options
9180 * @return \Illuminate\Routing\PendingResourceRegistration
9181 * @static
9182 */
9183 public static function apiResource($name, $controller, $options = array())
9184 {
9185 return \Illuminate\Routing\Router::apiResource($name, $controller, $options);
9186 }
9187
9188 /**
9189 * Create a route group with shared attributes.
9190 *
9191 * @param array $attributes
9192 * @param \Closure|string $routes
9193 * @return void
9194 * @static
9195 */
9196 public static function group($attributes, $routes)
9197 {
9198 \Illuminate\Routing\Router::group($attributes, $routes);
9199 }
9200
9201 /**
9202 * Merge the given array with the last group stack.
9203 *
9204 * @param array $new
9205 * @return array
9206 * @static
9207 */
9208 public static function mergeWithLastGroup($new)
9209 {
9210 return \Illuminate\Routing\Router::mergeWithLastGroup($new);
9211 }
9212
9213 /**
9214 * Get the prefix from the last group on the stack.
9215 *
9216 * @return string
9217 * @static
9218 */
9219 public static function getLastGroupPrefix()
9220 {
9221 return \Illuminate\Routing\Router::getLastGroupPrefix();
9222 }
9223
9224 /**
9225 * Return the response returned by the given route.
9226 *
9227 * @param string $name
9228 * @return mixed
9229 * @static
9230 */
9231 public static function respondWithRoute($name)
9232 {
9233 return \Illuminate\Routing\Router::respondWithRoute($name);
9234 }
9235
9236 /**
9237 * Dispatch the request to the application.
9238 *
9239 * @param \Illuminate\Http\Request $request
9240 * @return \Illuminate\Http\Response|\Illuminate\Http\JsonResponse
9241 * @static
9242 */
9243 public static function dispatch($request)
9244 {
9245 return \Illuminate\Routing\Router::dispatch($request);
9246 }
9247
9248 /**
9249 * Dispatch the request to a route and return the response.
9250 *
9251 * @param \Illuminate\Http\Request $request
9252 * @return mixed
9253 * @static
9254 */
9255 public static function dispatchToRoute($request)
9256 {
9257 return \Illuminate\Routing\Router::dispatchToRoute($request);
9258 }
9259
9260 /**
9261 * Gather the middleware for the given route with resolved class names.
9262 *
9263 * @param \Illuminate\Routing\Route $route
9264 * @return array
9265 * @static
9266 */
9267 public static function gatherRouteMiddleware($route)
9268 {
9269 return \Illuminate\Routing\Router::gatherRouteMiddleware($route);
9270 }
9271
9272 /**
9273 * Create a response instance from the given value.
9274 *
9275 * @param \Symfony\Component\HttpFoundation\Request $request
9276 * @param mixed $response
9277 * @return \Illuminate\Http\Response|\Illuminate\Http\JsonResponse
9278 * @static
9279 */
9280 public static function prepareResponse($request, $response)
9281 {
9282 return \Illuminate\Routing\Router::prepareResponse($request, $response);
9283 }
9284
9285 /**
9286 * Static version of prepareResponse.
9287 *
9288 * @param \Symfony\Component\HttpFoundation\Request $request
9289 * @param mixed $response
9290 * @return \Illuminate\Http\Response|\Illuminate\Http\JsonResponse
9291 * @static
9292 */
9293 public static function toResponse($request, $response)
9294 {
9295 return \Illuminate\Routing\Router::toResponse($request, $response);
9296 }
9297
9298 /**
9299 * Substitute the route bindings onto the route.
9300 *
9301 * @param \Illuminate\Routing\Route $route
9302 * @return \Illuminate\Routing\Route
9303 * @static
9304 */
9305 public static function substituteBindings($route)
9306 {
9307 return \Illuminate\Routing\Router::substituteBindings($route);
9308 }
9309
9310 /**
9311 * Substitute the implicit Eloquent model bindings for the route.
9312 *
9313 * @param \Illuminate\Routing\Route $route
9314 * @return void
9315 * @static
9316 */
9317 public static function substituteImplicitBindings($route)
9318 {
9319 \Illuminate\Routing\Router::substituteImplicitBindings($route);
9320 }
9321
9322 /**
9323 * Register a route matched event listener.
9324 *
9325 * @param string|callable $callback
9326 * @return void
9327 * @static
9328 */
9329 public static function matched($callback)
9330 {
9331 \Illuminate\Routing\Router::matched($callback);
9332 }
9333
9334 /**
9335 * Get all of the defined middleware short-hand names.
9336 *
9337 * @return array
9338 * @static
9339 */
9340 public static function getMiddleware()
9341 {
9342 return \Illuminate\Routing\Router::getMiddleware();
9343 }
9344
9345 /**
9346 * Register a short-hand name for a middleware.
9347 *
9348 * @param string $name
9349 * @param string $class
9350 * @return $this
9351 * @static
9352 */
9353 public static function aliasMiddleware($name, $class)
9354 {
9355 return \Illuminate\Routing\Router::aliasMiddleware($name, $class);
9356 }
9357
9358 /**
9359 * Check if a middlewareGroup with the given name exists.
9360 *
9361 * @param string $name
9362 * @return bool
9363 * @static
9364 */
9365 public static function hasMiddlewareGroup($name)
9366 {
9367 return \Illuminate\Routing\Router::hasMiddlewareGroup($name);
9368 }
9369
9370 /**
9371 * Get all of the defined middleware groups.
9372 *
9373 * @return array
9374 * @static
9375 */
9376 public static function getMiddlewareGroups()
9377 {
9378 return \Illuminate\Routing\Router::getMiddlewareGroups();
9379 }
9380
9381 /**
9382 * Register a group of middleware.
9383 *
9384 * @param string $name
9385 * @param array $middleware
9386 * @return $this
9387 * @static
9388 */
9389 public static function middlewareGroup($name, $middleware)
9390 {
9391 return \Illuminate\Routing\Router::middlewareGroup($name, $middleware);
9392 }
9393
9394 /**
9395 * Add a middleware to the beginning of a middleware group.
9396 *
9397 * If the middleware is already in the group, it will not be added again.
9398 *
9399 * @param string $group
9400 * @param string $middleware
9401 * @return $this
9402 * @static
9403 */
9404 public static function prependMiddlewareToGroup($group, $middleware)
9405 {
9406 return \Illuminate\Routing\Router::prependMiddlewareToGroup($group, $middleware);
9407 }
9408
9409 /**
9410 * Add a middleware to the end of a middleware group.
9411 *
9412 * If the middleware is already in the group, it will not be added again.
9413 *
9414 * @param string $group
9415 * @param string $middleware
9416 * @return $this
9417 * @static
9418 */
9419 public static function pushMiddlewareToGroup($group, $middleware)
9420 {
9421 return \Illuminate\Routing\Router::pushMiddlewareToGroup($group, $middleware);
9422 }
9423
9424 /**
9425 * Add a new route parameter binder.
9426 *
9427 * @param string $key
9428 * @param string|callable $binder
9429 * @return void
9430 * @static
9431 */
9432 public static function bind($key, $binder)
9433 {
9434 \Illuminate\Routing\Router::bind($key, $binder);
9435 }
9436
9437 /**
9438 * Register a model binder for a wildcard.
9439 *
9440 * @param string $key
9441 * @param string $class
9442 * @param \Closure|null $callback
9443 * @return void
9444 * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
9445 * @static
9446 */
9447 public static function model($key, $class, $callback = null)
9448 {
9449 \Illuminate\Routing\Router::model($key, $class, $callback);
9450 }
9451
9452 /**
9453 * Get the binding callback for a given binding.
9454 *
9455 * @param string $key
9456 * @return \Closure|null
9457 * @static
9458 */
9459 public static function getBindingCallback($key)
9460 {
9461 return \Illuminate\Routing\Router::getBindingCallback($key);
9462 }
9463
9464 /**
9465 * Get the global "where" patterns.
9466 *
9467 * @return array
9468 * @static
9469 */
9470 public static function getPatterns()
9471 {
9472 return \Illuminate\Routing\Router::getPatterns();
9473 }
9474
9475 /**
9476 * Set a global where pattern on all routes.
9477 *
9478 * @param string $key
9479 * @param string $pattern
9480 * @return void
9481 * @static
9482 */
9483 public static function pattern($key, $pattern)
9484 {
9485 \Illuminate\Routing\Router::pattern($key, $pattern);
9486 }
9487
9488 /**
9489 * Set a group of global where patterns on all routes.
9490 *
9491 * @param array $patterns
9492 * @return void
9493 * @static
9494 */
9495 public static function patterns($patterns)
9496 {
9497 \Illuminate\Routing\Router::patterns($patterns);
9498 }
9499
9500 /**
9501 * Determine if the router currently has a group stack.
9502 *
9503 * @return bool
9504 * @static
9505 */
9506 public static function hasGroupStack()
9507 {
9508 return \Illuminate\Routing\Router::hasGroupStack();
9509 }
9510
9511 /**
9512 * Get the current group stack for the router.
9513 *
9514 * @return array
9515 * @static
9516 */
9517 public static function getGroupStack()
9518 {
9519 return \Illuminate\Routing\Router::getGroupStack();
9520 }
9521
9522 /**
9523 * Get a route parameter for the current route.
9524 *
9525 * @param string $key
9526 * @param string $default
9527 * @return mixed
9528 * @static
9529 */
9530 public static function input($key, $default = null)
9531 {
9532 return \Illuminate\Routing\Router::input($key, $default);
9533 }
9534
9535 /**
9536 * Get the request currently being dispatched.
9537 *
9538 * @return \Illuminate\Http\Request
9539 * @static
9540 */
9541 public static function getCurrentRequest()
9542 {
9543 return \Illuminate\Routing\Router::getCurrentRequest();
9544 }
9545
9546 /**
9547 * Get the currently dispatched route instance.
9548 *
9549 * @return \Illuminate\Routing\Route
9550 * @static
9551 */
9552 public static function getCurrentRoute()
9553 {
9554 return \Illuminate\Routing\Router::getCurrentRoute();
9555 }
9556
9557 /**
9558 * Get the currently dispatched route instance.
9559 *
9560 * @return \Illuminate\Routing\Route
9561 * @static
9562 */
9563 public static function current()
9564 {
9565 return \Illuminate\Routing\Router::current();
9566 }
9567
9568 /**
9569 * Check if a route with the given name exists.
9570 *
9571 * @param string $name
9572 * @return bool
9573 * @static
9574 */
9575 public static function has($name)
9576 {
9577 return \Illuminate\Routing\Router::has($name);
9578 }
9579
9580 /**
9581 * Get the current route name.
9582 *
9583 * @return string|null
9584 * @static
9585 */
9586 public static function currentRouteName()
9587 {
9588 return \Illuminate\Routing\Router::currentRouteName();
9589 }
9590
9591 /**
9592 * Alias for the "currentRouteNamed" method.
9593 *
9594 * @param mixed $patterns
9595 * @return bool
9596 * @static
9597 */
9598 public static function is($patterns = null)
9599 {
9600 return \Illuminate\Routing\Router::is($patterns);
9601 }
9602
9603 /**
9604 * Determine if the current route matches a pattern.
9605 *
9606 * @param mixed $patterns
9607 * @return bool
9608 * @static
9609 */
9610 public static function currentRouteNamed($patterns = null)
9611 {
9612 return \Illuminate\Routing\Router::currentRouteNamed($patterns);
9613 }
9614
9615 /**
9616 * Get the current route action.
9617 *
9618 * @return string|null
9619 * @static
9620 */
9621 public static function currentRouteAction()
9622 {
9623 return \Illuminate\Routing\Router::currentRouteAction();
9624 }
9625
9626 /**
9627 * Alias for the "currentRouteUses" method.
9628 *
9629 * @param array $patterns
9630 * @return bool
9631 * @static
9632 */
9633 public static function uses($patterns = null)
9634 {
9635 return \Illuminate\Routing\Router::uses($patterns);
9636 }
9637
9638 /**
9639 * Determine if the current route action matches a given action.
9640 *
9641 * @param string $action
9642 * @return bool
9643 * @static
9644 */
9645 public static function currentRouteUses($action)
9646 {
9647 return \Illuminate\Routing\Router::currentRouteUses($action);
9648 }
9649
9650 /**
9651 * Register the typical authentication routes for an application.
9652 *
9653 * @return void
9654 * @static
9655 */
9656 public static function auth()
9657 {
9658 \Illuminate\Routing\Router::auth();
9659 }
9660
9661 /**
9662 * Set the unmapped global resource parameters to singular.
9663 *
9664 * @param bool $singular
9665 * @return void
9666 * @static
9667 */
9668 public static function singularResourceParameters($singular = true)
9669 {
9670 \Illuminate\Routing\Router::singularResourceParameters($singular);
9671 }
9672
9673 /**
9674 * Set the global resource parameter mapping.
9675 *
9676 * @param array $parameters
9677 * @return void
9678 * @static
9679 */
9680 public static function resourceParameters($parameters = array())
9681 {
9682 \Illuminate\Routing\Router::resourceParameters($parameters);
9683 }
9684
9685 /**
9686 * Get or set the verbs used in the resource URIs.
9687 *
9688 * @param array $verbs
9689 * @return array|null
9690 * @static
9691 */
9692 public static function resourceVerbs($verbs = array())
9693 {
9694 return \Illuminate\Routing\Router::resourceVerbs($verbs);
9695 }
9696
9697 /**
9698 * Get the underlying route collection.
9699 *
9700 * @return \Illuminate\Routing\RouteCollection
9701 * @static
9702 */
9703 public static function getRoutes()
9704 {
9705 return \Illuminate\Routing\Router::getRoutes();
9706 }
9707
9708 /**
9709 * Set the route collection instance.
9710 *
9711 * @param \Illuminate\Routing\RouteCollection $routes
9712 * @return void
9713 * @static
9714 */
9715 public static function setRoutes($routes)
9716 {
9717 \Illuminate\Routing\Router::setRoutes($routes);
9718 }
9719
9720 /**
9721 * Register a custom macro.
9722 *
9723 * @param string $name
9724 * @param object|callable $macro
9725 * @return void
9726 * @static
9727 */
9728 public static function macro($name, $macro)
9729 {
9730 \Illuminate\Routing\Router::macro($name, $macro);
9731 }
9732
9733 /**
9734 * Mix another object into the class.
9735 *
9736 * @param object $mixin
9737 * @return void
9738 * @throws \ReflectionException
9739 * @static
9740 */
9741 public static function mixin($mixin)
9742 {
9743 \Illuminate\Routing\Router::mixin($mixin);
9744 }
9745
9746 /**
9747 * Checks if macro is registered.
9748 *
9749 * @param string $name
9750 * @return bool
9751 * @static
9752 */
9753 public static function hasMacro($name)
9754 {
9755 return \Illuminate\Routing\Router::hasMacro($name);
9756 }
9757
9758 /**
9759 * Dynamically handle calls to the class.
9760 *
9761 * @param string $method
9762 * @param array $parameters
9763 * @return mixed
9764 * @throws \BadMethodCallException
9765 * @static
9766 */
9767 public static function macroCall($method, $parameters)
9768 {
9769 return \Illuminate\Routing\Router::macroCall($method, $parameters);
9770 }
9771
9772 }
9773
9774 class Schema {
9775
9776 /**
9777 * Determine if the given table exists.
9778 *
9779 * @param string $table
9780 * @return bool
9781 * @static
9782 */
9783 public static function hasTable($table)
9784 {
9785 return \Illuminate\Database\Schema\MySqlBuilder::hasTable($table);
9786 }
9787
9788 /**
9789 * Get the column listing for a given table.
9790 *
9791 * @param string $table
9792 * @return array
9793 * @static
9794 */
9795 public static function getColumnListing($table)
9796 {
9797 return \Illuminate\Database\Schema\MySqlBuilder::getColumnListing($table);
9798 }
9799
9800 /**
9801 * Drop all tables from the database.
9802 *
9803 * @return void
9804 * @static
9805 */
9806 public static function dropAllTables()
9807 {
9808 \Illuminate\Database\Schema\MySqlBuilder::dropAllTables();
9809 }
9810
9811 /**
9812 * Set the default string length for migrations.
9813 *
9814 * @param int $length
9815 * @return void
9816 * @static
9817 */
9818 public static function defaultStringLength($length)
9819 {
9820 //Method inherited from \Illuminate\Database\Schema\Builder
9821 \Illuminate\Database\Schema\MySqlBuilder::defaultStringLength($length);
9822 }
9823
9824 /**
9825 * Determine if the given table has a given column.
9826 *
9827 * @param string $table
9828 * @param string $column
9829 * @return bool
9830 * @static
9831 */
9832 public static function hasColumn($table, $column)
9833 {
9834 //Method inherited from \Illuminate\Database\Schema\Builder
9835 return \Illuminate\Database\Schema\MySqlBuilder::hasColumn($table, $column);
9836 }
9837
9838 /**
9839 * Determine if the given table has given columns.
9840 *
9841 * @param string $table
9842 * @param array $columns
9843 * @return bool
9844 * @static
9845 */
9846 public static function hasColumns($table, $columns)
9847 {
9848 //Method inherited from \Illuminate\Database\Schema\Builder
9849 return \Illuminate\Database\Schema\MySqlBuilder::hasColumns($table, $columns);
9850 }
9851
9852 /**
9853 * Get the data type for the given column name.
9854 *
9855 * @param string $table
9856 * @param string $column
9857 * @return string
9858 * @static
9859 */
9860 public static function getColumnType($table, $column)
9861 {
9862 //Method inherited from \Illuminate\Database\Schema\Builder
9863 return \Illuminate\Database\Schema\MySqlBuilder::getColumnType($table, $column);
9864 }
9865
9866 /**
9867 * Modify a table on the schema.
9868 *
9869 * @param string $table
9870 * @param \Closure $callback
9871 * @return void
9872 * @static
9873 */
9874 public static function table($table, $callback)
9875 {
9876 //Method inherited from \Illuminate\Database\Schema\Builder
9877 \Illuminate\Database\Schema\MySqlBuilder::table($table, $callback);
9878 }
9879
9880 /**
9881 * Create a new table on the schema.
9882 *
9883 * @param string $table
9884 * @param \Closure $callback
9885 * @return void
9886 * @static
9887 */
9888 public static function create($table, $callback)
9889 {
9890 //Method inherited from \Illuminate\Database\Schema\Builder
9891 \Illuminate\Database\Schema\MySqlBuilder::create($table, $callback);
9892 }
9893
9894 /**
9895 * Drop a table from the schema.
9896 *
9897 * @param string $table
9898 * @return void
9899 * @static
9900 */
9901 public static function drop($table)
9902 {
9903 //Method inherited from \Illuminate\Database\Schema\Builder
9904 \Illuminate\Database\Schema\MySqlBuilder::drop($table);
9905 }
9906
9907 /**
9908 * Drop a table from the schema if it exists.
9909 *
9910 * @param string $table
9911 * @return void
9912 * @static
9913 */
9914 public static function dropIfExists($table)
9915 {
9916 //Method inherited from \Illuminate\Database\Schema\Builder
9917 \Illuminate\Database\Schema\MySqlBuilder::dropIfExists($table);
9918 }
9919
9920 /**
9921 * Rename a table on the schema.
9922 *
9923 * @param string $from
9924 * @param string $to
9925 * @return void
9926 * @static
9927 */
9928 public static function rename($from, $to)
9929 {
9930 //Method inherited from \Illuminate\Database\Schema\Builder
9931 \Illuminate\Database\Schema\MySqlBuilder::rename($from, $to);
9932 }
9933
9934 /**
9935 * Enable foreign key constraints.
9936 *
9937 * @return bool
9938 * @static
9939 */
9940 public static function enableForeignKeyConstraints()
9941 {
9942 //Method inherited from \Illuminate\Database\Schema\Builder
9943 return \Illuminate\Database\Schema\MySqlBuilder::enableForeignKeyConstraints();
9944 }
9945
9946 /**
9947 * Disable foreign key constraints.
9948 *
9949 * @return bool
9950 * @static
9951 */
9952 public static function disableForeignKeyConstraints()
9953 {
9954 //Method inherited from \Illuminate\Database\Schema\Builder
9955 return \Illuminate\Database\Schema\MySqlBuilder::disableForeignKeyConstraints();
9956 }
9957
9958 /**
9959 * Get the database connection instance.
9960 *
9961 * @return \Illuminate\Database\Connection
9962 * @static
9963 */
9964 public static function getConnection()
9965 {
9966 //Method inherited from \Illuminate\Database\Schema\Builder
9967 return \Illuminate\Database\Schema\MySqlBuilder::getConnection();
9968 }
9969
9970 /**
9971 * Set the database connection instance.
9972 *
9973 * @param \Illuminate\Database\Connection $connection
9974 * @return $this
9975 * @static
9976 */
9977 public static function setConnection($connection)
9978 {
9979 //Method inherited from \Illuminate\Database\Schema\Builder
9980 return \Illuminate\Database\Schema\MySqlBuilder::setConnection($connection);
9981 }
9982
9983 /**
9984 * Set the Schema Blueprint resolver callback.
9985 *
9986 * @param \Closure $resolver
9987 * @return void
9988 * @static
9989 */
9990 public static function blueprintResolver($resolver)
9991 {
9992 //Method inherited from \Illuminate\Database\Schema\Builder
9993 \Illuminate\Database\Schema\MySqlBuilder::blueprintResolver($resolver);
9994 }
9995
9996 }
9997
9998 class Session {
9999
10000 /**
10001 * Get the session configuration.
10002 *
10003 * @return array
10004 * @static
10005 */
10006 public static function getSessionConfig()
10007 {
10008 return \Illuminate\Session\SessionManager::getSessionConfig();
10009 }
10010
10011 /**
10012 * Get the default session driver name.
10013 *
10014 * @return string
10015 * @static
10016 */
10017 public static function getDefaultDriver()
10018 {
10019 return \Illuminate\Session\SessionManager::getDefaultDriver();
10020 }
10021
10022 /**
10023 * Set the default session driver name.
10024 *
10025 * @param string $name
10026 * @return void
10027 * @static
10028 */
10029 public static function setDefaultDriver($name)
10030 {
10031 \Illuminate\Session\SessionManager::setDefaultDriver($name);
10032 }
10033
10034 /**
10035 * Get a driver instance.
10036 *
10037 * @param string $driver
10038 * @return mixed
10039 * @static
10040 */
10041 public static function driver($driver = null)
10042 {
10043 //Method inherited from \Illuminate\Support\Manager
10044 return \Illuminate\Session\SessionManager::driver($driver);
10045 }
10046
10047 /**
10048 * Register a custom driver creator Closure.
10049 *
10050 * @param string $driver
10051 * @param \Closure $callback
10052 * @return $this
10053 * @static
10054 */
10055 public static function extend($driver, $callback)
10056 {
10057 //Method inherited from \Illuminate\Support\Manager
10058 return \Illuminate\Session\SessionManager::extend($driver, $callback);
10059 }
10060
10061 /**
10062 * Get all of the created "drivers".
10063 *
10064 * @return array
10065 * @static
10066 */
10067 public static function getDrivers()
10068 {
10069 //Method inherited from \Illuminate\Support\Manager
10070 return \Illuminate\Session\SessionManager::getDrivers();
10071 }
10072
10073 /**
10074 * Start the session, reading the data from a handler.
10075 *
10076 * @return bool
10077 * @static
10078 */
10079 public static function start()
10080 {
10081 return \Illuminate\Session\Store::start();
10082 }
10083
10084 /**
10085 * Save the session data to storage.
10086 *
10087 * @return bool
10088 * @static
10089 */
10090 public static function save()
10091 {
10092 return \Illuminate\Session\Store::save();
10093 }
10094
10095 /**
10096 * Age the flash data for the session.
10097 *
10098 * @return void
10099 * @static
10100 */
10101 public static function ageFlashData()
10102 {
10103 \Illuminate\Session\Store::ageFlashData();
10104 }
10105
10106 /**
10107 * Get all of the session data.
10108 *
10109 * @return array
10110 * @static
10111 */
10112 public static function all()
10113 {
10114 return \Illuminate\Session\Store::all();
10115 }
10116
10117 /**
10118 * Checks if a key exists.
10119 *
10120 * @param string|array $key
10121 * @return bool
10122 * @static
10123 */
10124 public static function exists($key)
10125 {
10126 return \Illuminate\Session\Store::exists($key);
10127 }
10128
10129 /**
10130 * Checks if a key is present and not null.
10131 *
10132 * @param string|array $key
10133 * @return bool
10134 * @static
10135 */
10136 public static function has($key)
10137 {
10138 return \Illuminate\Session\Store::has($key);
10139 }
10140
10141 /**
10142 * Get an item from the session.
10143 *
10144 * @param string $key
10145 * @param mixed $default
10146 * @return mixed
10147 * @static
10148 */
10149 public static function get($key, $default = null)
10150 {
10151 return \Illuminate\Session\Store::get($key, $default);
10152 }
10153
10154 /**
10155 * Get the value of a given key and then forget it.
10156 *
10157 * @param string $key
10158 * @param string $default
10159 * @return mixed
10160 * @static
10161 */
10162 public static function pull($key, $default = null)
10163 {
10164 return \Illuminate\Session\Store::pull($key, $default);
10165 }
10166
10167 /**
10168 * Determine if the session contains old input.
10169 *
10170 * @param string $key
10171 * @return bool
10172 * @static
10173 */
10174 public static function hasOldInput($key = null)
10175 {
10176 return \Illuminate\Session\Store::hasOldInput($key);
10177 }
10178
10179 /**
10180 * Get the requested item from the flashed input array.
10181 *
10182 * @param string $key
10183 * @param mixed $default
10184 * @return mixed
10185 * @static
10186 */
10187 public static function getOldInput($key = null, $default = null)
10188 {
10189 return \Illuminate\Session\Store::getOldInput($key, $default);
10190 }
10191
10192 /**
10193 * Replace the given session attributes entirely.
10194 *
10195 * @param array $attributes
10196 * @return void
10197 * @static
10198 */
10199 public static function replace($attributes)
10200 {
10201 \Illuminate\Session\Store::replace($attributes);
10202 }
10203
10204 /**
10205 * Put a key / value pair or array of key / value pairs in the session.
10206 *
10207 * @param string|array $key
10208 * @param mixed $value
10209 * @return void
10210 * @static
10211 */
10212 public static function put($key, $value = null)
10213 {
10214 \Illuminate\Session\Store::put($key, $value);
10215 }
10216
10217 /**
10218 * Get an item from the session, or store the default value.
10219 *
10220 * @param string $key
10221 * @param \Closure $callback
10222 * @return mixed
10223 * @static
10224 */
10225 public static function remember($key, $callback)
10226 {
10227 return \Illuminate\Session\Store::remember($key, $callback);
10228 }
10229
10230 /**
10231 * Push a value onto a session array.
10232 *
10233 * @param string $key
10234 * @param mixed $value
10235 * @return void
10236 * @static
10237 */
10238 public static function push($key, $value)
10239 {
10240 \Illuminate\Session\Store::push($key, $value);
10241 }
10242
10243 /**
10244 * Increment the value of an item in the session.
10245 *
10246 * @param string $key
10247 * @param int $amount
10248 * @return mixed
10249 * @static
10250 */
10251 public static function increment($key, $amount = 1)
10252 {
10253 return \Illuminate\Session\Store::increment($key, $amount);
10254 }
10255
10256 /**
10257 * Decrement the value of an item in the session.
10258 *
10259 * @param string $key
10260 * @param int $amount
10261 * @return int
10262 * @static
10263 */
10264 public static function decrement($key, $amount = 1)
10265 {
10266 return \Illuminate\Session\Store::decrement($key, $amount);
10267 }
10268
10269 /**
10270 * Flash a key / value pair to the session.
10271 *
10272 * @param string $key
10273 * @param mixed $value
10274 * @return void
10275 * @static
10276 */
10277 public static function flash($key, $value = true)
10278 {
10279 \Illuminate\Session\Store::flash($key, $value);
10280 }
10281
10282 /**
10283 * Flash a key / value pair to the session for immediate use.
10284 *
10285 * @param string $key
10286 * @param mixed $value
10287 * @return void
10288 * @static
10289 */
10290 public static function now($key, $value)
10291 {
10292 \Illuminate\Session\Store::now($key, $value);
10293 }
10294
10295 /**
10296 * Reflash all of the session flash data.
10297 *
10298 * @return void
10299 * @static
10300 */
10301 public static function reflash()
10302 {
10303 \Illuminate\Session\Store::reflash();
10304 }
10305
10306 /**
10307 * Reflash a subset of the current flash data.
10308 *
10309 * @param array|mixed $keys
10310 * @return void
10311 * @static
10312 */
10313 public static function keep($keys = null)
10314 {
10315 \Illuminate\Session\Store::keep($keys);
10316 }
10317
10318 /**
10319 * Flash an input array to the session.
10320 *
10321 * @param array $value
10322 * @return void
10323 * @static
10324 */
10325 public static function flashInput($value)
10326 {
10327 \Illuminate\Session\Store::flashInput($value);
10328 }
10329
10330 /**
10331 * Remove an item from the session, returning its value.
10332 *
10333 * @param string $key
10334 * @return mixed
10335 * @static
10336 */
10337 public static function remove($key)
10338 {
10339 return \Illuminate\Session\Store::remove($key);
10340 }
10341
10342 /**
10343 * Remove one or many items from the session.
10344 *
10345 * @param string|array $keys
10346 * @return void
10347 * @static
10348 */
10349 public static function forget($keys)
10350 {
10351 \Illuminate\Session\Store::forget($keys);
10352 }
10353
10354 /**
10355 * Remove all of the items from the session.
10356 *
10357 * @return void
10358 * @static
10359 */
10360 public static function flush()
10361 {
10362 \Illuminate\Session\Store::flush();
10363 }
10364
10365 /**
10366 * Flush the session data and regenerate the ID.
10367 *
10368 * @return bool
10369 * @static
10370 */
10371 public static function invalidate()
10372 {
10373 return \Illuminate\Session\Store::invalidate();
10374 }
10375
10376 /**
10377 * Generate a new session identifier.
10378 *
10379 * @param bool $destroy
10380 * @return bool
10381 * @static
10382 */
10383 public static function regenerate($destroy = false)
10384 {
10385 return \Illuminate\Session\Store::regenerate($destroy);
10386 }
10387
10388 /**
10389 * Generate a new session ID for the session.
10390 *
10391 * @param bool $destroy
10392 * @return bool
10393 * @static
10394 */
10395 public static function migrate($destroy = false)
10396 {
10397 return \Illuminate\Session\Store::migrate($destroy);
10398 }
10399
10400 /**
10401 * Determine if the session has been started.
10402 *
10403 * @return bool
10404 * @static
10405 */
10406 public static function isStarted()
10407 {
10408 return \Illuminate\Session\Store::isStarted();
10409 }
10410
10411 /**
10412 * Get the name of the session.
10413 *
10414 * @return string
10415 * @static
10416 */
10417 public static function getName()
10418 {
10419 return \Illuminate\Session\Store::getName();
10420 }
10421
10422 /**
10423 * Set the name of the session.
10424 *
10425 * @param string $name
10426 * @return void
10427 * @static
10428 */
10429 public static function setName($name)
10430 {
10431 \Illuminate\Session\Store::setName($name);
10432 }
10433
10434 /**
10435 * Get the current session ID.
10436 *
10437 * @return string
10438 * @static
10439 */
10440 public static function getId()
10441 {
10442 return \Illuminate\Session\Store::getId();
10443 }
10444
10445 /**
10446 * Set the session ID.
10447 *
10448 * @param string $id
10449 * @return void
10450 * @static
10451 */
10452 public static function setId($id)
10453 {
10454 \Illuminate\Session\Store::setId($id);
10455 }
10456
10457 /**
10458 * Determine if this is a valid session ID.
10459 *
10460 * @param string $id
10461 * @return bool
10462 * @static
10463 */
10464 public static function isValidId($id)
10465 {
10466 return \Illuminate\Session\Store::isValidId($id);
10467 }
10468
10469 /**
10470 * Set the existence of the session on the handler if applicable.
10471 *
10472 * @param bool $value
10473 * @return void
10474 * @static
10475 */
10476 public static function setExists($value)
10477 {
10478 \Illuminate\Session\Store::setExists($value);
10479 }
10480
10481 /**
10482 * Get the CSRF token value.
10483 *
10484 * @return string
10485 * @static
10486 */
10487 public static function token()
10488 {
10489 return \Illuminate\Session\Store::token();
10490 }
10491
10492 /**
10493 * Regenerate the CSRF token value.
10494 *
10495 * @return void
10496 * @static
10497 */
10498 public static function regenerateToken()
10499 {
10500 \Illuminate\Session\Store::regenerateToken();
10501 }
10502
10503 /**
10504 * Get the previous URL from the session.
10505 *
10506 * @return string|null
10507 * @static
10508 */
10509 public static function previousUrl()
10510 {
10511 return \Illuminate\Session\Store::previousUrl();
10512 }
10513
10514 /**
10515 * Set the "previous" URL in the session.
10516 *
10517 * @param string $url
10518 * @return void
10519 * @static
10520 */
10521 public static function setPreviousUrl($url)
10522 {
10523 \Illuminate\Session\Store::setPreviousUrl($url);
10524 }
10525
10526 /**
10527 * Get the underlying session handler implementation.
10528 *
10529 * @return \SessionHandlerInterface
10530 * @static
10531 */
10532 public static function getHandler()
10533 {
10534 return \Illuminate\Session\Store::getHandler();
10535 }
10536
10537 /**
10538 * Determine if the session handler needs a request.
10539 *
10540 * @return bool
10541 * @static
10542 */
10543 public static function handlerNeedsRequest()
10544 {
10545 return \Illuminate\Session\Store::handlerNeedsRequest();
10546 }
10547
10548 /**
10549 * Set the request on the handler instance.
10550 *
10551 * @param \Illuminate\Http\Request $request
10552 * @return void
10553 * @static
10554 */
10555 public static function setRequestOnHandler($request)
10556 {
10557 \Illuminate\Session\Store::setRequestOnHandler($request);
10558 }
10559
10560 }
10561
10562 class Storage {
10563
10564 /**
10565 * Get a filesystem instance.
10566 *
10567 * @param string $name
10568 * @return \Illuminate\Filesystem\FilesystemAdapter
10569 * @static
10570 */
10571 public static function drive($name = null)
10572 {
10573 return \Illuminate\Filesystem\FilesystemManager::drive($name);
10574 }
10575
10576 /**
10577 * Get a filesystem instance.
10578 *
10579 * @param string $name
10580 * @return \Illuminate\Filesystem\FilesystemAdapter
10581 * @static
10582 */
10583 public static function disk($name = null)
10584 {
10585 return \Illuminate\Filesystem\FilesystemManager::disk($name);
10586 }
10587
10588 /**
10589 * Get a default cloud filesystem instance.
10590 *
10591 * @return \Illuminate\Filesystem\FilesystemAdapter
10592 * @static
10593 */
10594 public static function cloud()
10595 {
10596 return \Illuminate\Filesystem\FilesystemManager::cloud();
10597 }
10598
10599 /**
10600 * Create an instance of the local driver.
10601 *
10602 * @param array $config
10603 * @return \Illuminate\Filesystem\FilesystemAdapter
10604 * @static
10605 */
10606 public static function createLocalDriver($config)
10607 {
10608 return \Illuminate\Filesystem\FilesystemManager::createLocalDriver($config);
10609 }
10610
10611 /**
10612 * Create an instance of the ftp driver.
10613 *
10614 * @param array $config
10615 * @return \Illuminate\Filesystem\FilesystemAdapter
10616 * @static
10617 */
10618 public static function createFtpDriver($config)
10619 {
10620 return \Illuminate\Filesystem\FilesystemManager::createFtpDriver($config);
10621 }
10622
10623 /**
10624 * Create an instance of the sftp driver.
10625 *
10626 * @param array $config
10627 * @return \Illuminate\Filesystem\FilesystemAdapter
10628 * @static
10629 */
10630 public static function createSftpDriver($config)
10631 {
10632 return \Illuminate\Filesystem\FilesystemManager::createSftpDriver($config);
10633 }
10634
10635 /**
10636 * Create an instance of the Amazon S3 driver.
10637 *
10638 * @param array $config
10639 * @return \Illuminate\Contracts\Filesystem\Cloud
10640 * @static
10641 */
10642 public static function createS3Driver($config)
10643 {
10644 return \Illuminate\Filesystem\FilesystemManager::createS3Driver($config);
10645 }
10646
10647 /**
10648 * Create an instance of the Rackspace driver.
10649 *
10650 * @param array $config
10651 * @return \Illuminate\Contracts\Filesystem\Cloud
10652 * @static
10653 */
10654 public static function createRackspaceDriver($config)
10655 {
10656 return \Illuminate\Filesystem\FilesystemManager::createRackspaceDriver($config);
10657 }
10658
10659 /**
10660 * Set the given disk instance.
10661 *
10662 * @param string $name
10663 * @param mixed $disk
10664 * @return void
10665 * @static
10666 */
10667 public static function set($name, $disk)
10668 {
10669 \Illuminate\Filesystem\FilesystemManager::set($name, $disk);
10670 }
10671
10672 /**
10673 * Get the default driver name.
10674 *
10675 * @return string
10676 * @static
10677 */
10678 public static function getDefaultDriver()
10679 {
10680 return \Illuminate\Filesystem\FilesystemManager::getDefaultDriver();
10681 }
10682
10683 /**
10684 * Get the default cloud driver name.
10685 *
10686 * @return string
10687 * @static
10688 */
10689 public static function getDefaultCloudDriver()
10690 {
10691 return \Illuminate\Filesystem\FilesystemManager::getDefaultCloudDriver();
10692 }
10693
10694 /**
10695 * Register a custom driver creator Closure.
10696 *
10697 * @param string $driver
10698 * @param \Closure $callback
10699 * @return $this
10700 * @static
10701 */
10702 public static function extend($driver, $callback)
10703 {
10704 return \Illuminate\Filesystem\FilesystemManager::extend($driver, $callback);
10705 }
10706
10707 /**
10708 * Assert that the given file exists.
10709 *
10710 * @param string $path
10711 * @return void
10712 * @static
10713 */
10714 public static function assertExists($path)
10715 {
10716 \Illuminate\Filesystem\FilesystemAdapter::assertExists($path);
10717 }
10718
10719 /**
10720 * Assert that the given file does not exist.
10721 *
10722 * @param string $path
10723 * @return void
10724 * @static
10725 */
10726 public static function assertMissing($path)
10727 {
10728 \Illuminate\Filesystem\FilesystemAdapter::assertMissing($path);
10729 }
10730
10731 /**
10732 * Determine if a file exists.
10733 *
10734 * @param string $path
10735 * @return bool
10736 * @static
10737 */
10738 public static function exists($path)
10739 {
10740 return \Illuminate\Filesystem\FilesystemAdapter::exists($path);
10741 }
10742
10743 /**
10744 * Get the full path for the file at the given "short" path.
10745 *
10746 * @param string $path
10747 * @return string
10748 * @static
10749 */
10750 public static function path($path)
10751 {
10752 return \Illuminate\Filesystem\FilesystemAdapter::path($path);
10753 }
10754
10755 /**
10756 * Get the contents of a file.
10757 *
10758 * @param string $path
10759 * @return string
10760 * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
10761 * @static
10762 */
10763 public static function get($path)
10764 {
10765 return \Illuminate\Filesystem\FilesystemAdapter::get($path);
10766 }
10767
10768 /**
10769 * Create a streamed response for a given file.
10770 *
10771 * @param string $path
10772 * @param string|null $name
10773 * @param array|null $headers
10774 * @param string|null $disposition
10775 * @return \Symfony\Component\HttpFoundation\StreamedResponse
10776 * @static
10777 */
10778 public static function response($path, $name = null, $headers = array(), $disposition = 'inline')
10779 {
10780 return \Illuminate\Filesystem\FilesystemAdapter::response($path, $name, $headers, $disposition);
10781 }
10782
10783 /**
10784 * Create a streamed download response for a given file.
10785 *
10786 * @param string $path
10787 * @param string|null $name
10788 * @param array|null $headers
10789 * @return \Symfony\Component\HttpFoundation\StreamedResponse
10790 * @static
10791 */
10792 public static function download($path, $name = null, $headers = array())
10793 {
10794 return \Illuminate\Filesystem\FilesystemAdapter::download($path, $name, $headers);
10795 }
10796
10797 /**
10798 * Write the contents of a file.
10799 *
10800 * @param string $path
10801 * @param string|resource $contents
10802 * @param mixed $options
10803 * @return bool
10804 * @static
10805 */
10806 public static function put($path, $contents, $options = array())
10807 {
10808 return \Illuminate\Filesystem\FilesystemAdapter::put($path, $contents, $options);
10809 }
10810
10811 /**
10812 * Store the uploaded file on the disk.
10813 *
10814 * @param string $path
10815 * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile $file
10816 * @param array $options
10817 * @return string|false
10818 * @static
10819 */
10820 public static function putFile($path, $file, $options = array())
10821 {
10822 return \Illuminate\Filesystem\FilesystemAdapter::putFile($path, $file, $options);
10823 }
10824
10825 /**
10826 * Store the uploaded file on the disk with a given name.
10827 *
10828 * @param string $path
10829 * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile $file
10830 * @param string $name
10831 * @param array $options
10832 * @return string|false
10833 * @static
10834 */
10835 public static function putFileAs($path, $file, $name, $options = array())
10836 {
10837 return \Illuminate\Filesystem\FilesystemAdapter::putFileAs($path, $file, $name, $options);
10838 }
10839
10840 /**
10841 * Get the visibility for the given path.
10842 *
10843 * @param string $path
10844 * @return string
10845 * @static
10846 */
10847 public static function getVisibility($path)
10848 {
10849 return \Illuminate\Filesystem\FilesystemAdapter::getVisibility($path);
10850 }
10851
10852 /**
10853 * Set the visibility for the given path.
10854 *
10855 * @param string $path
10856 * @param string $visibility
10857 * @return void
10858 * @static
10859 */
10860 public static function setVisibility($path, $visibility)
10861 {
10862 \Illuminate\Filesystem\FilesystemAdapter::setVisibility($path, $visibility);
10863 }
10864
10865 /**
10866 * Prepend to a file.
10867 *
10868 * @param string $path
10869 * @param string $data
10870 * @param string $separator
10871 * @return int
10872 * @static
10873 */
10874 public static function prepend($path, $data, $separator = '')
10875 {
10876 return \Illuminate\Filesystem\FilesystemAdapter::prepend($path, $data, $separator);
10877 }
10878
10879 /**
10880 * Append to a file.
10881 *
10882 * @param string $path
10883 * @param string $data
10884 * @param string $separator
10885 * @return int
10886 * @static
10887 */
10888 public static function append($path, $data, $separator = '')
10889 {
10890 return \Illuminate\Filesystem\FilesystemAdapter::append($path, $data, $separator);
10891 }
10892
10893 /**
10894 * Delete the file at a given path.
10895 *
10896 * @param string|array $paths
10897 * @return bool
10898 * @static
10899 */
10900 public static function delete($paths)
10901 {
10902 return \Illuminate\Filesystem\FilesystemAdapter::delete($paths);
10903 }
10904
10905 /**
10906 * Copy a file to a new location.
10907 *
10908 * @param string $from
10909 * @param string $to
10910 * @return bool
10911 * @static
10912 */
10913 public static function copy($from, $to)
10914 {
10915 return \Illuminate\Filesystem\FilesystemAdapter::copy($from, $to);
10916 }
10917
10918 /**
10919 * Move a file to a new location.
10920 *
10921 * @param string $from
10922 * @param string $to
10923 * @return bool
10924 * @static
10925 */
10926 public static function move($from, $to)
10927 {
10928 return \Illuminate\Filesystem\FilesystemAdapter::move($from, $to);
10929 }
10930
10931 /**
10932 * Get the file size of a given file.
10933 *
10934 * @param string $path
10935 * @return int
10936 * @static
10937 */
10938 public static function size($path)
10939 {
10940 return \Illuminate\Filesystem\FilesystemAdapter::size($path);
10941 }
10942
10943 /**
10944 * Get the mime-type of a given file.
10945 *
10946 * @param string $path
10947 * @return string|false
10948 * @static
10949 */
10950 public static function mimeType($path)
10951 {
10952 return \Illuminate\Filesystem\FilesystemAdapter::mimeType($path);
10953 }
10954
10955 /**
10956 * Get the file's last modification time.
10957 *
10958 * @param string $path
10959 * @return int
10960 * @static
10961 */
10962 public static function lastModified($path)
10963 {
10964 return \Illuminate\Filesystem\FilesystemAdapter::lastModified($path);
10965 }
10966
10967 /**
10968 * Get the URL for the file at the given path.
10969 *
10970 * @param string $path
10971 * @return string
10972 * @static
10973 */
10974 public static function url($path)
10975 {
10976 return \Illuminate\Filesystem\FilesystemAdapter::url($path);
10977 }
10978
10979 /**
10980 * Get a temporary URL for the file at the given path.
10981 *
10982 * @param string $path
10983 * @param \DateTimeInterface $expiration
10984 * @param array $options
10985 * @return string
10986 * @static
10987 */
10988 public static function temporaryUrl($path, $expiration, $options = array())
10989 {
10990 return \Illuminate\Filesystem\FilesystemAdapter::temporaryUrl($path, $expiration, $options);
10991 }
10992
10993 /**
10994 * Get a temporary URL for the file at the given path.
10995 *
10996 * @param \League\Flysystem\AwsS3v3\AwsS3Adapter $adapter
10997 * @param string $path
10998 * @param \DateTimeInterface $expiration
10999 * @param array $options
11000 * @return string
11001 * @static
11002 */
11003 public static function getAwsTemporaryUrl($adapter, $path, $expiration, $options)
11004 {
11005 return \Illuminate\Filesystem\FilesystemAdapter::getAwsTemporaryUrl($adapter, $path, $expiration, $options);
11006 }
11007
11008 /**
11009 * Get a temporary URL for the file at the given path.
11010 *
11011 * @param \League\Flysystem\Rackspace\RackspaceAdapter $adapter
11012 * @param string $path
11013 * @param \DateTimeInterface $expiration
11014 * @param array $options
11015 * @return string
11016 * @static
11017 */
11018 public static function getRackspaceTemporaryUrl($adapter, $path, $expiration, $options)
11019 {
11020 return \Illuminate\Filesystem\FilesystemAdapter::getRackspaceTemporaryUrl($adapter, $path, $expiration, $options);
11021 }
11022
11023 /**
11024 * Get an array of all files in a directory.
11025 *
11026 * @param string|null $directory
11027 * @param bool $recursive
11028 * @return array
11029 * @static
11030 */
11031 public static function files($directory = null, $recursive = false)
11032 {
11033 return \Illuminate\Filesystem\FilesystemAdapter::files($directory, $recursive);
11034 }
11035
11036 /**
11037 * Get all of the files from the given directory (recursive).
11038 *
11039 * @param string|null $directory
11040 * @return array
11041 * @static
11042 */
11043 public static function allFiles($directory = null)
11044 {
11045 return \Illuminate\Filesystem\FilesystemAdapter::allFiles($directory);
11046 }
11047
11048 /**
11049 * Get all of the directories within a given directory.
11050 *
11051 * @param string|null $directory
11052 * @param bool $recursive
11053 * @return array
11054 * @static
11055 */
11056 public static function directories($directory = null, $recursive = false)
11057 {
11058 return \Illuminate\Filesystem\FilesystemAdapter::directories($directory, $recursive);
11059 }
11060
11061 /**
11062 * Get all (recursive) of the directories within a given directory.
11063 *
11064 * @param string|null $directory
11065 * @return array
11066 * @static
11067 */
11068 public static function allDirectories($directory = null)
11069 {
11070 return \Illuminate\Filesystem\FilesystemAdapter::allDirectories($directory);
11071 }
11072
11073 /**
11074 * Create a directory.
11075 *
11076 * @param string $path
11077 * @return bool
11078 * @static
11079 */
11080 public static function makeDirectory($path)
11081 {
11082 return \Illuminate\Filesystem\FilesystemAdapter::makeDirectory($path);
11083 }
11084
11085 /**
11086 * Recursively delete a directory.
11087 *
11088 * @param string $directory
11089 * @return bool
11090 * @static
11091 */
11092 public static function deleteDirectory($directory)
11093 {
11094 return \Illuminate\Filesystem\FilesystemAdapter::deleteDirectory($directory);
11095 }
11096
11097 /**
11098 * Flush the Flysystem cache.
11099 *
11100 * @return void
11101 * @static
11102 */
11103 public static function flushCache()
11104 {
11105 \Illuminate\Filesystem\FilesystemAdapter::flushCache();
11106 }
11107
11108 /**
11109 * Get the Flysystem driver.
11110 *
11111 * @return \League\Flysystem\FilesystemInterface
11112 * @static
11113 */
11114 public static function getDriver()
11115 {
11116 return \Illuminate\Filesystem\FilesystemAdapter::getDriver();
11117 }
11118
11119 }
11120
11121 class URL {
11122
11123 /**
11124 * Get the full URL for the current request.
11125 *
11126 * @return string
11127 * @static
11128 */
11129 public static function full()
11130 {
11131 return \Illuminate\Routing\UrlGenerator::full();
11132 }
11133
11134 /**
11135 * Get the current URL for the request.
11136 *
11137 * @return string
11138 * @static
11139 */
11140 public static function current()
11141 {
11142 return \Illuminate\Routing\UrlGenerator::current();
11143 }
11144
11145 /**
11146 * Get the URL for the previous request.
11147 *
11148 * @param mixed $fallback
11149 * @return string
11150 * @static
11151 */
11152 public static function previous($fallback = false)
11153 {
11154 return \Illuminate\Routing\UrlGenerator::previous($fallback);
11155 }
11156
11157 /**
11158 * Generate an absolute URL to the given path.
11159 *
11160 * @param string $path
11161 * @param mixed $extra
11162 * @param bool|null $secure
11163 * @return string
11164 * @static
11165 */
11166 public static function to($path, $extra = array(), $secure = null)
11167 {
11168 return \Illuminate\Routing\UrlGenerator::to($path, $extra, $secure);
11169 }
11170
11171 /**
11172 * Generate a secure, absolute URL to the given path.
11173 *
11174 * @param string $path
11175 * @param array $parameters
11176 * @return string
11177 * @static
11178 */
11179 public static function secure($path, $parameters = array())
11180 {
11181 return \Illuminate\Routing\UrlGenerator::secure($path, $parameters);
11182 }
11183
11184 /**
11185 * Generate the URL to an application asset.
11186 *
11187 * @param string $path
11188 * @param bool|null $secure
11189 * @return string
11190 * @static
11191 */
11192 public static function asset($path, $secure = null)
11193 {
11194 return \Illuminate\Routing\UrlGenerator::asset($path, $secure);
11195 }
11196
11197 /**
11198 * Generate the URL to a secure asset.
11199 *
11200 * @param string $path
11201 * @return string
11202 * @static
11203 */
11204 public static function secureAsset($path)
11205 {
11206 return \Illuminate\Routing\UrlGenerator::secureAsset($path);
11207 }
11208
11209 /**
11210 * Generate the URL to an asset from a custom root domain such as CDN, etc.
11211 *
11212 * @param string $root
11213 * @param string $path
11214 * @param bool|null $secure
11215 * @return string
11216 * @static
11217 */
11218 public static function assetFrom($root, $path, $secure = null)
11219 {
11220 return \Illuminate\Routing\UrlGenerator::assetFrom($root, $path, $secure);
11221 }
11222
11223 /**
11224 * Get the default scheme for a raw URL.
11225 *
11226 * @param bool|null $secure
11227 * @return string
11228 * @static
11229 */
11230 public static function formatScheme($secure)
11231 {
11232 return \Illuminate\Routing\UrlGenerator::formatScheme($secure);
11233 }
11234
11235 /**
11236 * Create a signed route URL for a named route.
11237 *
11238 * @param string $name
11239 * @param array $parameters
11240 * @param \DateTimeInterface|int $expiration
11241 * @return string
11242 * @static
11243 */
11244 public static function signedRoute($name, $parameters = array(), $expiration = null)
11245 {
11246 return \Illuminate\Routing\UrlGenerator::signedRoute($name, $parameters, $expiration);
11247 }
11248
11249 /**
11250 * Create a temporary signed route URL for a named route.
11251 *
11252 * @param string $name
11253 * @param \DateTimeInterface|int $expiration
11254 * @param array $parameters
11255 * @return string
11256 * @static
11257 */
11258 public static function temporarySignedRoute($name, $expiration, $parameters = array())
11259 {
11260 return \Illuminate\Routing\UrlGenerator::temporarySignedRoute($name, $expiration, $parameters);
11261 }
11262
11263 /**
11264 * Determine if the given request has a valid signature.
11265 *
11266 * @param \Illuminate\Http\Request $request
11267 * @return bool
11268 * @static
11269 */
11270 public static function hasValidSignature($request)
11271 {
11272 return \Illuminate\Routing\UrlGenerator::hasValidSignature($request);
11273 }
11274
11275 /**
11276 * Get the URL to a named route.
11277 *
11278 * @param string $name
11279 * @param mixed $parameters
11280 * @param bool $absolute
11281 * @return string
11282 * @throws \InvalidArgumentException
11283 * @static
11284 */
11285 public static function route($name, $parameters = array(), $absolute = true)
11286 {
11287 return \Illuminate\Routing\UrlGenerator::route($name, $parameters, $absolute);
11288 }
11289
11290 /**
11291 * Get the URL to a controller action.
11292 *
11293 * @param string $action
11294 * @param mixed $parameters
11295 * @param bool $absolute
11296 * @return string
11297 * @throws \InvalidArgumentException
11298 * @static
11299 */
11300 public static function action($action, $parameters = array(), $absolute = true)
11301 {
11302 return \Illuminate\Routing\UrlGenerator::action($action, $parameters, $absolute);
11303 }
11304
11305 /**
11306 * Format the array of URL parameters.
11307 *
11308 * @param mixed|array $parameters
11309 * @return array
11310 * @static
11311 */
11312 public static function formatParameters($parameters)
11313 {
11314 return \Illuminate\Routing\UrlGenerator::formatParameters($parameters);
11315 }
11316
11317 /**
11318 * Get the base URL for the request.
11319 *
11320 * @param string $scheme
11321 * @param string $root
11322 * @return string
11323 * @static
11324 */
11325 public static function formatRoot($scheme, $root = null)
11326 {
11327 return \Illuminate\Routing\UrlGenerator::formatRoot($scheme, $root);
11328 }
11329
11330 /**
11331 * Format the given URL segments into a single URL.
11332 *
11333 * @param string $root
11334 * @param string $path
11335 * @return string
11336 * @static
11337 */
11338 public static function format($root, $path)
11339 {
11340 return \Illuminate\Routing\UrlGenerator::format($root, $path);
11341 }
11342
11343 /**
11344 * Determine if the given path is a valid URL.
11345 *
11346 * @param string $path
11347 * @return bool
11348 * @static
11349 */
11350 public static function isValidUrl($path)
11351 {
11352 return \Illuminate\Routing\UrlGenerator::isValidUrl($path);
11353 }
11354
11355 /**
11356 * Set the default named parameters used by the URL generator.
11357 *
11358 * @param array $defaults
11359 * @return void
11360 * @static
11361 */
11362 public static function defaults($defaults)
11363 {
11364 \Illuminate\Routing\UrlGenerator::defaults($defaults);
11365 }
11366
11367 /**
11368 * Get the default named parameters used by the URL generator.
11369 *
11370 * @return array
11371 * @static
11372 */
11373 public static function getDefaultParameters()
11374 {
11375 return \Illuminate\Routing\UrlGenerator::getDefaultParameters();
11376 }
11377
11378 /**
11379 * Force the scheme for URLs.
11380 *
11381 * @param string $schema
11382 * @return void
11383 * @static
11384 */
11385 public static function forceScheme($schema)
11386 {
11387 \Illuminate\Routing\UrlGenerator::forceScheme($schema);
11388 }
11389
11390 /**
11391 * Set the forced root URL.
11392 *
11393 * @param string $root
11394 * @return void
11395 * @static
11396 */
11397 public static function forceRootUrl($root)
11398 {
11399 \Illuminate\Routing\UrlGenerator::forceRootUrl($root);
11400 }
11401
11402 /**
11403 * Set a callback to be used to format the host of generated URLs.
11404 *
11405 * @param \Closure $callback
11406 * @return $this
11407 * @static
11408 */
11409 public static function formatHostUsing($callback)
11410 {
11411 return \Illuminate\Routing\UrlGenerator::formatHostUsing($callback);
11412 }
11413
11414 /**
11415 * Set a callback to be used to format the path of generated URLs.
11416 *
11417 * @param \Closure $callback
11418 * @return $this
11419 * @static
11420 */
11421 public static function formatPathUsing($callback)
11422 {
11423 return \Illuminate\Routing\UrlGenerator::formatPathUsing($callback);
11424 }
11425
11426 /**
11427 * Get the path formatter being used by the URL generator.
11428 *
11429 * @return \Closure
11430 * @static
11431 */
11432 public static function pathFormatter()
11433 {
11434 return \Illuminate\Routing\UrlGenerator::pathFormatter();
11435 }
11436
11437 /**
11438 * Get the request instance.
11439 *
11440 * @return \Illuminate\Http\Request
11441 * @static
11442 */
11443 public static function getRequest()
11444 {
11445 return \Illuminate\Routing\UrlGenerator::getRequest();
11446 }
11447
11448 /**
11449 * Set the current request instance.
11450 *
11451 * @param \Illuminate\Http\Request $request
11452 * @return void
11453 * @static
11454 */
11455 public static function setRequest($request)
11456 {
11457 \Illuminate\Routing\UrlGenerator::setRequest($request);
11458 }
11459
11460 /**
11461 * Set the route collection.
11462 *
11463 * @param \Illuminate\Routing\RouteCollection $routes
11464 * @return $this
11465 * @static
11466 */
11467 public static function setRoutes($routes)
11468 {
11469 return \Illuminate\Routing\UrlGenerator::setRoutes($routes);
11470 }
11471
11472 /**
11473 * Set the session resolver for the generator.
11474 *
11475 * @param callable $sessionResolver
11476 * @return $this
11477 * @static
11478 */
11479 public static function setSessionResolver($sessionResolver)
11480 {
11481 return \Illuminate\Routing\UrlGenerator::setSessionResolver($sessionResolver);
11482 }
11483
11484 /**
11485 * Set the encryption key resolver.
11486 *
11487 * @param callable $keyResolver
11488 * @return $this
11489 * @static
11490 */
11491 public static function setKeyResolver($keyResolver)
11492 {
11493 return \Illuminate\Routing\UrlGenerator::setKeyResolver($keyResolver);
11494 }
11495
11496 /**
11497 * Set the root controller namespace.
11498 *
11499 * @param string $rootNamespace
11500 * @return $this
11501 * @static
11502 */
11503 public static function setRootControllerNamespace($rootNamespace)
11504 {
11505 return \Illuminate\Routing\UrlGenerator::setRootControllerNamespace($rootNamespace);
11506 }
11507
11508 /**
11509 * Register a custom macro.
11510 *
11511 * @param string $name
11512 * @param object|callable $macro
11513 * @return void
11514 * @static
11515 */
11516 public static function macro($name, $macro)
11517 {
11518 \Illuminate\Routing\UrlGenerator::macro($name, $macro);
11519 }
11520
11521 /**
11522 * Mix another object into the class.
11523 *
11524 * @param object $mixin
11525 * @return void
11526 * @throws \ReflectionException
11527 * @static
11528 */
11529 public static function mixin($mixin)
11530 {
11531 \Illuminate\Routing\UrlGenerator::mixin($mixin);
11532 }
11533
11534 /**
11535 * Checks if macro is registered.
11536 *
11537 * @param string $name
11538 * @return bool
11539 * @static
11540 */
11541 public static function hasMacro($name)
11542 {
11543 return \Illuminate\Routing\UrlGenerator::hasMacro($name);
11544 }
11545
11546 }
11547
11548 class Validator {
11549
11550 /**
11551 * Create a new Validator instance.
11552 *
11553 * @param array $data
11554 * @param array $rules
11555 * @param array $messages
11556 * @param array $customAttributes
11557 * @return \Illuminate\Validation\Validator
11558 * @static
11559 */
11560 public static function make($data, $rules, $messages = array(), $customAttributes = array())
11561 {
11562 return \Illuminate\Validation\Factory::make($data, $rules, $messages, $customAttributes);
11563 }
11564
11565 /**
11566 * Validate the given data against the provided rules.
11567 *
11568 * @param array $data
11569 * @param array $rules
11570 * @param array $messages
11571 * @param array $customAttributes
11572 * @return array
11573 * @throws \Illuminate\Validation\ValidationException
11574 * @static
11575 */
11576 public static function validate($data, $rules, $messages = array(), $customAttributes = array())
11577 {
11578 return \Illuminate\Validation\Factory::validate($data, $rules, $messages, $customAttributes);
11579 }
11580
11581 /**
11582 * Register a custom validator extension.
11583 *
11584 * @param string $rule
11585 * @param \Closure|string $extension
11586 * @param string $message
11587 * @return void
11588 * @static
11589 */
11590 public static function extend($rule, $extension, $message = null)
11591 {
11592 \Illuminate\Validation\Factory::extend($rule, $extension, $message);
11593 }
11594
11595 /**
11596 * Register a custom implicit validator extension.
11597 *
11598 * @param string $rule
11599 * @param \Closure|string $extension
11600 * @param string $message
11601 * @return void
11602 * @static
11603 */
11604 public static function extendImplicit($rule, $extension, $message = null)
11605 {
11606 \Illuminate\Validation\Factory::extendImplicit($rule, $extension, $message);
11607 }
11608
11609 /**
11610 * Register a custom dependent validator extension.
11611 *
11612 * @param string $rule
11613 * @param \Closure|string $extension
11614 * @param string $message
11615 * @return void
11616 * @static
11617 */
11618 public static function extendDependent($rule, $extension, $message = null)
11619 {
11620 \Illuminate\Validation\Factory::extendDependent($rule, $extension, $message);
11621 }
11622
11623 /**
11624 * Register a custom validator message replacer.
11625 *
11626 * @param string $rule
11627 * @param \Closure|string $replacer
11628 * @return void
11629 * @static
11630 */
11631 public static function replacer($rule, $replacer)
11632 {
11633 \Illuminate\Validation\Factory::replacer($rule, $replacer);
11634 }
11635
11636 /**
11637 * Set the Validator instance resolver.
11638 *
11639 * @param \Closure $resolver
11640 * @return void
11641 * @static
11642 */
11643 public static function resolver($resolver)
11644 {
11645 \Illuminate\Validation\Factory::resolver($resolver);
11646 }
11647
11648 /**
11649 * Get the Translator implementation.
11650 *
11651 * @return \Illuminate\Contracts\Translation\Translator
11652 * @static
11653 */
11654 public static function getTranslator()
11655 {
11656 return \Illuminate\Validation\Factory::getTranslator();
11657 }
11658
11659 /**
11660 * Get the Presence Verifier implementation.
11661 *
11662 * @return \Illuminate\Validation\PresenceVerifierInterface
11663 * @static
11664 */
11665 public static function getPresenceVerifier()
11666 {
11667 return \Illuminate\Validation\Factory::getPresenceVerifier();
11668 }
11669
11670 /**
11671 * Set the Presence Verifier implementation.
11672 *
11673 * @param \Illuminate\Validation\PresenceVerifierInterface $presenceVerifier
11674 * @return void
11675 * @static
11676 */
11677 public static function setPresenceVerifier($presenceVerifier)
11678 {
11679 \Illuminate\Validation\Factory::setPresenceVerifier($presenceVerifier);
11680 }
11681
11682 }
11683
11684 class View {
11685
11686 /**
11687 * Get the evaluated view contents for the given view.
11688 *
11689 * @param string $path
11690 * @param array $data
11691 * @param array $mergeData
11692 * @return \Illuminate\Contracts\View\View
11693 * @static
11694 */
11695 public static function file($path, $data = array(), $mergeData = array())
11696 {
11697 return \Illuminate\View\Factory::file($path, $data, $mergeData);
11698 }
11699
11700 /**
11701 * Get the evaluated view contents for the given view.
11702 *
11703 * @param string $view
11704 * @param array $data
11705 * @param array $mergeData
11706 * @return \Illuminate\Contracts\View\View
11707 * @static
11708 */
11709 public static function make($view, $data = array(), $mergeData = array())
11710 {
11711 return \Illuminate\View\Factory::make($view, $data, $mergeData);
11712 }
11713
11714 /**
11715 * Get the first view that actually exists from the given list.
11716 *
11717 * @param array $views
11718 * @param array $data
11719 * @param array $mergeData
11720 * @return \Illuminate\Contracts\View\View
11721 * @static
11722 */
11723 public static function first($views, $data = array(), $mergeData = array())
11724 {
11725 return \Illuminate\View\Factory::first($views, $data, $mergeData);
11726 }
11727
11728 /**
11729 * Get the rendered content of the view based on a given condition.
11730 *
11731 * @param bool $condition
11732 * @param string $view
11733 * @param array $data
11734 * @param array $mergeData
11735 * @return string
11736 * @static
11737 */
11738 public static function renderWhen($condition, $view, $data = array(), $mergeData = array())
11739 {
11740 return \Illuminate\View\Factory::renderWhen($condition, $view, $data, $mergeData);
11741 }
11742
11743 /**
11744 * Get the rendered contents of a partial from a loop.
11745 *
11746 * @param string $view
11747 * @param array $data
11748 * @param string $iterator
11749 * @param string $empty
11750 * @return string
11751 * @static
11752 */
11753 public static function renderEach($view, $data, $iterator, $empty = 'raw|')
11754 {
11755 return \Illuminate\View\Factory::renderEach($view, $data, $iterator, $empty);
11756 }
11757
11758 /**
11759 * Determine if a given view exists.
11760 *
11761 * @param string $view
11762 * @return bool
11763 * @static
11764 */
11765 public static function exists($view)
11766 {
11767 return \Illuminate\View\Factory::exists($view);
11768 }
11769
11770 /**
11771 * Get the appropriate view engine for the given path.
11772 *
11773 * @param string $path
11774 * @return \Illuminate\Contracts\View\Engine
11775 * @throws \InvalidArgumentException
11776 * @static
11777 */
11778 public static function getEngineFromPath($path)
11779 {
11780 return \Illuminate\View\Factory::getEngineFromPath($path);
11781 }
11782
11783 /**
11784 * Add a piece of shared data to the environment.
11785 *
11786 * @param array|string $key
11787 * @param mixed $value
11788 * @return mixed
11789 * @static
11790 */
11791 public static function share($key, $value = null)
11792 {
11793 return \Illuminate\View\Factory::share($key, $value);
11794 }
11795
11796 /**
11797 * Increment the rendering counter.
11798 *
11799 * @return void
11800 * @static
11801 */
11802 public static function incrementRender()
11803 {
11804 \Illuminate\View\Factory::incrementRender();
11805 }
11806
11807 /**
11808 * Decrement the rendering counter.
11809 *
11810 * @return void
11811 * @static
11812 */
11813 public static function decrementRender()
11814 {
11815 \Illuminate\View\Factory::decrementRender();
11816 }
11817
11818 /**
11819 * Check if there are no active render operations.
11820 *
11821 * @return bool
11822 * @static
11823 */
11824 public static function doneRendering()
11825 {
11826 return \Illuminate\View\Factory::doneRendering();
11827 }
11828
11829 /**
11830 * Add a location to the array of view locations.
11831 *
11832 * @param string $location
11833 * @return void
11834 * @static
11835 */
11836 public static function addLocation($location)
11837 {
11838 \Illuminate\View\Factory::addLocation($location);
11839 }
11840
11841 /**
11842 * Add a new namespace to the loader.
11843 *
11844 * @param string $namespace
11845 * @param string|array $hints
11846 * @return $this
11847 * @static
11848 */
11849 public static function addNamespace($namespace, $hints)
11850 {
11851 return \Illuminate\View\Factory::addNamespace($namespace, $hints);
11852 }
11853
11854 /**
11855 * Prepend a new namespace to the loader.
11856 *
11857 * @param string $namespace
11858 * @param string|array $hints
11859 * @return $this
11860 * @static
11861 */
11862 public static function prependNamespace($namespace, $hints)
11863 {
11864 return \Illuminate\View\Factory::prependNamespace($namespace, $hints);
11865 }
11866
11867 /**
11868 * Replace the namespace hints for the given namespace.
11869 *
11870 * @param string $namespace
11871 * @param string|array $hints
11872 * @return $this
11873 * @static
11874 */
11875 public static function replaceNamespace($namespace, $hints)
11876 {
11877 return \Illuminate\View\Factory::replaceNamespace($namespace, $hints);
11878 }
11879
11880 /**
11881 * Register a valid view extension and its engine.
11882 *
11883 * @param string $extension
11884 * @param string $engine
11885 * @param \Closure $resolver
11886 * @return void
11887 * @static
11888 */
11889 public static function addExtension($extension, $engine, $resolver = null)
11890 {
11891 \Illuminate\View\Factory::addExtension($extension, $engine, $resolver);
11892 }
11893
11894 /**
11895 * Flush all of the factory state like sections and stacks.
11896 *
11897 * @return void
11898 * @static
11899 */
11900 public static function flushState()
11901 {
11902 \Illuminate\View\Factory::flushState();
11903 }
11904
11905 /**
11906 * Flush all of the section contents if done rendering.
11907 *
11908 * @return void
11909 * @static
11910 */
11911 public static function flushStateIfDoneRendering()
11912 {
11913 \Illuminate\View\Factory::flushStateIfDoneRendering();
11914 }
11915
11916 /**
11917 * Get the extension to engine bindings.
11918 *
11919 * @return array
11920 * @static
11921 */
11922 public static function getExtensions()
11923 {
11924 return \Illuminate\View\Factory::getExtensions();
11925 }
11926
11927 /**
11928 * Get the engine resolver instance.
11929 *
11930 * @return \Illuminate\View\Engines\EngineResolver
11931 * @static
11932 */
11933 public static function getEngineResolver()
11934 {
11935 return \Illuminate\View\Factory::getEngineResolver();
11936 }
11937
11938 /**
11939 * Get the view finder instance.
11940 *
11941 * @return \Illuminate\View\ViewFinderInterface
11942 * @static
11943 */
11944 public static function getFinder()
11945 {
11946 return \Illuminate\View\Factory::getFinder();
11947 }
11948
11949 /**
11950 * Set the view finder instance.
11951 *
11952 * @param \Illuminate\View\ViewFinderInterface $finder
11953 * @return void
11954 * @static
11955 */
11956 public static function setFinder($finder)
11957 {
11958 \Illuminate\View\Factory::setFinder($finder);
11959 }
11960
11961 /**
11962 * Flush the cache of views located by the finder.
11963 *
11964 * @return void
11965 * @static
11966 */
11967 public static function flushFinderCache()
11968 {
11969 \Illuminate\View\Factory::flushFinderCache();
11970 }
11971
11972 /**
11973 * Get the event dispatcher instance.
11974 *
11975 * @return \Illuminate\Contracts\Events\Dispatcher
11976 * @static
11977 */
11978 public static function getDispatcher()
11979 {
11980 return \Illuminate\View\Factory::getDispatcher();
11981 }
11982
11983 /**
11984 * Set the event dispatcher instance.
11985 *
11986 * @param \Illuminate\Contracts\Events\Dispatcher $events
11987 * @return void
11988 * @static
11989 */
11990 public static function setDispatcher($events)
11991 {
11992 \Illuminate\View\Factory::setDispatcher($events);
11993 }
11994
11995 /**
11996 * Get the IoC container instance.
11997 *
11998 * @return \Illuminate\Contracts\Container\Container
11999 * @static
12000 */
12001 public static function getContainer()
12002 {
12003 return \Illuminate\View\Factory::getContainer();
12004 }
12005
12006 /**
12007 * Set the IoC container instance.
12008 *
12009 * @param \Illuminate\Contracts\Container\Container $container
12010 * @return void
12011 * @static
12012 */
12013 public static function setContainer($container)
12014 {
12015 \Illuminate\View\Factory::setContainer($container);
12016 }
12017
12018 /**
12019 * Get an item from the shared data.
12020 *
12021 * @param string $key
12022 * @param mixed $default
12023 * @return mixed
12024 * @static
12025 */
12026 public static function shared($key, $default = null)
12027 {
12028 return \Illuminate\View\Factory::shared($key, $default);
12029 }
12030
12031 /**
12032 * Get all of the shared data for the environment.
12033 *
12034 * @return array
12035 * @static
12036 */
12037 public static function getShared()
12038 {
12039 return \Illuminate\View\Factory::getShared();
12040 }
12041
12042 /**
12043 * Start a component rendering process.
12044 *
12045 * @param string $name
12046 * @param array $data
12047 * @return void
12048 * @static
12049 */
12050 public static function startComponent($name, $data = array())
12051 {
12052 \Illuminate\View\Factory::startComponent($name, $data);
12053 }
12054
12055 /**
12056 * Render the current component.
12057 *
12058 * @return string
12059 * @static
12060 */
12061 public static function renderComponent()
12062 {
12063 return \Illuminate\View\Factory::renderComponent();
12064 }
12065
12066 /**
12067 * Start the slot rendering process.
12068 *
12069 * @param string $name
12070 * @param string|null $content
12071 * @return void
12072 * @static
12073 */
12074 public static function slot($name, $content = null)
12075 {
12076 \Illuminate\View\Factory::slot($name, $content);
12077 }
12078
12079 /**
12080 * Save the slot content for rendering.
12081 *
12082 * @return void
12083 * @static
12084 */
12085 public static function endSlot()
12086 {
12087 \Illuminate\View\Factory::endSlot();
12088 }
12089
12090 /**
12091 * Register a view creator event.
12092 *
12093 * @param array|string $views
12094 * @param \Closure|string $callback
12095 * @return array
12096 * @static
12097 */
12098 public static function creator($views, $callback)
12099 {
12100 return \Illuminate\View\Factory::creator($views, $callback);
12101 }
12102
12103 /**
12104 * Register multiple view composers via an array.
12105 *
12106 * @param array $composers
12107 * @return array
12108 * @static
12109 */
12110 public static function composers($composers)
12111 {
12112 return \Illuminate\View\Factory::composers($composers);
12113 }
12114
12115 /**
12116 * Register a view composer event.
12117 *
12118 * @param array|string $views
12119 * @param \Closure|string $callback
12120 * @return array
12121 * @static
12122 */
12123 public static function composer($views, $callback)
12124 {
12125 return \Illuminate\View\Factory::composer($views, $callback);
12126 }
12127
12128 /**
12129 * Call the composer for a given view.
12130 *
12131 * @param \Illuminate\Contracts\View\View $view
12132 * @return void
12133 * @static
12134 */
12135 public static function callComposer($view)
12136 {
12137 \Illuminate\View\Factory::callComposer($view);
12138 }
12139
12140 /**
12141 * Call the creator for a given view.
12142 *
12143 * @param \Illuminate\Contracts\View\View $view
12144 * @return void
12145 * @static
12146 */
12147 public static function callCreator($view)
12148 {
12149 \Illuminate\View\Factory::callCreator($view);
12150 }
12151
12152 /**
12153 * Start injecting content into a section.
12154 *
12155 * @param string $section
12156 * @param string|null $content
12157 * @return void
12158 * @static
12159 */
12160 public static function startSection($section, $content = null)
12161 {
12162 \Illuminate\View\Factory::startSection($section, $content);
12163 }
12164
12165 /**
12166 * Inject inline content into a section.
12167 *
12168 * @param string $section
12169 * @param string $content
12170 * @return void
12171 * @static
12172 */
12173 public static function inject($section, $content)
12174 {
12175 \Illuminate\View\Factory::inject($section, $content);
12176 }
12177
12178 /**
12179 * Stop injecting content into a section and return its contents.
12180 *
12181 * @return string
12182 * @static
12183 */
12184 public static function yieldSection()
12185 {
12186 return \Illuminate\View\Factory::yieldSection();
12187 }
12188
12189 /**
12190 * Stop injecting content into a section.
12191 *
12192 * @param bool $overwrite
12193 * @return string
12194 * @throws \InvalidArgumentException
12195 * @static
12196 */
12197 public static function stopSection($overwrite = false)
12198 {
12199 return \Illuminate\View\Factory::stopSection($overwrite);
12200 }
12201
12202 /**
12203 * Stop injecting content into a section and append it.
12204 *
12205 * @return string
12206 * @throws \InvalidArgumentException
12207 * @static
12208 */
12209 public static function appendSection()
12210 {
12211 return \Illuminate\View\Factory::appendSection();
12212 }
12213
12214 /**
12215 * Get the string contents of a section.
12216 *
12217 * @param string $section
12218 * @param string $default
12219 * @return string
12220 * @static
12221 */
12222 public static function yieldContent($section, $default = '')
12223 {
12224 return \Illuminate\View\Factory::yieldContent($section, $default);
12225 }
12226
12227 /**
12228 * Get the parent placeholder for the current request.
12229 *
12230 * @param string $section
12231 * @return string
12232 * @static
12233 */
12234 public static function parentPlaceholder($section = '')
12235 {
12236 return \Illuminate\View\Factory::parentPlaceholder($section);
12237 }
12238
12239 /**
12240 * Check if section exists.
12241 *
12242 * @param string $name
12243 * @return bool
12244 * @static
12245 */
12246 public static function hasSection($name)
12247 {
12248 return \Illuminate\View\Factory::hasSection($name);
12249 }
12250
12251 /**
12252 * Get the contents of a section.
12253 *
12254 * @param string $name
12255 * @param string $default
12256 * @return mixed
12257 * @static
12258 */
12259 public static function getSection($name, $default = null)
12260 {
12261 return \Illuminate\View\Factory::getSection($name, $default);
12262 }
12263
12264 /**
12265 * Get the entire array of sections.
12266 *
12267 * @return array
12268 * @static
12269 */
12270 public static function getSections()
12271 {
12272 return \Illuminate\View\Factory::getSections();
12273 }
12274
12275 /**
12276 * Flush all of the sections.
12277 *
12278 * @return void
12279 * @static
12280 */
12281 public static function flushSections()
12282 {
12283 \Illuminate\View\Factory::flushSections();
12284 }
12285
12286 /**
12287 * Add new loop to the stack.
12288 *
12289 * @param \Countable|array $data
12290 * @return void
12291 * @static
12292 */
12293 public static function addLoop($data)
12294 {
12295 \Illuminate\View\Factory::addLoop($data);
12296 }
12297
12298 /**
12299 * Increment the top loop's indices.
12300 *
12301 * @return void
12302 * @static
12303 */
12304 public static function incrementLoopIndices()
12305 {
12306 \Illuminate\View\Factory::incrementLoopIndices();
12307 }
12308
12309 /**
12310 * Pop a loop from the top of the loop stack.
12311 *
12312 * @return void
12313 * @static
12314 */
12315 public static function popLoop()
12316 {
12317 \Illuminate\View\Factory::popLoop();
12318 }
12319
12320 /**
12321 * Get an instance of the last loop in the stack.
12322 *
12323 * @return \stdClass|null
12324 * @static
12325 */
12326 public static function getLastLoop()
12327 {
12328 return \Illuminate\View\Factory::getLastLoop();
12329 }
12330
12331 /**
12332 * Get the entire loop stack.
12333 *
12334 * @return array
12335 * @static
12336 */
12337 public static function getLoopStack()
12338 {
12339 return \Illuminate\View\Factory::getLoopStack();
12340 }
12341
12342 /**
12343 * Start injecting content into a push section.
12344 *
12345 * @param string $section
12346 * @param string $content
12347 * @return void
12348 * @static
12349 */
12350 public static function startPush($section, $content = '')
12351 {
12352 \Illuminate\View\Factory::startPush($section, $content);
12353 }
12354
12355 /**
12356 * Stop injecting content into a push section.
12357 *
12358 * @return string
12359 * @throws \InvalidArgumentException
12360 * @static
12361 */
12362 public static function stopPush()
12363 {
12364 return \Illuminate\View\Factory::stopPush();
12365 }
12366
12367 /**
12368 * Start prepending content into a push section.
12369 *
12370 * @param string $section
12371 * @param string $content
12372 * @return void
12373 * @static
12374 */
12375 public static function startPrepend($section, $content = '')
12376 {
12377 \Illuminate\View\Factory::startPrepend($section, $content);
12378 }
12379
12380 /**
12381 * Stop prepending content into a push section.
12382 *
12383 * @return string
12384 * @throws \InvalidArgumentException
12385 * @static
12386 */
12387 public static function stopPrepend()
12388 {
12389 return \Illuminate\View\Factory::stopPrepend();
12390 }
12391
12392 /**
12393 * Get the string contents of a push section.
12394 *
12395 * @param string $section
12396 * @param string $default
12397 * @return string
12398 * @static
12399 */
12400 public static function yieldPushContent($section, $default = '')
12401 {
12402 return \Illuminate\View\Factory::yieldPushContent($section, $default);
12403 }
12404
12405 /**
12406 * Flush all of the stacks.
12407 *
12408 * @return void
12409 * @static
12410 */
12411 public static function flushStacks()
12412 {
12413 \Illuminate\View\Factory::flushStacks();
12414 }
12415
12416 /**
12417 * Start a translation block.
12418 *
12419 * @param array $replacements
12420 * @return void
12421 * @static
12422 */
12423 public static function startTranslation($replacements = array())
12424 {
12425 \Illuminate\View\Factory::startTranslation($replacements);
12426 }
12427
12428 /**
12429 * Render the current translation.
12430 *
12431 * @return string
12432 * @static
12433 */
12434 public static function renderTranslation()
12435 {
12436 return \Illuminate\View\Factory::renderTranslation();
12437 }
12438
12439 }
12440
12441}
12442
12443
12444namespace {
12445
12446 class App extends \Illuminate\Support\Facades\App {}
12447
12448 class Artisan extends \Illuminate\Support\Facades\Artisan {}
12449
12450 class Auth extends \Illuminate\Support\Facades\Auth {}
12451
12452 class Blade extends \Illuminate\Support\Facades\Blade {}
12453
12454 class Broadcast extends \Illuminate\Support\Facades\Broadcast {}
12455
12456 class Bus extends \Illuminate\Support\Facades\Bus {}
12457
12458 class Cache extends \Illuminate\Support\Facades\Cache {}
12459
12460 class Config extends \Illuminate\Support\Facades\Config {}
12461
12462 class Cookie extends \Illuminate\Support\Facades\Cookie {}
12463
12464 class Crypt extends \Illuminate\Support\Facades\Crypt {}
12465
12466 class DB extends \Illuminate\Support\Facades\DB {}
12467
12468 class Eloquent extends \Illuminate\Database\Eloquent\Model {
12469 /**
12470 * Create and return an un-saved model instance.
12471 *
12472 * @param array $attributes
12473 * @return \Illuminate\Database\Eloquent\Model
12474 * @static
12475 */
12476 public static function make($attributes = array())
12477 {
12478 return \Illuminate\Database\Eloquent\Builder::make($attributes);
12479 }
12480
12481 /**
12482 * Register a new global scope.
12483 *
12484 * @param string $identifier
12485 * @param \Illuminate\Database\Eloquent\Scope|\Closure $scope
12486 * @return $this
12487 * @static
12488 */
12489 public static function withGlobalScope($identifier, $scope)
12490 {
12491 return \Illuminate\Database\Eloquent\Builder::withGlobalScope($identifier, $scope);
12492 }
12493
12494 /**
12495 * Remove a registered global scope.
12496 *
12497 * @param \Illuminate\Database\Eloquent\Scope|string $scope
12498 * @return $this
12499 * @static
12500 */
12501 public static function withoutGlobalScope($scope)
12502 {
12503 return \Illuminate\Database\Eloquent\Builder::withoutGlobalScope($scope);
12504 }
12505
12506 /**
12507 * Remove all or passed registered global scopes.
12508 *
12509 * @param array|null $scopes
12510 * @return $this
12511 * @static
12512 */
12513 public static function withoutGlobalScopes($scopes = null)
12514 {
12515 return \Illuminate\Database\Eloquent\Builder::withoutGlobalScopes($scopes);
12516 }
12517
12518 /**
12519 * Get an array of global scopes that were removed from the query.
12520 *
12521 * @return array
12522 * @static
12523 */
12524 public static function removedScopes()
12525 {
12526 return \Illuminate\Database\Eloquent\Builder::removedScopes();
12527 }
12528
12529 /**
12530 * Add a where clause on the primary key to the query.
12531 *
12532 * @param mixed $id
12533 * @return $this
12534 * @static
12535 */
12536 public static function whereKey($id)
12537 {
12538 return \Illuminate\Database\Eloquent\Builder::whereKey($id);
12539 }
12540
12541 /**
12542 * Add a where clause on the primary key to the query.
12543 *
12544 * @param mixed $id
12545 * @return $this
12546 * @static
12547 */
12548 public static function whereKeyNot($id)
12549 {
12550 return \Illuminate\Database\Eloquent\Builder::whereKeyNot($id);
12551 }
12552
12553 /**
12554 * Add a basic where clause to the query.
12555 *
12556 * @param string|array|\Closure $column
12557 * @param string $operator
12558 * @param mixed $value
12559 * @param string $boolean
12560 * @return $this
12561 * @static
12562 */
12563 public static function where($column, $operator = null, $value = null, $boolean = 'and')
12564 {
12565 return \Illuminate\Database\Eloquent\Builder::where($column, $operator, $value, $boolean);
12566 }
12567
12568 /**
12569 * Add an "or where" clause to the query.
12570 *
12571 * @param \Closure|array|string $column
12572 * @param string $operator
12573 * @param mixed $value
12574 * @return \Illuminate\Database\Eloquent\Builder|static
12575 * @static
12576 */
12577 public static function orWhere($column, $operator = null, $value = null)
12578 {
12579 return \Illuminate\Database\Eloquent\Builder::orWhere($column, $operator, $value);
12580 }
12581
12582 /**
12583 * Create a collection of models from plain arrays.
12584 *
12585 * @param array $items
12586 * @return \Illuminate\Database\Eloquent\Collection
12587 * @static
12588 */
12589 public static function hydrate($items)
12590 {
12591 return \Illuminate\Database\Eloquent\Builder::hydrate($items);
12592 }
12593
12594 /**
12595 * Create a collection of models from a raw query.
12596 *
12597 * @param string $query
12598 * @param array $bindings
12599 * @return \Illuminate\Database\Eloquent\Collection
12600 * @static
12601 */
12602 public static function fromQuery($query, $bindings = array())
12603 {
12604 return \Illuminate\Database\Eloquent\Builder::fromQuery($query, $bindings);
12605 }
12606
12607 /**
12608 * Find a model by its primary key.
12609 *
12610 * @param mixed $id
12611 * @param array $columns
12612 * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static[]|static|null
12613 * @static
12614 */
12615 public static function find($id, $columns = array())
12616 {
12617 return \Illuminate\Database\Eloquent\Builder::find($id, $columns);
12618 }
12619
12620 /**
12621 * Find multiple models by their primary keys.
12622 *
12623 * @param \Illuminate\Contracts\Support\Arrayable|array $ids
12624 * @param array $columns
12625 * @return \Illuminate\Database\Eloquent\Collection
12626 * @static
12627 */
12628 public static function findMany($ids, $columns = array())
12629 {
12630 return \Illuminate\Database\Eloquent\Builder::findMany($ids, $columns);
12631 }
12632
12633 /**
12634 * Find a model by its primary key or throw an exception.
12635 *
12636 * @param mixed $id
12637 * @param array $columns
12638 * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection
12639 * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
12640 * @static
12641 */
12642 public static function findOrFail($id, $columns = array())
12643 {
12644 return \Illuminate\Database\Eloquent\Builder::findOrFail($id, $columns);
12645 }
12646
12647 /**
12648 * Find a model by its primary key or return fresh model instance.
12649 *
12650 * @param mixed $id
12651 * @param array $columns
12652 * @return \Illuminate\Database\Eloquent\Model
12653 * @static
12654 */
12655 public static function findOrNew($id, $columns = array())
12656 {
12657 return \Illuminate\Database\Eloquent\Builder::findOrNew($id, $columns);
12658 }
12659
12660 /**
12661 * Get the first record matching the attributes or instantiate it.
12662 *
12663 * @param array $attributes
12664 * @param array $values
12665 * @return \Illuminate\Database\Eloquent\Model
12666 * @static
12667 */
12668 public static function firstOrNew($attributes, $values = array())
12669 {
12670 return \Illuminate\Database\Eloquent\Builder::firstOrNew($attributes, $values);
12671 }
12672
12673 /**
12674 * Get the first record matching the attributes or create it.
12675 *
12676 * @param array $attributes
12677 * @param array $values
12678 * @return \Illuminate\Database\Eloquent\Model
12679 * @static
12680 */
12681 public static function firstOrCreate($attributes, $values = array())
12682 {
12683 return \Illuminate\Database\Eloquent\Builder::firstOrCreate($attributes, $values);
12684 }
12685
12686 /**
12687 * Create or update a record matching the attributes, and fill it with values.
12688 *
12689 * @param array $attributes
12690 * @param array $values
12691 * @return \Illuminate\Database\Eloquent\Model
12692 * @static
12693 */
12694 public static function updateOrCreate($attributes, $values = array())
12695 {
12696 return \Illuminate\Database\Eloquent\Builder::updateOrCreate($attributes, $values);
12697 }
12698
12699 /**
12700 * Execute the query and get the first result or throw an exception.
12701 *
12702 * @param array $columns
12703 * @return \Illuminate\Database\Eloquent\Model|static
12704 * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
12705 * @static
12706 */
12707 public static function firstOrFail($columns = array())
12708 {
12709 return \Illuminate\Database\Eloquent\Builder::firstOrFail($columns);
12710 }
12711
12712 /**
12713 * Execute the query and get the first result or call a callback.
12714 *
12715 * @param \Closure|array $columns
12716 * @param \Closure|null $callback
12717 * @return \Illuminate\Database\Eloquent\Model|static|mixed
12718 * @static
12719 */
12720 public static function firstOr($columns = array(), $callback = null)
12721 {
12722 return \Illuminate\Database\Eloquent\Builder::firstOr($columns, $callback);
12723 }
12724
12725 /**
12726 * Get a single column's value from the first result of a query.
12727 *
12728 * @param string $column
12729 * @return mixed
12730 * @static
12731 */
12732 public static function value($column)
12733 {
12734 return \Illuminate\Database\Eloquent\Builder::value($column);
12735 }
12736
12737 /**
12738 * Execute the query as a "select" statement.
12739 *
12740 * @param array $columns
12741 * @return \Illuminate\Database\Eloquent\Collection|static[]
12742 * @static
12743 */
12744 public static function get($columns = array())
12745 {
12746 return \Illuminate\Database\Eloquent\Builder::get($columns);
12747 }
12748
12749 /**
12750 * Get the hydrated models without eager loading.
12751 *
12752 * @param array $columns
12753 * @return \Illuminate\Database\Eloquent\Model[]
12754 * @static
12755 */
12756 public static function getModels($columns = array())
12757 {
12758 return \Illuminate\Database\Eloquent\Builder::getModels($columns);
12759 }
12760
12761 /**
12762 * Eager load the relationships for the models.
12763 *
12764 * @param array $models
12765 * @return array
12766 * @static
12767 */
12768 public static function eagerLoadRelations($models)
12769 {
12770 return \Illuminate\Database\Eloquent\Builder::eagerLoadRelations($models);
12771 }
12772
12773 /**
12774 * Get a generator for the given query.
12775 *
12776 * @return \Generator
12777 * @static
12778 */
12779 public static function cursor()
12780 {
12781 return \Illuminate\Database\Eloquent\Builder::cursor();
12782 }
12783
12784 /**
12785 * Chunk the results of a query by comparing numeric IDs.
12786 *
12787 * @param int $count
12788 * @param callable $callback
12789 * @param string $column
12790 * @param string|null $alias
12791 * @return bool
12792 * @static
12793 */
12794 public static function chunkById($count, $callback, $column = null, $alias = null)
12795 {
12796 return \Illuminate\Database\Eloquent\Builder::chunkById($count, $callback, $column, $alias);
12797 }
12798
12799 /**
12800 * Get an array with the values of a given column.
12801 *
12802 * @param string $column
12803 * @param string|null $key
12804 * @return \Illuminate\Support\Collection
12805 * @static
12806 */
12807 public static function pluck($column, $key = null)
12808 {
12809 return \Illuminate\Database\Eloquent\Builder::pluck($column, $key);
12810 }
12811
12812 /**
12813 * Paginate the given query.
12814 *
12815 * @param int $perPage
12816 * @param array $columns
12817 * @param string $pageName
12818 * @param int|null $page
12819 * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator
12820 * @throws \InvalidArgumentException
12821 * @static
12822 */
12823 public static function paginate($perPage = null, $columns = array(), $pageName = 'page', $page = null)
12824 {
12825 return \Illuminate\Database\Eloquent\Builder::paginate($perPage, $columns, $pageName, $page);
12826 }
12827
12828 /**
12829 * Paginate the given query into a simple paginator.
12830 *
12831 * @param int $perPage
12832 * @param array $columns
12833 * @param string $pageName
12834 * @param int|null $page
12835 * @return \Illuminate\Contracts\Pagination\Paginator
12836 * @static
12837 */
12838 public static function simplePaginate($perPage = null, $columns = array(), $pageName = 'page', $page = null)
12839 {
12840 return \Illuminate\Database\Eloquent\Builder::simplePaginate($perPage, $columns, $pageName, $page);
12841 }
12842
12843 /**
12844 * Save a new model and return the instance.
12845 *
12846 * @param array $attributes
12847 * @return \Illuminate\Database\Eloquent\Model|$this
12848 * @static
12849 */
12850 public static function create($attributes = array())
12851 {
12852 return \Illuminate\Database\Eloquent\Builder::create($attributes);
12853 }
12854
12855 /**
12856 * Save a new model and return the instance. Allow mass-assignment.
12857 *
12858 * @param array $attributes
12859 * @return \Illuminate\Database\Eloquent\Model|$this
12860 * @static
12861 */
12862 public static function forceCreate($attributes)
12863 {
12864 return \Illuminate\Database\Eloquent\Builder::forceCreate($attributes);
12865 }
12866
12867 /**
12868 * Register a replacement for the default delete function.
12869 *
12870 * @param \Closure $callback
12871 * @return void
12872 * @static
12873 */
12874 public static function onDelete($callback)
12875 {
12876 \Illuminate\Database\Eloquent\Builder::onDelete($callback);
12877 }
12878
12879 /**
12880 * Call the given local model scopes.
12881 *
12882 * @param array $scopes
12883 * @return mixed
12884 * @static
12885 */
12886 public static function scopes($scopes)
12887 {
12888 return \Illuminate\Database\Eloquent\Builder::scopes($scopes);
12889 }
12890
12891 /**
12892 * Apply the scopes to the Eloquent builder instance and return it.
12893 *
12894 * @return \Illuminate\Database\Eloquent\Builder|static
12895 * @static
12896 */
12897 public static function applyScopes()
12898 {
12899 return \Illuminate\Database\Eloquent\Builder::applyScopes();
12900 }
12901
12902 /**
12903 * Prevent the specified relations from being eager loaded.
12904 *
12905 * @param mixed $relations
12906 * @return $this
12907 * @static
12908 */
12909 public static function without($relations)
12910 {
12911 return \Illuminate\Database\Eloquent\Builder::without($relations);
12912 }
12913
12914 /**
12915 * Create a new instance of the model being queried.
12916 *
12917 * @param array $attributes
12918 * @return \Illuminate\Database\Eloquent\Model
12919 * @static
12920 */
12921 public static function newModelInstance($attributes = array())
12922 {
12923 return \Illuminate\Database\Eloquent\Builder::newModelInstance($attributes);
12924 }
12925
12926 /**
12927 * Get the underlying query builder instance.
12928 *
12929 * @return \Illuminate\Database\Query\Builder
12930 * @static
12931 */
12932 public static function getQuery()
12933 {
12934 return \Illuminate\Database\Eloquent\Builder::getQuery();
12935 }
12936
12937 /**
12938 * Set the underlying query builder instance.
12939 *
12940 * @param \Illuminate\Database\Query\Builder $query
12941 * @return $this
12942 * @static
12943 */
12944 public static function setQuery($query)
12945 {
12946 return \Illuminate\Database\Eloquent\Builder::setQuery($query);
12947 }
12948
12949 /**
12950 * Get a base query builder instance.
12951 *
12952 * @return \Illuminate\Database\Query\Builder
12953 * @static
12954 */
12955 public static function toBase()
12956 {
12957 return \Illuminate\Database\Eloquent\Builder::toBase();
12958 }
12959
12960 /**
12961 * Get the relationships being eagerly loaded.
12962 *
12963 * @return array
12964 * @static
12965 */
12966 public static function getEagerLoads()
12967 {
12968 return \Illuminate\Database\Eloquent\Builder::getEagerLoads();
12969 }
12970
12971 /**
12972 * Set the relationships being eagerly loaded.
12973 *
12974 * @param array $eagerLoad
12975 * @return $this
12976 * @static
12977 */
12978 public static function setEagerLoads($eagerLoad)
12979 {
12980 return \Illuminate\Database\Eloquent\Builder::setEagerLoads($eagerLoad);
12981 }
12982
12983 /**
12984 * Get the model instance being queried.
12985 *
12986 * @return \Illuminate\Database\Eloquent\Model
12987 * @static
12988 */
12989 public static function getModel()
12990 {
12991 return \Illuminate\Database\Eloquent\Builder::getModel();
12992 }
12993
12994 /**
12995 * Set a model instance for the model being queried.
12996 *
12997 * @param \Illuminate\Database\Eloquent\Model $model
12998 * @return $this
12999 * @static
13000 */
13001 public static function setModel($model)
13002 {
13003 return \Illuminate\Database\Eloquent\Builder::setModel($model);
13004 }
13005
13006 /**
13007 * Get the given macro by name.
13008 *
13009 * @param string $name
13010 * @return \Closure
13011 * @static
13012 */
13013 public static function getMacro($name)
13014 {
13015 return \Illuminate\Database\Eloquent\Builder::getMacro($name);
13016 }
13017
13018 /**
13019 * Chunk the results of the query.
13020 *
13021 * @param int $count
13022 * @param callable $callback
13023 * @return bool
13024 * @static
13025 */
13026 public static function chunk($count, $callback)
13027 {
13028 return \Illuminate\Database\Eloquent\Builder::chunk($count, $callback);
13029 }
13030
13031 /**
13032 * Execute a callback over each item while chunking.
13033 *
13034 * @param callable $callback
13035 * @param int $count
13036 * @return bool
13037 * @static
13038 */
13039 public static function each($callback, $count = 1000)
13040 {
13041 return \Illuminate\Database\Eloquent\Builder::each($callback, $count);
13042 }
13043
13044 /**
13045 * Execute the query and get the first result.
13046 *
13047 * @param array $columns
13048 * @return \Illuminate\Database\Eloquent\Model|object|static|null
13049 * @static
13050 */
13051 public static function first($columns = array())
13052 {
13053 return \Illuminate\Database\Eloquent\Builder::first($columns);
13054 }
13055
13056 /**
13057 * Apply the callback's query changes if the given "value" is true.
13058 *
13059 * @param mixed $value
13060 * @param callable $callback
13061 * @param callable $default
13062 * @return mixed
13063 * @static
13064 */
13065 public static function when($value, $callback, $default = null)
13066 {
13067 return \Illuminate\Database\Eloquent\Builder::when($value, $callback, $default);
13068 }
13069
13070 /**
13071 * Pass the query to a given callback.
13072 *
13073 * @param \Closure $callback
13074 * @return \Illuminate\Database\Query\Builder
13075 * @static
13076 */
13077 public static function tap($callback)
13078 {
13079 return \Illuminate\Database\Eloquent\Builder::tap($callback);
13080 }
13081
13082 /**
13083 * Apply the callback's query changes if the given "value" is false.
13084 *
13085 * @param mixed $value
13086 * @param callable $callback
13087 * @param callable $default
13088 * @return mixed
13089 * @static
13090 */
13091 public static function unless($value, $callback, $default = null)
13092 {
13093 return \Illuminate\Database\Eloquent\Builder::unless($value, $callback, $default);
13094 }
13095
13096 /**
13097 * Add a relationship count / exists condition to the query.
13098 *
13099 * @param string $relation
13100 * @param string $operator
13101 * @param int $count
13102 * @param string $boolean
13103 * @param \Closure|null $callback
13104 * @return \Illuminate\Database\Eloquent\Builder|static
13105 * @static
13106 */
13107 public static function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
13108 {
13109 return \Illuminate\Database\Eloquent\Builder::has($relation, $operator, $count, $boolean, $callback);
13110 }
13111
13112 /**
13113 * Add a relationship count / exists condition to the query with an "or".
13114 *
13115 * @param string $relation
13116 * @param string $operator
13117 * @param int $count
13118 * @return \Illuminate\Database\Eloquent\Builder|static
13119 * @static
13120 */
13121 public static function orHas($relation, $operator = '>=', $count = 1)
13122 {
13123 return \Illuminate\Database\Eloquent\Builder::orHas($relation, $operator, $count);
13124 }
13125
13126 /**
13127 * Add a relationship count / exists condition to the query.
13128 *
13129 * @param string $relation
13130 * @param string $boolean
13131 * @param \Closure|null $callback
13132 * @return \Illuminate\Database\Eloquent\Builder|static
13133 * @static
13134 */
13135 public static function doesntHave($relation, $boolean = 'and', $callback = null)
13136 {
13137 return \Illuminate\Database\Eloquent\Builder::doesntHave($relation, $boolean, $callback);
13138 }
13139
13140 /**
13141 * Add a relationship count / exists condition to the query with an "or".
13142 *
13143 * @param string $relation
13144 * @return \Illuminate\Database\Eloquent\Builder|static
13145 * @static
13146 */
13147 public static function orDoesntHave($relation)
13148 {
13149 return \Illuminate\Database\Eloquent\Builder::orDoesntHave($relation);
13150 }
13151
13152 /**
13153 * Add a relationship count / exists condition to the query with where clauses.
13154 *
13155 * @param string $relation
13156 * @param \Closure|null $callback
13157 * @param string $operator
13158 * @param int $count
13159 * @return \Illuminate\Database\Eloquent\Builder|static
13160 * @static
13161 */
13162 public static function whereHas($relation, $callback = null, $operator = '>=', $count = 1)
13163 {
13164 return \Illuminate\Database\Eloquent\Builder::whereHas($relation, $callback, $operator, $count);
13165 }
13166
13167 /**
13168 * Add a relationship count / exists condition to the query with where clauses and an "or".
13169 *
13170 * @param string $relation
13171 * @param \Closure $callback
13172 * @param string $operator
13173 * @param int $count
13174 * @return \Illuminate\Database\Eloquent\Builder|static
13175 * @static
13176 */
13177 public static function orWhereHas($relation, $callback = null, $operator = '>=', $count = 1)
13178 {
13179 return \Illuminate\Database\Eloquent\Builder::orWhereHas($relation, $callback, $operator, $count);
13180 }
13181
13182 /**
13183 * Add a relationship count / exists condition to the query with where clauses.
13184 *
13185 * @param string $relation
13186 * @param \Closure|null $callback
13187 * @return \Illuminate\Database\Eloquent\Builder|static
13188 * @static
13189 */
13190 public static function whereDoesntHave($relation, $callback = null)
13191 {
13192 return \Illuminate\Database\Eloquent\Builder::whereDoesntHave($relation, $callback);
13193 }
13194
13195 /**
13196 * Add a relationship count / exists condition to the query with where clauses and an "or".
13197 *
13198 * @param string $relation
13199 * @param \Closure $callback
13200 * @return \Illuminate\Database\Eloquent\Builder|static
13201 * @static
13202 */
13203 public static function orWhereDoesntHave($relation, $callback = null)
13204 {
13205 return \Illuminate\Database\Eloquent\Builder::orWhereDoesntHave($relation, $callback);
13206 }
13207
13208 /**
13209 * Add subselect queries to count the relations.
13210 *
13211 * @param mixed $relations
13212 * @return $this
13213 * @static
13214 */
13215 public static function withCount($relations)
13216 {
13217 return \Illuminate\Database\Eloquent\Builder::withCount($relations);
13218 }
13219
13220 /**
13221 * Merge the where constraints from another query to the current query.
13222 *
13223 * @param \Illuminate\Database\Eloquent\Builder $from
13224 * @return \Illuminate\Database\Eloquent\Builder|static
13225 * @static
13226 */
13227 public static function mergeConstraintsFrom($from)
13228 {
13229 return \Illuminate\Database\Eloquent\Builder::mergeConstraintsFrom($from);
13230 }
13231
13232 /**
13233 * Set the columns to be selected.
13234 *
13235 * @param array|mixed $columns
13236 * @return $this
13237 * @static
13238 */
13239 public static function select($columns = array())
13240 {
13241 return \Illuminate\Database\Query\Builder::select($columns);
13242 }
13243
13244 /**
13245 * Add a subselect expression to the query.
13246 *
13247 * @param \Closure|\Illuminate\Database\Query\Builder|string $query
13248 * @param string $as
13249 * @return \Illuminate\Database\Query\Builder|static
13250 * @throws \InvalidArgumentException
13251 * @static
13252 */
13253 public static function selectSub($query, $as)
13254 {
13255 return \Illuminate\Database\Query\Builder::selectSub($query, $as);
13256 }
13257
13258 /**
13259 * Add a new "raw" select expression to the query.
13260 *
13261 * @param string $expression
13262 * @param array $bindings
13263 * @return \Illuminate\Database\Query\Builder|static
13264 * @static
13265 */
13266 public static function selectRaw($expression, $bindings = array())
13267 {
13268 return \Illuminate\Database\Query\Builder::selectRaw($expression, $bindings);
13269 }
13270
13271 /**
13272 * Makes "from" fetch from a subquery.
13273 *
13274 * @param \Closure|\Illuminate\Database\Query\Builder|string $query
13275 * @param string $as
13276 * @return \Illuminate\Database\Query\Builder|static
13277 * @throws \InvalidArgumentException
13278 * @static
13279 */
13280 public static function fromSub($query, $as)
13281 {
13282 return \Illuminate\Database\Query\Builder::fromSub($query, $as);
13283 }
13284
13285 /**
13286 * Add a raw from clause to the query.
13287 *
13288 * @param string $expression
13289 * @param mixed $bindings
13290 * @return \Illuminate\Database\Query\Builder|static
13291 * @static
13292 */
13293 public static function fromRaw($expression, $bindings = array())
13294 {
13295 return \Illuminate\Database\Query\Builder::fromRaw($expression, $bindings);
13296 }
13297
13298 /**
13299 * Add a new select column to the query.
13300 *
13301 * @param array|mixed $column
13302 * @return $this
13303 * @static
13304 */
13305 public static function addSelect($column)
13306 {
13307 return \Illuminate\Database\Query\Builder::addSelect($column);
13308 }
13309
13310 /**
13311 * Force the query to only return distinct results.
13312 *
13313 * @return $this
13314 * @static
13315 */
13316 public static function distinct()
13317 {
13318 return \Illuminate\Database\Query\Builder::distinct();
13319 }
13320
13321 /**
13322 * Set the table which the query is targeting.
13323 *
13324 * @param string $table
13325 * @return $this
13326 * @static
13327 */
13328 public static function from($table)
13329 {
13330 return \Illuminate\Database\Query\Builder::from($table);
13331 }
13332
13333 /**
13334 * Add a join clause to the query.
13335 *
13336 * @param string $table
13337 * @param string $first
13338 * @param string|null $operator
13339 * @param string|null $second
13340 * @param string $type
13341 * @param bool $where
13342 * @return $this
13343 * @static
13344 */
13345 public static function join($table, $first, $operator = null, $second = null, $type = 'inner', $where = false)
13346 {
13347 return \Illuminate\Database\Query\Builder::join($table, $first, $operator, $second, $type, $where);
13348 }
13349
13350 /**
13351 * Add a "join where" clause to the query.
13352 *
13353 * @param string $table
13354 * @param string $first
13355 * @param string $operator
13356 * @param string $second
13357 * @param string $type
13358 * @return \Illuminate\Database\Query\Builder|static
13359 * @static
13360 */
13361 public static function joinWhere($table, $first, $operator, $second, $type = 'inner')
13362 {
13363 return \Illuminate\Database\Query\Builder::joinWhere($table, $first, $operator, $second, $type);
13364 }
13365
13366 /**
13367 * Add a subquery join clause to the query.
13368 *
13369 * @param \Closure|\Illuminate\Database\Query\Builder|string $query
13370 * @param string $as
13371 * @param string $first
13372 * @param string|null $operator
13373 * @param string|null $second
13374 * @param string $type
13375 * @param bool $where
13376 * @return \Illuminate\Database\Query\Builder|static
13377 * @throws \InvalidArgumentException
13378 * @static
13379 */
13380 public static function joinSub($query, $as, $first, $operator = null, $second = null, $type = 'inner', $where = false)
13381 {
13382 return \Illuminate\Database\Query\Builder::joinSub($query, $as, $first, $operator, $second, $type, $where);
13383 }
13384
13385 /**
13386 * Add a left join to the query.
13387 *
13388 * @param string $table
13389 * @param string $first
13390 * @param string|null $operator
13391 * @param string|null $second
13392 * @return \Illuminate\Database\Query\Builder|static
13393 * @static
13394 */
13395 public static function leftJoin($table, $first, $operator = null, $second = null)
13396 {
13397 return \Illuminate\Database\Query\Builder::leftJoin($table, $first, $operator, $second);
13398 }
13399
13400 /**
13401 * Add a "join where" clause to the query.
13402 *
13403 * @param string $table
13404 * @param string $first
13405 * @param string $operator
13406 * @param string $second
13407 * @return \Illuminate\Database\Query\Builder|static
13408 * @static
13409 */
13410 public static function leftJoinWhere($table, $first, $operator, $second)
13411 {
13412 return \Illuminate\Database\Query\Builder::leftJoinWhere($table, $first, $operator, $second);
13413 }
13414
13415 /**
13416 * Add a subquery left join to the query.
13417 *
13418 * @param \Closure|\Illuminate\Database\Query\Builder|string $query
13419 * @param string $as
13420 * @param string $first
13421 * @param string|null $operator
13422 * @param string|null $second
13423 * @return \Illuminate\Database\Query\Builder|static
13424 * @static
13425 */
13426 public static function leftJoinSub($query, $as, $first, $operator = null, $second = null)
13427 {
13428 return \Illuminate\Database\Query\Builder::leftJoinSub($query, $as, $first, $operator, $second);
13429 }
13430
13431 /**
13432 * Add a right join to the query.
13433 *
13434 * @param string $table
13435 * @param string $first
13436 * @param string|null $operator
13437 * @param string|null $second
13438 * @return \Illuminate\Database\Query\Builder|static
13439 * @static
13440 */
13441 public static function rightJoin($table, $first, $operator = null, $second = null)
13442 {
13443 return \Illuminate\Database\Query\Builder::rightJoin($table, $first, $operator, $second);
13444 }
13445
13446 /**
13447 * Add a "right join where" clause to the query.
13448 *
13449 * @param string $table
13450 * @param string $first
13451 * @param string $operator
13452 * @param string $second
13453 * @return \Illuminate\Database\Query\Builder|static
13454 * @static
13455 */
13456 public static function rightJoinWhere($table, $first, $operator, $second)
13457 {
13458 return \Illuminate\Database\Query\Builder::rightJoinWhere($table, $first, $operator, $second);
13459 }
13460
13461 /**
13462 * Add a subquery right join to the query.
13463 *
13464 * @param \Closure|\Illuminate\Database\Query\Builder|string $query
13465 * @param string $as
13466 * @param string $first
13467 * @param string|null $operator
13468 * @param string|null $second
13469 * @return \Illuminate\Database\Query\Builder|static
13470 * @static
13471 */
13472 public static function rightJoinSub($query, $as, $first, $operator = null, $second = null)
13473 {
13474 return \Illuminate\Database\Query\Builder::rightJoinSub($query, $as, $first, $operator, $second);
13475 }
13476
13477 /**
13478 * Add a "cross join" clause to the query.
13479 *
13480 * @param string $table
13481 * @param string|null $first
13482 * @param string|null $operator
13483 * @param string|null $second
13484 * @return \Illuminate\Database\Query\Builder|static
13485 * @static
13486 */
13487 public static function crossJoin($table, $first = null, $operator = null, $second = null)
13488 {
13489 return \Illuminate\Database\Query\Builder::crossJoin($table, $first, $operator, $second);
13490 }
13491
13492 /**
13493 * Merge an array of where clauses and bindings.
13494 *
13495 * @param array $wheres
13496 * @param array $bindings
13497 * @return void
13498 * @static
13499 */
13500 public static function mergeWheres($wheres, $bindings)
13501 {
13502 \Illuminate\Database\Query\Builder::mergeWheres($wheres, $bindings);
13503 }
13504
13505 /**
13506 * Prepare the value and operator for a where clause.
13507 *
13508 * @param string $value
13509 * @param string $operator
13510 * @param bool $useDefault
13511 * @return array
13512 * @throws \InvalidArgumentException
13513 * @static
13514 */
13515 public static function prepareValueAndOperator($value, $operator, $useDefault = false)
13516 {
13517 return \Illuminate\Database\Query\Builder::prepareValueAndOperator($value, $operator, $useDefault);
13518 }
13519
13520 /**
13521 * Add a "where" clause comparing two columns to the query.
13522 *
13523 * @param string|array $first
13524 * @param string|null $operator
13525 * @param string|null $second
13526 * @param string|null $boolean
13527 * @return \Illuminate\Database\Query\Builder|static
13528 * @static
13529 */
13530 public static function whereColumn($first, $operator = null, $second = null, $boolean = 'and')
13531 {
13532 return \Illuminate\Database\Query\Builder::whereColumn($first, $operator, $second, $boolean);
13533 }
13534
13535 /**
13536 * Add an "or where" clause comparing two columns to the query.
13537 *
13538 * @param string|array $first
13539 * @param string|null $operator
13540 * @param string|null $second
13541 * @return \Illuminate\Database\Query\Builder|static
13542 * @static
13543 */
13544 public static function orWhereColumn($first, $operator = null, $second = null)
13545 {
13546 return \Illuminate\Database\Query\Builder::orWhereColumn($first, $operator, $second);
13547 }
13548
13549 /**
13550 * Add a raw where clause to the query.
13551 *
13552 * @param string $sql
13553 * @param mixed $bindings
13554 * @param string $boolean
13555 * @return $this
13556 * @static
13557 */
13558 public static function whereRaw($sql, $bindings = array(), $boolean = 'and')
13559 {
13560 return \Illuminate\Database\Query\Builder::whereRaw($sql, $bindings, $boolean);
13561 }
13562
13563 /**
13564 * Add a raw or where clause to the query.
13565 *
13566 * @param string $sql
13567 * @param mixed $bindings
13568 * @return \Illuminate\Database\Query\Builder|static
13569 * @static
13570 */
13571 public static function orWhereRaw($sql, $bindings = array())
13572 {
13573 return \Illuminate\Database\Query\Builder::orWhereRaw($sql, $bindings);
13574 }
13575
13576 /**
13577 * Add a "where in" clause to the query.
13578 *
13579 * @param string $column
13580 * @param mixed $values
13581 * @param string $boolean
13582 * @param bool $not
13583 * @return $this
13584 * @static
13585 */
13586 public static function whereIn($column, $values, $boolean = 'and', $not = false)
13587 {
13588 return \Illuminate\Database\Query\Builder::whereIn($column, $values, $boolean, $not);
13589 }
13590
13591 /**
13592 * Add an "or where in" clause to the query.
13593 *
13594 * @param string $column
13595 * @param mixed $values
13596 * @return \Illuminate\Database\Query\Builder|static
13597 * @static
13598 */
13599 public static function orWhereIn($column, $values)
13600 {
13601 return \Illuminate\Database\Query\Builder::orWhereIn($column, $values);
13602 }
13603
13604 /**
13605 * Add a "where not in" clause to the query.
13606 *
13607 * @param string $column
13608 * @param mixed $values
13609 * @param string $boolean
13610 * @return \Illuminate\Database\Query\Builder|static
13611 * @static
13612 */
13613 public static function whereNotIn($column, $values, $boolean = 'and')
13614 {
13615 return \Illuminate\Database\Query\Builder::whereNotIn($column, $values, $boolean);
13616 }
13617
13618 /**
13619 * Add an "or where not in" clause to the query.
13620 *
13621 * @param string $column
13622 * @param mixed $values
13623 * @return \Illuminate\Database\Query\Builder|static
13624 * @static
13625 */
13626 public static function orWhereNotIn($column, $values)
13627 {
13628 return \Illuminate\Database\Query\Builder::orWhereNotIn($column, $values);
13629 }
13630
13631 /**
13632 * Add a "where null" clause to the query.
13633 *
13634 * @param string $column
13635 * @param string $boolean
13636 * @param bool $not
13637 * @return $this
13638 * @static
13639 */
13640 public static function whereNull($column, $boolean = 'and', $not = false)
13641 {
13642 return \Illuminate\Database\Query\Builder::whereNull($column, $boolean, $not);
13643 }
13644
13645 /**
13646 * Add an "or where null" clause to the query.
13647 *
13648 * @param string $column
13649 * @return \Illuminate\Database\Query\Builder|static
13650 * @static
13651 */
13652 public static function orWhereNull($column)
13653 {
13654 return \Illuminate\Database\Query\Builder::orWhereNull($column);
13655 }
13656
13657 /**
13658 * Add a "where not null" clause to the query.
13659 *
13660 * @param string $column
13661 * @param string $boolean
13662 * @return \Illuminate\Database\Query\Builder|static
13663 * @static
13664 */
13665 public static function whereNotNull($column, $boolean = 'and')
13666 {
13667 return \Illuminate\Database\Query\Builder::whereNotNull($column, $boolean);
13668 }
13669
13670 /**
13671 * Add a where between statement to the query.
13672 *
13673 * @param string $column
13674 * @param array $values
13675 * @param string $boolean
13676 * @param bool $not
13677 * @return $this
13678 * @static
13679 */
13680 public static function whereBetween($column, $values, $boolean = 'and', $not = false)
13681 {
13682 return \Illuminate\Database\Query\Builder::whereBetween($column, $values, $boolean, $not);
13683 }
13684
13685 /**
13686 * Add an or where between statement to the query.
13687 *
13688 * @param string $column
13689 * @param array $values
13690 * @return \Illuminate\Database\Query\Builder|static
13691 * @static
13692 */
13693 public static function orWhereBetween($column, $values)
13694 {
13695 return \Illuminate\Database\Query\Builder::orWhereBetween($column, $values);
13696 }
13697
13698 /**
13699 * Add a where not between statement to the query.
13700 *
13701 * @param string $column
13702 * @param array $values
13703 * @param string $boolean
13704 * @return \Illuminate\Database\Query\Builder|static
13705 * @static
13706 */
13707 public static function whereNotBetween($column, $values, $boolean = 'and')
13708 {
13709 return \Illuminate\Database\Query\Builder::whereNotBetween($column, $values, $boolean);
13710 }
13711
13712 /**
13713 * Add an or where not between statement to the query.
13714 *
13715 * @param string $column
13716 * @param array $values
13717 * @return \Illuminate\Database\Query\Builder|static
13718 * @static
13719 */
13720 public static function orWhereNotBetween($column, $values)
13721 {
13722 return \Illuminate\Database\Query\Builder::orWhereNotBetween($column, $values);
13723 }
13724
13725 /**
13726 * Add an "or where not null" clause to the query.
13727 *
13728 * @param string $column
13729 * @return \Illuminate\Database\Query\Builder|static
13730 * @static
13731 */
13732 public static function orWhereNotNull($column)
13733 {
13734 return \Illuminate\Database\Query\Builder::orWhereNotNull($column);
13735 }
13736
13737 /**
13738 * Add a "where date" statement to the query.
13739 *
13740 * @param string $column
13741 * @param string $operator
13742 * @param mixed $value
13743 * @param string $boolean
13744 * @return \Illuminate\Database\Query\Builder|static
13745 * @static
13746 */
13747 public static function whereDate($column, $operator, $value = null, $boolean = 'and')
13748 {
13749 return \Illuminate\Database\Query\Builder::whereDate($column, $operator, $value, $boolean);
13750 }
13751
13752 /**
13753 * Add an "or where date" statement to the query.
13754 *
13755 * @param string $column
13756 * @param string $operator
13757 * @param string $value
13758 * @return \Illuminate\Database\Query\Builder|static
13759 * @static
13760 */
13761 public static function orWhereDate($column, $operator, $value)
13762 {
13763 return \Illuminate\Database\Query\Builder::orWhereDate($column, $operator, $value);
13764 }
13765
13766 /**
13767 * Add a "where time" statement to the query.
13768 *
13769 * @param string $column
13770 * @param string $operator
13771 * @param mixed $value
13772 * @param string $boolean
13773 * @return \Illuminate\Database\Query\Builder|static
13774 * @static
13775 */
13776 public static function whereTime($column, $operator, $value = null, $boolean = 'and')
13777 {
13778 return \Illuminate\Database\Query\Builder::whereTime($column, $operator, $value, $boolean);
13779 }
13780
13781 /**
13782 * Add an "or where time" statement to the query.
13783 *
13784 * @param string $column
13785 * @param string $operator
13786 * @param mixed $value
13787 * @return \Illuminate\Database\Query\Builder|static
13788 * @static
13789 */
13790 public static function orWhereTime($column, $operator, $value = null)
13791 {
13792 return \Illuminate\Database\Query\Builder::orWhereTime($column, $operator, $value);
13793 }
13794
13795 /**
13796 * Add a "where day" statement to the query.
13797 *
13798 * @param string $column
13799 * @param string $operator
13800 * @param mixed $value
13801 * @param string $boolean
13802 * @return \Illuminate\Database\Query\Builder|static
13803 * @static
13804 */
13805 public static function whereDay($column, $operator, $value = null, $boolean = 'and')
13806 {
13807 return \Illuminate\Database\Query\Builder::whereDay($column, $operator, $value, $boolean);
13808 }
13809
13810 /**
13811 * Add an "or where day" statement to the query.
13812 *
13813 * @param string $column
13814 * @param string $operator
13815 * @param mixed $value
13816 * @return \Illuminate\Database\Query\Builder|static
13817 * @static
13818 */
13819 public static function orWhereDay($column, $operator, $value = null)
13820 {
13821 return \Illuminate\Database\Query\Builder::orWhereDay($column, $operator, $value);
13822 }
13823
13824 /**
13825 * Add a "where month" statement to the query.
13826 *
13827 * @param string $column
13828 * @param string $operator
13829 * @param mixed $value
13830 * @param string $boolean
13831 * @return \Illuminate\Database\Query\Builder|static
13832 * @static
13833 */
13834 public static function whereMonth($column, $operator, $value = null, $boolean = 'and')
13835 {
13836 return \Illuminate\Database\Query\Builder::whereMonth($column, $operator, $value, $boolean);
13837 }
13838
13839 /**
13840 * Add an "or where month" statement to the query.
13841 *
13842 * @param string $column
13843 * @param string $operator
13844 * @param mixed $value
13845 * @return \Illuminate\Database\Query\Builder|static
13846 * @static
13847 */
13848 public static function orWhereMonth($column, $operator, $value = null)
13849 {
13850 return \Illuminate\Database\Query\Builder::orWhereMonth($column, $operator, $value);
13851 }
13852
13853 /**
13854 * Add a "where year" statement to the query.
13855 *
13856 * @param string $column
13857 * @param string $operator
13858 * @param mixed $value
13859 * @param string $boolean
13860 * @return \Illuminate\Database\Query\Builder|static
13861 * @static
13862 */
13863 public static function whereYear($column, $operator, $value = null, $boolean = 'and')
13864 {
13865 return \Illuminate\Database\Query\Builder::whereYear($column, $operator, $value, $boolean);
13866 }
13867
13868 /**
13869 * Add an "or where year" statement to the query.
13870 *
13871 * @param string $column
13872 * @param string $operator
13873 * @param mixed $value
13874 * @return \Illuminate\Database\Query\Builder|static
13875 * @static
13876 */
13877 public static function orWhereYear($column, $operator, $value = null)
13878 {
13879 return \Illuminate\Database\Query\Builder::orWhereYear($column, $operator, $value);
13880 }
13881
13882 /**
13883 * Add a nested where statement to the query.
13884 *
13885 * @param \Closure $callback
13886 * @param string $boolean
13887 * @return \Illuminate\Database\Query\Builder|static
13888 * @static
13889 */
13890 public static function whereNested($callback, $boolean = 'and')
13891 {
13892 return \Illuminate\Database\Query\Builder::whereNested($callback, $boolean);
13893 }
13894
13895 /**
13896 * Create a new query instance for nested where condition.
13897 *
13898 * @return \Illuminate\Database\Query\Builder
13899 * @static
13900 */
13901 public static function forNestedWhere()
13902 {
13903 return \Illuminate\Database\Query\Builder::forNestedWhere();
13904 }
13905
13906 /**
13907 * Add another query builder as a nested where to the query builder.
13908 *
13909 * @param \Illuminate\Database\Query\Builder|static $query
13910 * @param string $boolean
13911 * @return $this
13912 * @static
13913 */
13914 public static function addNestedWhereQuery($query, $boolean = 'and')
13915 {
13916 return \Illuminate\Database\Query\Builder::addNestedWhereQuery($query, $boolean);
13917 }
13918
13919 /**
13920 * Add an exists clause to the query.
13921 *
13922 * @param \Closure $callback
13923 * @param string $boolean
13924 * @param bool $not
13925 * @return $this
13926 * @static
13927 */
13928 public static function whereExists($callback, $boolean = 'and', $not = false)
13929 {
13930 return \Illuminate\Database\Query\Builder::whereExists($callback, $boolean, $not);
13931 }
13932
13933 /**
13934 * Add an or exists clause to the query.
13935 *
13936 * @param \Closure $callback
13937 * @param bool $not
13938 * @return \Illuminate\Database\Query\Builder|static
13939 * @static
13940 */
13941 public static function orWhereExists($callback, $not = false)
13942 {
13943 return \Illuminate\Database\Query\Builder::orWhereExists($callback, $not);
13944 }
13945
13946 /**
13947 * Add a where not exists clause to the query.
13948 *
13949 * @param \Closure $callback
13950 * @param string $boolean
13951 * @return \Illuminate\Database\Query\Builder|static
13952 * @static
13953 */
13954 public static function whereNotExists($callback, $boolean = 'and')
13955 {
13956 return \Illuminate\Database\Query\Builder::whereNotExists($callback, $boolean);
13957 }
13958
13959 /**
13960 * Add a where not exists clause to the query.
13961 *
13962 * @param \Closure $callback
13963 * @return \Illuminate\Database\Query\Builder|static
13964 * @static
13965 */
13966 public static function orWhereNotExists($callback)
13967 {
13968 return \Illuminate\Database\Query\Builder::orWhereNotExists($callback);
13969 }
13970
13971 /**
13972 * Add an exists clause to the query.
13973 *
13974 * @param \Illuminate\Database\Query\Builder $query
13975 * @param string $boolean
13976 * @param bool $not
13977 * @return $this
13978 * @static
13979 */
13980 public static function addWhereExistsQuery($query, $boolean = 'and', $not = false)
13981 {
13982 return \Illuminate\Database\Query\Builder::addWhereExistsQuery($query, $boolean, $not);
13983 }
13984
13985 /**
13986 * Adds a where condition using row values.
13987 *
13988 * @param array $columns
13989 * @param string $operator
13990 * @param array $values
13991 * @param string $boolean
13992 * @return $this
13993 * @static
13994 */
13995 public static function whereRowValues($columns, $operator, $values, $boolean = 'and')
13996 {
13997 return \Illuminate\Database\Query\Builder::whereRowValues($columns, $operator, $values, $boolean);
13998 }
13999
14000 /**
14001 * Adds a or where condition using row values.
14002 *
14003 * @param array $columns
14004 * @param string $operator
14005 * @param array $values
14006 * @return $this
14007 * @static
14008 */
14009 public static function orWhereRowValues($columns, $operator, $values)
14010 {
14011 return \Illuminate\Database\Query\Builder::orWhereRowValues($columns, $operator, $values);
14012 }
14013
14014 /**
14015 * Handles dynamic "where" clauses to the query.
14016 *
14017 * @param string $method
14018 * @param string $parameters
14019 * @return $this
14020 * @static
14021 */
14022 public static function dynamicWhere($method, $parameters)
14023 {
14024 return \Illuminate\Database\Query\Builder::dynamicWhere($method, $parameters);
14025 }
14026
14027 /**
14028 * Add a "group by" clause to the query.
14029 *
14030 * @param array $groups
14031 * @return $this
14032 * @static
14033 */
14034 public static function groupBy($groups = null)
14035 {
14036 return \Illuminate\Database\Query\Builder::groupBy($groups);
14037 }
14038
14039 /**
14040 * Add a "having" clause to the query.
14041 *
14042 * @param string $column
14043 * @param string|null $operator
14044 * @param string|null $value
14045 * @param string $boolean
14046 * @return $this
14047 * @static
14048 */
14049 public static function having($column, $operator = null, $value = null, $boolean = 'and')
14050 {
14051 return \Illuminate\Database\Query\Builder::having($column, $operator, $value, $boolean);
14052 }
14053
14054 /**
14055 * Add a "or having" clause to the query.
14056 *
14057 * @param string $column
14058 * @param string|null $operator
14059 * @param string|null $value
14060 * @return \Illuminate\Database\Query\Builder|static
14061 * @static
14062 */
14063 public static function orHaving($column, $operator = null, $value = null)
14064 {
14065 return \Illuminate\Database\Query\Builder::orHaving($column, $operator, $value);
14066 }
14067
14068 /**
14069 * Add a raw having clause to the query.
14070 *
14071 * @param string $sql
14072 * @param array $bindings
14073 * @param string $boolean
14074 * @return $this
14075 * @static
14076 */
14077 public static function havingRaw($sql, $bindings = array(), $boolean = 'and')
14078 {
14079 return \Illuminate\Database\Query\Builder::havingRaw($sql, $bindings, $boolean);
14080 }
14081
14082 /**
14083 * Add a raw or having clause to the query.
14084 *
14085 * @param string $sql
14086 * @param array $bindings
14087 * @return \Illuminate\Database\Query\Builder|static
14088 * @static
14089 */
14090 public static function orHavingRaw($sql, $bindings = array())
14091 {
14092 return \Illuminate\Database\Query\Builder::orHavingRaw($sql, $bindings);
14093 }
14094
14095 /**
14096 * Add an "order by" clause to the query.
14097 *
14098 * @param string $column
14099 * @param string $direction
14100 * @return $this
14101 * @static
14102 */
14103 public static function orderBy($column, $direction = 'asc')
14104 {
14105 return \Illuminate\Database\Query\Builder::orderBy($column, $direction);
14106 }
14107
14108 /**
14109 * Add a descending "order by" clause to the query.
14110 *
14111 * @param string $column
14112 * @return $this
14113 * @static
14114 */
14115 public static function orderByDesc($column)
14116 {
14117 return \Illuminate\Database\Query\Builder::orderByDesc($column);
14118 }
14119
14120 /**
14121 * Add an "order by" clause for a timestamp to the query.
14122 *
14123 * @param string $column
14124 * @return \Illuminate\Database\Query\Builder|static
14125 * @static
14126 */
14127 public static function latest($column = 'created_at')
14128 {
14129 return \Illuminate\Database\Query\Builder::latest($column);
14130 }
14131
14132 /**
14133 * Add an "order by" clause for a timestamp to the query.
14134 *
14135 * @param string $column
14136 * @return \Illuminate\Database\Query\Builder|static
14137 * @static
14138 */
14139 public static function oldest($column = 'created_at')
14140 {
14141 return \Illuminate\Database\Query\Builder::oldest($column);
14142 }
14143
14144 /**
14145 * Put the query's results in random order.
14146 *
14147 * @param string $seed
14148 * @return $this
14149 * @static
14150 */
14151 public static function inRandomOrder($seed = '')
14152 {
14153 return \Illuminate\Database\Query\Builder::inRandomOrder($seed);
14154 }
14155
14156 /**
14157 * Add a raw "order by" clause to the query.
14158 *
14159 * @param string $sql
14160 * @param array $bindings
14161 * @return $this
14162 * @static
14163 */
14164 public static function orderByRaw($sql, $bindings = array())
14165 {
14166 return \Illuminate\Database\Query\Builder::orderByRaw($sql, $bindings);
14167 }
14168
14169 /**
14170 * Alias to set the "offset" value of the query.
14171 *
14172 * @param int $value
14173 * @return \Illuminate\Database\Query\Builder|static
14174 * @static
14175 */
14176 public static function skip($value)
14177 {
14178 return \Illuminate\Database\Query\Builder::skip($value);
14179 }
14180
14181 /**
14182 * Set the "offset" value of the query.
14183 *
14184 * @param int $value
14185 * @return $this
14186 * @static
14187 */
14188 public static function offset($value)
14189 {
14190 return \Illuminate\Database\Query\Builder::offset($value);
14191 }
14192
14193 /**
14194 * Alias to set the "limit" value of the query.
14195 *
14196 * @param int $value
14197 * @return \Illuminate\Database\Query\Builder|static
14198 * @static
14199 */
14200 public static function take($value)
14201 {
14202 return \Illuminate\Database\Query\Builder::take($value);
14203 }
14204
14205 /**
14206 * Set the "limit" value of the query.
14207 *
14208 * @param int $value
14209 * @return $this
14210 * @static
14211 */
14212 public static function limit($value)
14213 {
14214 return \Illuminate\Database\Query\Builder::limit($value);
14215 }
14216
14217 /**
14218 * Set the limit and offset for a given page.
14219 *
14220 * @param int $page
14221 * @param int $perPage
14222 * @return \Illuminate\Database\Query\Builder|static
14223 * @static
14224 */
14225 public static function forPage($page, $perPage = 15)
14226 {
14227 return \Illuminate\Database\Query\Builder::forPage($page, $perPage);
14228 }
14229
14230 /**
14231 * Constrain the query to the next "page" of results after a given ID.
14232 *
14233 * @param int $perPage
14234 * @param int $lastId
14235 * @param string $column
14236 * @return \Illuminate\Database\Query\Builder|static
14237 * @static
14238 */
14239 public static function forPageAfterId($perPage = 15, $lastId = 0, $column = 'id')
14240 {
14241 return \Illuminate\Database\Query\Builder::forPageAfterId($perPage, $lastId, $column);
14242 }
14243
14244 /**
14245 * Add a union statement to the query.
14246 *
14247 * @param \Illuminate\Database\Query\Builder|\Closure $query
14248 * @param bool $all
14249 * @return \Illuminate\Database\Query\Builder|static
14250 * @static
14251 */
14252 public static function union($query, $all = false)
14253 {
14254 return \Illuminate\Database\Query\Builder::union($query, $all);
14255 }
14256
14257 /**
14258 * Add a union all statement to the query.
14259 *
14260 * @param \Illuminate\Database\Query\Builder|\Closure $query
14261 * @return \Illuminate\Database\Query\Builder|static
14262 * @static
14263 */
14264 public static function unionAll($query)
14265 {
14266 return \Illuminate\Database\Query\Builder::unionAll($query);
14267 }
14268
14269 /**
14270 * Lock the selected rows in the table.
14271 *
14272 * @param string|bool $value
14273 * @return $this
14274 * @static
14275 */
14276 public static function lock($value = true)
14277 {
14278 return \Illuminate\Database\Query\Builder::lock($value);
14279 }
14280
14281 /**
14282 * Lock the selected rows in the table for updating.
14283 *
14284 * @return \Illuminate\Database\Query\Builder
14285 * @static
14286 */
14287 public static function lockForUpdate()
14288 {
14289 return \Illuminate\Database\Query\Builder::lockForUpdate();
14290 }
14291
14292 /**
14293 * Share lock the selected rows in the table.
14294 *
14295 * @return \Illuminate\Database\Query\Builder
14296 * @static
14297 */
14298 public static function sharedLock()
14299 {
14300 return \Illuminate\Database\Query\Builder::sharedLock();
14301 }
14302
14303 /**
14304 * Get the SQL representation of the query.
14305 *
14306 * @return string
14307 * @static
14308 */
14309 public static function toSql()
14310 {
14311 return \Illuminate\Database\Query\Builder::toSql();
14312 }
14313
14314 /**
14315 * Get the count of the total records for the paginator.
14316 *
14317 * @param array $columns
14318 * @return int
14319 * @static
14320 */
14321 public static function getCountForPagination($columns = array())
14322 {
14323 return \Illuminate\Database\Query\Builder::getCountForPagination($columns);
14324 }
14325
14326 /**
14327 * Concatenate values of a given column as a string.
14328 *
14329 * @param string $column
14330 * @param string $glue
14331 * @return string
14332 * @static
14333 */
14334 public static function implode($column, $glue = '')
14335 {
14336 return \Illuminate\Database\Query\Builder::implode($column, $glue);
14337 }
14338
14339 /**
14340 * Determine if any rows exist for the current query.
14341 *
14342 * @return bool
14343 * @static
14344 */
14345 public static function exists()
14346 {
14347 return \Illuminate\Database\Query\Builder::exists();
14348 }
14349
14350 /**
14351 * Determine if no rows exist for the current query.
14352 *
14353 * @return bool
14354 * @static
14355 */
14356 public static function doesntExist()
14357 {
14358 return \Illuminate\Database\Query\Builder::doesntExist();
14359 }
14360
14361 /**
14362 * Retrieve the "count" result of the query.
14363 *
14364 * @param string $columns
14365 * @return int
14366 * @static
14367 */
14368 public static function count($columns = '*')
14369 {
14370 return \Illuminate\Database\Query\Builder::count($columns);
14371 }
14372
14373 /**
14374 * Retrieve the minimum value of a given column.
14375 *
14376 * @param string $column
14377 * @return mixed
14378 * @static
14379 */
14380 public static function min($column)
14381 {
14382 return \Illuminate\Database\Query\Builder::min($column);
14383 }
14384
14385 /**
14386 * Retrieve the maximum value of a given column.
14387 *
14388 * @param string $column
14389 * @return mixed
14390 * @static
14391 */
14392 public static function max($column)
14393 {
14394 return \Illuminate\Database\Query\Builder::max($column);
14395 }
14396
14397 /**
14398 * Retrieve the sum of the values of a given column.
14399 *
14400 * @param string $column
14401 * @return mixed
14402 * @static
14403 */
14404 public static function sum($column)
14405 {
14406 return \Illuminate\Database\Query\Builder::sum($column);
14407 }
14408
14409 /**
14410 * Retrieve the average of the values of a given column.
14411 *
14412 * @param string $column
14413 * @return mixed
14414 * @static
14415 */
14416 public static function avg($column)
14417 {
14418 return \Illuminate\Database\Query\Builder::avg($column);
14419 }
14420
14421 /**
14422 * Alias for the "avg" method.
14423 *
14424 * @param string $column
14425 * @return mixed
14426 * @static
14427 */
14428 public static function average($column)
14429 {
14430 return \Illuminate\Database\Query\Builder::average($column);
14431 }
14432
14433 /**
14434 * Execute an aggregate function on the database.
14435 *
14436 * @param string $function
14437 * @param array $columns
14438 * @return mixed
14439 * @static
14440 */
14441 public static function aggregate($function, $columns = array())
14442 {
14443 return \Illuminate\Database\Query\Builder::aggregate($function, $columns);
14444 }
14445
14446 /**
14447 * Execute a numeric aggregate function on the database.
14448 *
14449 * @param string $function
14450 * @param array $columns
14451 * @return float|int
14452 * @static
14453 */
14454 public static function numericAggregate($function, $columns = array())
14455 {
14456 return \Illuminate\Database\Query\Builder::numericAggregate($function, $columns);
14457 }
14458
14459 /**
14460 * Insert a new record into the database.
14461 *
14462 * @param array $values
14463 * @return bool
14464 * @static
14465 */
14466 public static function insert($values)
14467 {
14468 return \Illuminate\Database\Query\Builder::insert($values);
14469 }
14470
14471 /**
14472 * Insert a new record and get the value of the primary key.
14473 *
14474 * @param array $values
14475 * @param string|null $sequence
14476 * @return int
14477 * @static
14478 */
14479 public static function insertGetId($values, $sequence = null)
14480 {
14481 return \Illuminate\Database\Query\Builder::insertGetId($values, $sequence);
14482 }
14483
14484 /**
14485 * Insert or update a record matching the attributes, and fill it with values.
14486 *
14487 * @param array $attributes
14488 * @param array $values
14489 * @return bool
14490 * @static
14491 */
14492 public static function updateOrInsert($attributes, $values = array())
14493 {
14494 return \Illuminate\Database\Query\Builder::updateOrInsert($attributes, $values);
14495 }
14496
14497 /**
14498 * Run a truncate statement on the table.
14499 *
14500 * @return void
14501 * @static
14502 */
14503 public static function truncate()
14504 {
14505 \Illuminate\Database\Query\Builder::truncate();
14506 }
14507
14508 /**
14509 * Create a raw database expression.
14510 *
14511 * @param mixed $value
14512 * @return \Illuminate\Database\Query\Expression
14513 * @static
14514 */
14515 public static function raw($value)
14516 {
14517 return \Illuminate\Database\Query\Builder::raw($value);
14518 }
14519
14520 /**
14521 * Get the current query value bindings in a flattened array.
14522 *
14523 * @return array
14524 * @static
14525 */
14526 public static function getBindings()
14527 {
14528 return \Illuminate\Database\Query\Builder::getBindings();
14529 }
14530
14531 /**
14532 * Get the raw array of bindings.
14533 *
14534 * @return array
14535 * @static
14536 */
14537 public static function getRawBindings()
14538 {
14539 return \Illuminate\Database\Query\Builder::getRawBindings();
14540 }
14541
14542 /**
14543 * Set the bindings on the query builder.
14544 *
14545 * @param array $bindings
14546 * @param string $type
14547 * @return $this
14548 * @throws \InvalidArgumentException
14549 * @static
14550 */
14551 public static function setBindings($bindings, $type = 'where')
14552 {
14553 return \Illuminate\Database\Query\Builder::setBindings($bindings, $type);
14554 }
14555
14556 /**
14557 * Add a binding to the query.
14558 *
14559 * @param mixed $value
14560 * @param string $type
14561 * @return $this
14562 * @throws \InvalidArgumentException
14563 * @static
14564 */
14565 public static function addBinding($value, $type = 'where')
14566 {
14567 return \Illuminate\Database\Query\Builder::addBinding($value, $type);
14568 }
14569
14570 /**
14571 * Merge an array of bindings into our bindings.
14572 *
14573 * @param \Illuminate\Database\Query\Builder $query
14574 * @return $this
14575 * @static
14576 */
14577 public static function mergeBindings($query)
14578 {
14579 return \Illuminate\Database\Query\Builder::mergeBindings($query);
14580 }
14581
14582 /**
14583 * Get the database query processor instance.
14584 *
14585 * @return \Illuminate\Database\Query\Processors\Processor
14586 * @static
14587 */
14588 public static function getProcessor()
14589 {
14590 return \Illuminate\Database\Query\Builder::getProcessor();
14591 }
14592
14593 /**
14594 * Get the query grammar instance.
14595 *
14596 * @return \Illuminate\Database\Query\Grammars\Grammar
14597 * @static
14598 */
14599 public static function getGrammar()
14600 {
14601 return \Illuminate\Database\Query\Builder::getGrammar();
14602 }
14603
14604 /**
14605 * Use the write pdo for query.
14606 *
14607 * @return $this
14608 * @static
14609 */
14610 public static function useWritePdo()
14611 {
14612 return \Illuminate\Database\Query\Builder::useWritePdo();
14613 }
14614
14615 /**
14616 * Clone the query without the given properties.
14617 *
14618 * @param array $properties
14619 * @return static
14620 * @static
14621 */
14622 public static function cloneWithout($properties)
14623 {
14624 return \Illuminate\Database\Query\Builder::cloneWithout($properties);
14625 }
14626
14627 /**
14628 * Clone the query without the given bindings.
14629 *
14630 * @param array $except
14631 * @return static
14632 * @static
14633 */
14634 public static function cloneWithoutBindings($except)
14635 {
14636 return \Illuminate\Database\Query\Builder::cloneWithoutBindings($except);
14637 }
14638
14639 /**
14640 * Register a custom macro.
14641 *
14642 * @param string $name
14643 * @param object|callable $macro
14644 * @return void
14645 * @static
14646 */
14647 public static function macro($name, $macro)
14648 {
14649 \Illuminate\Database\Query\Builder::macro($name, $macro);
14650 }
14651
14652 /**
14653 * Mix another object into the class.
14654 *
14655 * @param object $mixin
14656 * @return void
14657 * @throws \ReflectionException
14658 * @static
14659 */
14660 public static function mixin($mixin)
14661 {
14662 \Illuminate\Database\Query\Builder::mixin($mixin);
14663 }
14664
14665 /**
14666 * Checks if macro is registered.
14667 *
14668 * @param string $name
14669 * @return bool
14670 * @static
14671 */
14672 public static function hasMacro($name)
14673 {
14674 return \Illuminate\Database\Query\Builder::hasMacro($name);
14675 }
14676
14677 /**
14678 * Dynamically handle calls to the class.
14679 *
14680 * @param string $method
14681 * @param array $parameters
14682 * @return mixed
14683 * @throws \BadMethodCallException
14684 * @static
14685 */
14686 public static function macroCall($method, $parameters)
14687 {
14688 return \Illuminate\Database\Query\Builder::macroCall($method, $parameters);
14689 }
14690 }
14691
14692 class Event extends \Illuminate\Support\Facades\Event {}
14693
14694 class File extends \Illuminate\Support\Facades\File {}
14695
14696 class Gate extends \Illuminate\Support\Facades\Gate {}
14697
14698 class Hash extends \Illuminate\Support\Facades\Hash {}
14699
14700 class Lang extends \Illuminate\Support\Facades\Lang {}
14701
14702 class Log extends \Illuminate\Support\Facades\Log {}
14703
14704 class Mail extends \Illuminate\Support\Facades\Mail {}
14705
14706 class Notification extends \Illuminate\Support\Facades\Notification {}
14707
14708 class Password extends \Illuminate\Support\Facades\Password {}
14709
14710 class Queue extends \Illuminate\Support\Facades\Queue {}
14711
14712 class Redirect extends \Illuminate\Support\Facades\Redirect {}
14713
14714 class Request extends \Illuminate\Support\Facades\Request {}
14715
14716 class Response extends \Illuminate\Support\Facades\Response {}
14717
14718 class Route extends \Illuminate\Support\Facades\Route {}
14719
14720 class Schema extends \Illuminate\Support\Facades\Schema {}
14721
14722 class Session extends \Illuminate\Support\Facades\Session {}
14723
14724 class Storage extends \Illuminate\Support\Facades\Storage {}
14725
14726 class URL extends \Illuminate\Support\Facades\URL {}
14727
14728 class Validator extends \Illuminate\Support\Facades\Validator {}
14729
14730 class View extends \Illuminate\Support\Facades\View {}
14731
14732}