HomeAccounting

1
<?php
2
/**
3
 * A helper file for Laravel 5, to provide autocomplete information to your IDE
4
 * Generated for Laravel 5.6.12 on 2019-06-16 13:56:52.
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

12
namespace 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\Models\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\Models\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\Models\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
         * Register an authentication attempt event listener.
1749
         *
1750
         * @param mixed $callback
1751
         * @return void 
1752
         * @static 
1753
         */ 
1754
        public static function attempting($callback)
1755
        {
1756
            \Illuminate\Auth\SessionGuard::attempting($callback);
1757
        }
1758
        
1759
        /**
1760
         * Get the last user we attempted to authenticate.
1761
         *
1762
         * @return \App\Models\User 
1763
         * @static 
1764
         */ 
1765
        public static function getLastAttempted()
1766
        {
1767
            return \Illuminate\Auth\SessionGuard::getLastAttempted();
1768
        }
1769
        
1770
        /**
1771
         * Get a unique identifier for the auth session value.
1772
         *
1773
         * @return string 
1774
         * @static 
1775
         */ 
1776
        public static function getName()
1777
        {
1778
            return \Illuminate\Auth\SessionGuard::getName();
1779
        }
1780
        
1781
        /**
1782
         * Get the name of the cookie used to store the "recaller".
1783
         *
1784
         * @return string 
1785
         * @static 
1786
         */ 
1787
        public static function getRecallerName()
1788
        {
1789
            return \Illuminate\Auth\SessionGuard::getRecallerName();
1790
        }
1791
        
1792
        /**
1793
         * Determine if the user was authenticated via "remember me" cookie.
1794
         *
1795
         * @return bool 
1796
         * @static 
1797
         */ 
1798
        public static function viaRemember()
1799
        {
1800
            return \Illuminate\Auth\SessionGuard::viaRemember();
1801
        }
1802
        
1803
        /**
1804
         * Get the cookie creator instance used by the guard.
1805
         *
1806
         * @return \Illuminate\Contracts\Cookie\QueueingFactory 
1807
         * @throws \RuntimeException
1808
         * @static 
1809
         */ 
1810
        public static function getCookieJar()
1811
        {
1812
            return \Illuminate\Auth\SessionGuard::getCookieJar();
1813
        }
1814
        
1815
        /**
1816
         * Set the cookie creator instance used by the guard.
1817
         *
1818
         * @param \Illuminate\Contracts\Cookie\QueueingFactory $cookie
1819
         * @return void 
1820
         * @static 
1821
         */ 
1822
        public static function setCookieJar($cookie)
1823
        {
1824
            \Illuminate\Auth\SessionGuard::setCookieJar($cookie);
1825
        }
1826
        
1827
        /**
1828
         * Get the event dispatcher instance.
1829
         *
1830
         * @return \Illuminate\Contracts\Events\Dispatcher 
1831
         * @static 
1832
         */ 
1833
        public static function getDispatcher()
1834
        {
1835
            return \Illuminate\Auth\SessionGuard::getDispatcher();
1836
        }
1837
        
1838
        /**
1839
         * Set the event dispatcher instance.
1840
         *
1841
         * @param \Illuminate\Contracts\Events\Dispatcher $events
1842
         * @return void 
1843
         * @static 
1844
         */ 
1845
        public static function setDispatcher($events)
1846
        {
1847
            \Illuminate\Auth\SessionGuard::setDispatcher($events);
1848
        }
1849
        
1850
        /**
1851
         * Get the session store used by the guard.
1852
         *
1853
         * @return \Illuminate\Contracts\Session\Session 
1854
         * @static 
1855
         */ 
1856
        public static function getSession()
1857
        {
1858
            return \Illuminate\Auth\SessionGuard::getSession();
1859
        }
1860
        
1861
        /**
1862
         * Return the currently cached user.
1863
         *
1864
         * @return \App\Models\User|null 
1865
         * @static 
1866
         */ 
1867
        public static function getUser()
1868
        {
1869
            return \Illuminate\Auth\SessionGuard::getUser();
1870
        }
1871
        
1872
        /**
1873
         * Set the current user.
1874
         *
1875
         * @param \Illuminate\Contracts\Auth\Authenticatable $user
1876
         * @return $this 
1877
         * @static 
1878
         */ 
1879
        public static function setUser($user)
1880
        {
1881
            return \Illuminate\Auth\SessionGuard::setUser($user);
1882
        }
1883
        
1884
        /**
1885
         * Get the current request instance.
1886
         *
1887
         * @return \Symfony\Component\HttpFoundation\Request 
1888
         * @static 
1889
         */ 
1890
        public static function getRequest()
1891
        {
1892
            return \Illuminate\Auth\SessionGuard::getRequest();
1893
        }
1894
        
1895
        /**
1896
         * Set the current request instance.
1897
         *
1898
         * @param \Symfony\Component\HttpFoundation\Request $request
1899
         * @return $this 
1900
         * @static 
1901
         */ 
1902
        public static function setRequest($request)
1903
        {
1904
            return \Illuminate\Auth\SessionGuard::setRequest($request);
1905
        }
1906
        
1907
        /**
1908
         * Determine if the current user is authenticated.
1909
         *
1910
         * @return \App\Models\User 
1911
         * @throws \Illuminate\Auth\AuthenticationException
1912
         * @static 
1913
         */ 
1914
        public static function authenticate()
1915
        {
1916
            return \Illuminate\Auth\SessionGuard::authenticate();
1917
        }
1918
        
1919
        /**
1920
         * Determine if the current user is authenticated.
1921
         *
1922
         * @return bool 
1923
         * @static 
1924
         */ 
1925
        public static function check()
1926
        {
1927
            return \Illuminate\Auth\SessionGuard::check();
1928
        }
1929
        
1930
        /**
1931
         * Determine if the current user is a guest.
1932
         *
1933
         * @return bool 
1934
         * @static 
1935
         */ 
1936
        public static function guest()
1937
        {
1938
            return \Illuminate\Auth\SessionGuard::guest();
1939
        }
1940
        
1941
        /**
1942
         * Get the user provider used by the guard.
1943
         *
1944
         * @return \Illuminate\Contracts\Auth\UserProvider 
1945
         * @static 
1946
         */ 
1947
        public static function getProvider()
1948
        {
1949
            return \Illuminate\Auth\SessionGuard::getProvider();
1950
        }
1951
        
1952
        /**
1953
         * Set the user provider used by the guard.
1954
         *
1955
         * @param \Illuminate\Contracts\Auth\UserProvider $provider
1956
         * @return void 
1957
         * @static 
1958
         */ 
1959
        public static function setProvider($provider)
1960
        {
1961
            \Illuminate\Auth\SessionGuard::setProvider($provider);
1962
        }
1963
        
1964
        /**
1965
         * Register a custom macro.
1966
         *
1967
         * @param string $name
1968
         * @param object|callable $macro
1969
         * @return void 
1970
         * @static 
1971
         */ 
1972
        public static function macro($name, $macro)
1973
        {
1974
            \Illuminate\Auth\SessionGuard::macro($name, $macro);
1975
        }
1976
        
1977
        /**
1978
         * Mix another object into the class.
1979
         *
1980
         * @param object $mixin
1981
         * @return void 
1982
         * @static 
1983
         */ 
1984
        public static function mixin($mixin)
1985
        {
1986
            \Illuminate\Auth\SessionGuard::mixin($mixin);
1987
        }
1988
        
1989
        /**
1990
         * Checks if macro is registered.
1991
         *
1992
         * @param string $name
1993
         * @return bool 
1994
         * @static 
1995
         */ 
1996
        public static function hasMacro($name)
1997
        {
1998
            return \Illuminate\Auth\SessionGuard::hasMacro($name);
1999
        }
2000
         
2001
    }
2002

2003
    class Blade {
2004
        
2005
        /**
2006
         * Compile the view at the given path.
2007
         *
2008
         * @param string $path
2009
         * @return void 
2010
         * @static 
2011
         */ 
2012
        public static function compile($path = null)
2013
        {
2014
            \Illuminate\View\Compilers\BladeCompiler::compile($path);
2015
        }
2016
        
2017
        /**
2018
         * Get the path currently being compiled.
2019
         *
2020
         * @return string 
2021
         * @static 
2022
         */ 
2023
        public static function getPath()
2024
        {
2025
            return \Illuminate\View\Compilers\BladeCompiler::getPath();
2026
        }
2027
        
2028
        /**
2029
         * Set the path currently being compiled.
2030
         *
2031
         * @param string $path
2032
         * @return void 
2033
         * @static 
2034
         */ 
2035
        public static function setPath($path)
2036
        {
2037
            \Illuminate\View\Compilers\BladeCompiler::setPath($path);
2038
        }
2039
        
2040
        /**
2041
         * Compile the given Blade template contents.
2042
         *
2043
         * @param string $value
2044
         * @return string 
2045
         * @static 
2046
         */ 
2047
        public static function compileString($value)
2048
        {
2049
            return \Illuminate\View\Compilers\BladeCompiler::compileString($value);
2050
        }
2051
        
2052
        /**
2053
         * Strip the parentheses from the given expression.
2054
         *
2055
         * @param string $expression
2056
         * @return string 
2057
         * @static 
2058
         */ 
2059
        public static function stripParentheses($expression)
2060
        {
2061
            return \Illuminate\View\Compilers\BladeCompiler::stripParentheses($expression);
2062
        }
2063
        
2064
        /**
2065
         * Register a custom Blade compiler.
2066
         *
2067
         * @param callable $compiler
2068
         * @return void 
2069
         * @static 
2070
         */ 
2071
        public static function extend($compiler)
2072
        {
2073
            \Illuminate\View\Compilers\BladeCompiler::extend($compiler);
2074
        }
2075
        
2076
        /**
2077
         * Get the extensions used by the compiler.
2078
         *
2079
         * @return array 
2080
         * @static 
2081
         */ 
2082
        public static function getExtensions()
2083
        {
2084
            return \Illuminate\View\Compilers\BladeCompiler::getExtensions();
2085
        }
2086
        
2087
        /**
2088
         * Register an "if" statement directive.
2089
         *
2090
         * @param string $name
2091
         * @param callable $callback
2092
         * @return void 
2093
         * @static 
2094
         */ 
2095
        public static function if($name, $callback)
2096
        {
2097
            \Illuminate\View\Compilers\BladeCompiler::if($name, $callback);
2098
        }
2099
        
2100
        /**
2101
         * Check the result of a condition.
2102
         *
2103
         * @param string $name
2104
         * @param array $parameters
2105
         * @return bool 
2106
         * @static 
2107
         */ 
2108
        public static function check($name, $parameters = null)
2109
        {
2110
            return \Illuminate\View\Compilers\BladeCompiler::check($name, $parameters);
2111
        }
2112
        
2113
        /**
2114
         * Register a component alias directive.
2115
         *
2116
         * @param string $path
2117
         * @param string $alias
2118
         * @return void 
2119
         * @static 
2120
         */ 
2121
        public static function component($path, $alias = null)
2122
        {
2123
            \Illuminate\View\Compilers\BladeCompiler::component($path, $alias);
2124
        }
2125
        
2126
        /**
2127
         * Register an include alias directive.
2128
         *
2129
         * @param string $path
2130
         * @param string $alias
2131
         * @return void 
2132
         * @static 
2133
         */ 
2134
        public static function include($path, $alias = null)
2135
        {
2136
            \Illuminate\View\Compilers\BladeCompiler::include($path, $alias);
2137
        }
2138
        
2139
        /**
2140
         * Register a handler for custom directives.
2141
         *
2142
         * @param string $name
2143
         * @param callable $handler
2144
         * @return void 
2145
         * @static 
2146
         */ 
2147
        public static function directive($name, $handler)
2148
        {
2149
            \Illuminate\View\Compilers\BladeCompiler::directive($name, $handler);
2150
        }
2151
        
2152
        /**
2153
         * Get the list of custom directives.
2154
         *
2155
         * @return array 
2156
         * @static 
2157
         */ 
2158
        public static function getCustomDirectives()
2159
        {
2160
            return \Illuminate\View\Compilers\BladeCompiler::getCustomDirectives();
2161
        }
2162
        
2163
        /**
2164
         * Set the echo format to be used by the compiler.
2165
         *
2166
         * @param string $format
2167
         * @return void 
2168
         * @static 
2169
         */ 
2170
        public static function setEchoFormat($format)
2171
        {
2172
            \Illuminate\View\Compilers\BladeCompiler::setEchoFormat($format);
2173
        }
2174
        
2175
        /**
2176
         * Set the "echo" format to double encode entities.
2177
         *
2178
         * @return void 
2179
         * @static 
2180
         */ 
2181
        public static function withDoubleEncoding()
2182
        {
2183
            \Illuminate\View\Compilers\BladeCompiler::withDoubleEncoding();
2184
        }
2185
        
2186
        /**
2187
         * Set the "echo" format to not double encode entities.
2188
         *
2189
         * @return void 
2190
         * @static 
2191
         */ 
2192
        public static function withoutDoubleEncoding()
2193
        {
2194
            \Illuminate\View\Compilers\BladeCompiler::withoutDoubleEncoding();
2195
        }
2196
        
2197
        /**
2198
         * Get the path to the compiled version of a view.
2199
         *
2200
         * @param string $path
2201
         * @return string 
2202
         * @static 
2203
         */ 
2204
        public static function getCompiledPath($path)
2205
        {
2206
            //Method inherited from \Illuminate\View\Compilers\Compiler            
2207
            return \Illuminate\View\Compilers\BladeCompiler::getCompiledPath($path);
2208
        }
2209
        
2210
        /**
2211
         * Determine if the view at the given path is expired.
2212
         *
2213
         * @param string $path
2214
         * @return bool 
2215
         * @static 
2216
         */ 
2217
        public static function isExpired($path)
2218
        {
2219
            //Method inherited from \Illuminate\View\Compilers\Compiler            
2220
            return \Illuminate\View\Compilers\BladeCompiler::isExpired($path);
2221
        }
2222
        
2223
        /**
2224
         * Compile the default values for the echo statement.
2225
         *
2226
         * @param string $value
2227
         * @return string 
2228
         * @static 
2229
         */ 
2230
        public static function compileEchoDefaults($value)
2231
        {
2232
            return \Illuminate\View\Compilers\BladeCompiler::compileEchoDefaults($value);
2233
        }
2234
         
2235
    }
2236

2237
    class Broadcast {
2238
        
2239
        /**
2240
         * Register the routes for handling broadcast authentication and sockets.
2241
         *
2242
         * @param array|null $attributes
2243
         * @return void 
2244
         * @static 
2245
         */ 
2246
        public static function routes($attributes = null)
2247
        {
2248
            \Illuminate\Broadcasting\BroadcastManager::routes($attributes);
2249
        }
2250
        
2251
        /**
2252
         * Get the socket ID for the given request.
2253
         *
2254
         * @param \Illuminate\Http\Request|null $request
2255
         * @return string|null 
2256
         * @static 
2257
         */ 
2258
        public static function socket($request = null)
2259
        {
2260
            return \Illuminate\Broadcasting\BroadcastManager::socket($request);
2261
        }
2262
        
2263
        /**
2264
         * Begin broadcasting an event.
2265
         *
2266
         * @param mixed|null $event
2267
         * @return \Illuminate\Broadcasting\PendingBroadcast|void 
2268
         * @static 
2269
         */ 
2270
        public static function event($event = null)
2271
        {
2272
            return \Illuminate\Broadcasting\BroadcastManager::event($event);
2273
        }
2274
        
2275
        /**
2276
         * Queue the given event for broadcast.
2277
         *
2278
         * @param mixed $event
2279
         * @return void 
2280
         * @static 
2281
         */ 
2282
        public static function queue($event)
2283
        {
2284
            \Illuminate\Broadcasting\BroadcastManager::queue($event);
2285
        }
2286
        
2287
        /**
2288
         * Get a driver instance.
2289
         *
2290
         * @param string $driver
2291
         * @return mixed 
2292
         * @static 
2293
         */ 
2294
        public static function connection($driver = null)
2295
        {
2296
            return \Illuminate\Broadcasting\BroadcastManager::connection($driver);
2297
        }
2298
        
2299
        /**
2300
         * Get a driver instance.
2301
         *
2302
         * @param string $name
2303
         * @return mixed 
2304
         * @static 
2305
         */ 
2306
        public static function driver($name = null)
2307
        {
2308
            return \Illuminate\Broadcasting\BroadcastManager::driver($name);
2309
        }
2310
        
2311
        /**
2312
         * Get the default driver name.
2313
         *
2314
         * @return string 
2315
         * @static 
2316
         */ 
2317
        public static function getDefaultDriver()
2318
        {
2319
            return \Illuminate\Broadcasting\BroadcastManager::getDefaultDriver();
2320
        }
2321
        
2322
        /**
2323
         * Set the default driver name.
2324
         *
2325
         * @param string $name
2326
         * @return void 
2327
         * @static 
2328
         */ 
2329
        public static function setDefaultDriver($name)
2330
        {
2331
            \Illuminate\Broadcasting\BroadcastManager::setDefaultDriver($name);
2332
        }
2333
        
2334
        /**
2335
         * Register a custom driver creator Closure.
2336
         *
2337
         * @param string $driver
2338
         * @param \Closure $callback
2339
         * @return $this 
2340
         * @static 
2341
         */ 
2342
        public static function extend($driver, $callback)
2343
        {
2344
            return \Illuminate\Broadcasting\BroadcastManager::extend($driver, $callback);
2345
        }
2346
         
2347
    }
2348

2349
    class Bus {
2350
        
2351
        /**
2352
         * Dispatch a command to its appropriate handler.
2353
         *
2354
         * @param mixed $command
2355
         * @return mixed 
2356
         * @static 
2357
         */ 
2358
        public static function dispatch($command)
2359
        {
2360
            return \Illuminate\Bus\Dispatcher::dispatch($command);
2361
        }
2362
        
2363
        /**
2364
         * Dispatch a command to its appropriate handler in the current process.
2365
         *
2366
         * @param mixed $command
2367
         * @param mixed $handler
2368
         * @return mixed 
2369
         * @static 
2370
         */ 
2371
        public static function dispatchNow($command, $handler = null)
2372
        {
2373
            return \Illuminate\Bus\Dispatcher::dispatchNow($command, $handler);
2374
        }
2375
        
2376
        /**
2377
         * Determine if the given command has a handler.
2378
         *
2379
         * @param mixed $command
2380
         * @return bool 
2381
         * @static 
2382
         */ 
2383
        public static function hasCommandHandler($command)
2384
        {
2385
            return \Illuminate\Bus\Dispatcher::hasCommandHandler($command);
2386
        }
2387
        
2388
        /**
2389
         * Retrieve the handler for a command.
2390
         *
2391
         * @param mixed $command
2392
         * @return bool|mixed 
2393
         * @static 
2394
         */ 
2395
        public static function getCommandHandler($command)
2396
        {
2397
            return \Illuminate\Bus\Dispatcher::getCommandHandler($command);
2398
        }
2399
        
2400
        /**
2401
         * Dispatch a command to its appropriate handler behind a queue.
2402
         *
2403
         * @param mixed $command
2404
         * @return mixed 
2405
         * @throws \RuntimeException
2406
         * @static 
2407
         */ 
2408
        public static function dispatchToQueue($command)
2409
        {
2410
            return \Illuminate\Bus\Dispatcher::dispatchToQueue($command);
2411
        }
2412
        
2413
        /**
2414
         * Set the pipes through which commands should be piped before dispatching.
2415
         *
2416
         * @param array $pipes
2417
         * @return $this 
2418
         * @static 
2419
         */ 
2420
        public static function pipeThrough($pipes)
2421
        {
2422
            return \Illuminate\Bus\Dispatcher::pipeThrough($pipes);
2423
        }
2424
        
2425
        /**
2426
         * Map a command to a handler.
2427
         *
2428
         * @param array $map
2429
         * @return $this 
2430
         * @static 
2431
         */ 
2432
        public static function map($map)
2433
        {
2434
            return \Illuminate\Bus\Dispatcher::map($map);
2435
        }
2436
         
2437
    }
2438

2439
    class Cache {
2440
        
2441
        /**
2442
         * Get a cache store instance by name.
2443
         *
2444
         * @param string|null $name
2445
         * @return \Illuminate\Contracts\Cache\Repository 
2446
         * @static 
2447
         */ 
2448
        public static function store($name = null)
2449
        {
2450
            return \Illuminate\Cache\CacheManager::store($name);
2451
        }
2452
        
2453
        /**
2454
         * Get a cache driver instance.
2455
         *
2456
         * @param string $driver
2457
         * @return mixed 
2458
         * @static 
2459
         */ 
2460
        public static function driver($driver = null)
2461
        {
2462
            return \Illuminate\Cache\CacheManager::driver($driver);
2463
        }
2464
        
2465
        /**
2466
         * Create a new cache repository with the given implementation.
2467
         *
2468
         * @param \Illuminate\Contracts\Cache\Store $store
2469
         * @return \Illuminate\Cache\Repository 
2470
         * @static 
2471
         */ 
2472
        public static function repository($store)
2473
        {
2474
            return \Illuminate\Cache\CacheManager::repository($store);
2475
        }
2476
        
2477
        /**
2478
         * Get the default cache driver name.
2479
         *
2480
         * @return string 
2481
         * @static 
2482
         */ 
2483
        public static function getDefaultDriver()
2484
        {
2485
            return \Illuminate\Cache\CacheManager::getDefaultDriver();
2486
        }
2487
        
2488
        /**
2489
         * Set the default cache driver name.
2490
         *
2491
         * @param string $name
2492
         * @return void 
2493
         * @static 
2494
         */ 
2495
        public static function setDefaultDriver($name)
2496
        {
2497
            \Illuminate\Cache\CacheManager::setDefaultDriver($name);
2498
        }
2499
        
2500
        /**
2501
         * Register a custom driver creator Closure.
2502
         *
2503
         * @param string $driver
2504
         * @param \Closure $callback
2505
         * @return $this 
2506
         * @static 
2507
         */ 
2508
        public static function extend($driver, $callback)
2509
        {
2510
            return \Illuminate\Cache\CacheManager::extend($driver, $callback);
2511
        }
2512
        
2513
        /**
2514
         * Determine if an item exists in the cache.
2515
         *
2516
         * @param string $key
2517
         * @return bool 
2518
         * @static 
2519
         */ 
2520
        public static function has($key)
2521
        {
2522
            return \Illuminate\Cache\Repository::has($key);
2523
        }
2524
        
2525
        /**
2526
         * Retrieve an item from the cache by key.
2527
         *
2528
         * @param string $key
2529
         * @param mixed $default
2530
         * @return mixed 
2531
         * @static 
2532
         */ 
2533
        public static function get($key, $default = null)
2534
        {
2535
            return \Illuminate\Cache\Repository::get($key, $default);
2536
        }
2537
        
2538
        /**
2539
         * Retrieve multiple items from the cache by key.
2540
         * 
2541
         * Items not found in the cache will have a null value.
2542
         *
2543
         * @param array $keys
2544
         * @return array 
2545
         * @static 
2546
         */ 
2547
        public static function many($keys)
2548
        {
2549
            return \Illuminate\Cache\Repository::many($keys);
2550
        }
2551
        
2552
        /**
2553
         * Obtains multiple cache items by their unique keys.
2554
         *
2555
         * @param \Psr\SimpleCache\iterable $keys A list of keys that can obtained in a single operation.
2556
         * @param mixed $default Default value to return for keys that do not exist.
2557
         * @return \Psr\SimpleCache\iterable A list of key => value pairs. Cache keys that do not exist or are stale will have $default as value.
2558
         * @throws \Psr\SimpleCache\InvalidArgumentException
2559
         *   MUST be thrown if $keys is neither an array nor a Traversable,
2560
         *   or if any of the $keys are not a legal value.
2561
         * @static 
2562
         */ 
2563
        public static function getMultiple($keys, $default = null)
2564
        {
2565
            return \Illuminate\Cache\Repository::getMultiple($keys, $default);
2566
        }
2567
        
2568
        /**
2569
         * Retrieve an item from the cache and delete it.
2570
         *
2571
         * @param string $key
2572
         * @param mixed $default
2573
         * @return mixed 
2574
         * @static 
2575
         */ 
2576
        public static function pull($key, $default = null)
2577
        {
2578
            return \Illuminate\Cache\Repository::pull($key, $default);
2579
        }
2580
        
2581
        /**
2582
         * Store an item in the cache.
2583
         *
2584
         * @param string $key
2585
         * @param mixed $value
2586
         * @param \DateTimeInterface|\DateInterval|float|int $minutes
2587
         * @return void 
2588
         * @static 
2589
         */ 
2590
        public static function put($key, $value, $minutes = null)
2591
        {
2592
            \Illuminate\Cache\Repository::put($key, $value, $minutes);
2593
        }
2594
        
2595
        /**
2596
         * Persists data in the cache, uniquely referenced by a key with an optional expiration TTL time.
2597
         *
2598
         * @param string $key The key of the item to store.
2599
         * @param mixed $value The value of the item to store, must be serializable.
2600
         * @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and
2601
         *                                      the driver supports TTL then the library may set a default value
2602
         *                                      for it or let the driver take care of that.
2603
         * @return bool True on success and false on failure.
2604
         * @throws \Psr\SimpleCache\InvalidArgumentException
2605
         *   MUST be thrown if the $key string is not a legal value.
2606
         * @static 
2607
         */ 
2608
        public static function set($key, $value, $ttl = null)
2609
        {
2610
            return \Illuminate\Cache\Repository::set($key, $value, $ttl);
2611
        }
2612
        
2613
        /**
2614
         * Store multiple items in the cache for a given number of minutes.
2615
         *
2616
         * @param array $values
2617
         * @param \DateTimeInterface|\DateInterval|float|int $minutes
2618
         * @return void 
2619
         * @static 
2620
         */ 
2621
        public static function putMany($values, $minutes)
2622
        {
2623
            \Illuminate\Cache\Repository::putMany($values, $minutes);
2624
        }
2625
        
2626
        /**
2627
         * Persists a set of key => value pairs in the cache, with an optional TTL.
2628
         *
2629
         * @param \Psr\SimpleCache\iterable $values A list of key => value pairs for a multiple-set operation.
2630
         * @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and
2631
         *                                       the driver supports TTL then the library may set a default value
2632
         *                                       for it or let the driver take care of that.
2633
         * @return bool True on success and false on failure.
2634
         * @throws \Psr\SimpleCache\InvalidArgumentException
2635
         *   MUST be thrown if $values is neither an array nor a Traversable,
2636
         *   or if any of the $values are not a legal value.
2637
         * @static 
2638
         */ 
2639
        public static function setMultiple($values, $ttl = null)
2640
        {
2641
            return \Illuminate\Cache\Repository::setMultiple($values, $ttl);
2642
        }
2643
        
2644
        /**
2645
         * Store an item in the cache if the key does not exist.
2646
         *
2647
         * @param string $key
2648
         * @param mixed $value
2649
         * @param \DateTimeInterface|\DateInterval|float|int $minutes
2650
         * @return bool 
2651
         * @static 
2652
         */ 
2653
        public static function add($key, $value, $minutes)
2654
        {
2655
            return \Illuminate\Cache\Repository::add($key, $value, $minutes);
2656
        }
2657
        
2658
        /**
2659
         * Increment the value of an item in the cache.
2660
         *
2661
         * @param string $key
2662
         * @param mixed $value
2663
         * @return int|bool 
2664
         * @static 
2665
         */ 
2666
        public static function increment($key, $value = 1)
2667
        {
2668
            return \Illuminate\Cache\Repository::increment($key, $value);
2669
        }
2670
        
2671
        /**
2672
         * Decrement the value of an item in the cache.
2673
         *
2674
         * @param string $key
2675
         * @param mixed $value
2676
         * @return int|bool 
2677
         * @static 
2678
         */ 
2679
        public static function decrement($key, $value = 1)
2680
        {
2681
            return \Illuminate\Cache\Repository::decrement($key, $value);
2682
        }
2683
        
2684
        /**
2685
         * Store an item in the cache indefinitely.
2686
         *
2687
         * @param string $key
2688
         * @param mixed $value
2689
         * @return void 
2690
         * @static 
2691
         */ 
2692
        public static function forever($key, $value)
2693
        {
2694
            \Illuminate\Cache\Repository::forever($key, $value);
2695
        }
2696
        
2697
        /**
2698
         * Get an item from the cache, or store the default value.
2699
         *
2700
         * @param string $key
2701
         * @param \DateTimeInterface|\DateInterval|float|int $minutes
2702
         * @param \Closure $callback
2703
         * @return mixed 
2704
         * @static 
2705
         */ 
2706
        public static function remember($key, $minutes, $callback)
2707
        {
2708
            return \Illuminate\Cache\Repository::remember($key, $minutes, $callback);
2709
        }
2710
        
2711
        /**
2712
         * Get an item from the cache, or store the default value forever.
2713
         *
2714
         * @param string $key
2715
         * @param \Closure $callback
2716
         * @return mixed 
2717
         * @static 
2718
         */ 
2719
        public static function sear($key, $callback)
2720
        {
2721
            return \Illuminate\Cache\Repository::sear($key, $callback);
2722
        }
2723
        
2724
        /**
2725
         * Get an item from the cache, or store the default value forever.
2726
         *
2727
         * @param string $key
2728
         * @param \Closure $callback
2729
         * @return mixed 
2730
         * @static 
2731
         */ 
2732
        public static function rememberForever($key, $callback)
2733
        {
2734
            return \Illuminate\Cache\Repository::rememberForever($key, $callback);
2735
        }
2736
        
2737
        /**
2738
         * Remove an item from the cache.
2739
         *
2740
         * @param string $key
2741
         * @return bool 
2742
         * @static 
2743
         */ 
2744
        public static function forget($key)
2745
        {
2746
            return \Illuminate\Cache\Repository::forget($key);
2747
        }
2748
        
2749
        /**
2750
         * Delete an item from the cache by its unique key.
2751
         *
2752
         * @param string $key The unique cache key of the item to delete.
2753
         * @return bool True if the item was successfully removed. False if there was an error.
2754
         * @throws \Psr\SimpleCache\InvalidArgumentException
2755
         *   MUST be thrown if the $key string is not a legal value.
2756
         * @static 
2757
         */ 
2758
        public static function delete($key)
2759
        {
2760
            return \Illuminate\Cache\Repository::delete($key);
2761
        }
2762
        
2763
        /**
2764
         * Deletes multiple cache items in a single operation.
2765
         *
2766
         * @param \Psr\SimpleCache\iterable $keys A list of string-based keys to be deleted.
2767
         * @return bool True if the items were successfully removed. False if there was an error.
2768
         * @throws \Psr\SimpleCache\InvalidArgumentException
2769
         *   MUST be thrown if $keys is neither an array nor a Traversable,
2770
         *   or if any of the $keys are not a legal value.
2771
         * @static 
2772
         */ 
2773
        public static function deleteMultiple($keys)
2774
        {
2775
            return \Illuminate\Cache\Repository::deleteMultiple($keys);
2776
        }
2777
        
2778
        /**
2779
         * Wipes clean the entire cache's keys.
2780
         *
2781
         * @return bool True on success and false on failure.
2782
         * @static 
2783
         */ 
2784
        public static function clear()
2785
        {
2786
            return \Illuminate\Cache\Repository::clear();
2787
        }
2788
        
2789
        /**
2790
         * Begin executing a new tags operation if the store supports it.
2791
         *
2792
         * @param array|mixed $names
2793
         * @return \Illuminate\Cache\TaggedCache 
2794
         * @throws \BadMethodCallException
2795
         * @static 
2796
         */ 
2797
        public static function tags($names)
2798
        {
2799
            return \Illuminate\Cache\Repository::tags($names);
2800
        }
2801
        
2802
        /**
2803
         * Get the default cache time.
2804
         *
2805
         * @return float|int 
2806
         * @static 
2807
         */ 
2808
        public static function getDefaultCacheTime()
2809
        {
2810
            return \Illuminate\Cache\Repository::getDefaultCacheTime();
2811
        }
2812
        
2813
        /**
2814
         * Set the default cache time in minutes.
2815
         *
2816
         * @param float|int $minutes
2817
         * @return $this 
2818
         * @static 
2819
         */ 
2820
        public static function setDefaultCacheTime($minutes)
2821
        {
2822
            return \Illuminate\Cache\Repository::setDefaultCacheTime($minutes);
2823
        }
2824
        
2825
        /**
2826
         * Get the cache store implementation.
2827
         *
2828
         * @return \Illuminate\Contracts\Cache\Store 
2829
         * @static 
2830
         */ 
2831
        public static function getStore()
2832
        {
2833
            return \Illuminate\Cache\Repository::getStore();
2834
        }
2835
        
2836
        /**
2837
         * Set the event dispatcher instance.
2838
         *
2839
         * @param \Illuminate\Contracts\Events\Dispatcher $events
2840
         * @return void 
2841
         * @static 
2842
         */ 
2843
        public static function setEventDispatcher($events)
2844
        {
2845
            \Illuminate\Cache\Repository::setEventDispatcher($events);
2846
        }
2847
        
2848
        /**
2849
         * Determine if a cached value exists.
2850
         *
2851
         * @param string $key
2852
         * @return bool 
2853
         * @static 
2854
         */ 
2855
        public static function offsetExists($key)
2856
        {
2857
            return \Illuminate\Cache\Repository::offsetExists($key);
2858
        }
2859
        
2860
        /**
2861
         * Retrieve an item from the cache by key.
2862
         *
2863
         * @param string $key
2864
         * @return mixed 
2865
         * @static 
2866
         */ 
2867
        public static function offsetGet($key)
2868
        {
2869
            return \Illuminate\Cache\Repository::offsetGet($key);
2870
        }
2871
        
2872
        /**
2873
         * Store an item in the cache for the default time.
2874
         *
2875
         * @param string $key
2876
         * @param mixed $value
2877
         * @return void 
2878
         * @static 
2879
         */ 
2880
        public static function offsetSet($key, $value)
2881
        {
2882
            \Illuminate\Cache\Repository::offsetSet($key, $value);
2883
        }
2884
        
2885
        /**
2886
         * Remove an item from the cache.
2887
         *
2888
         * @param string $key
2889
         * @return void 
2890
         * @static 
2891
         */ 
2892
        public static function offsetUnset($key)
2893
        {
2894
            \Illuminate\Cache\Repository::offsetUnset($key);
2895
        }
2896
        
2897
        /**
2898
         * Register a custom macro.
2899
         *
2900
         * @param string $name
2901
         * @param object|callable $macro
2902
         * @return void 
2903
         * @static 
2904
         */ 
2905
        public static function macro($name, $macro)
2906
        {
2907
            \Illuminate\Cache\Repository::macro($name, $macro);
2908
        }
2909
        
2910
        /**
2911
         * Mix another object into the class.
2912
         *
2913
         * @param object $mixin
2914
         * @return void 
2915
         * @static 
2916
         */ 
2917
        public static function mixin($mixin)
2918
        {
2919
            \Illuminate\Cache\Repository::mixin($mixin);
2920
        }
2921
        
2922
        /**
2923
         * Checks if macro is registered.
2924
         *
2925
         * @param string $name
2926
         * @return bool 
2927
         * @static 
2928
         */ 
2929
        public static function hasMacro($name)
2930
        {
2931
            return \Illuminate\Cache\Repository::hasMacro($name);
2932
        }
2933
        
2934
        /**
2935
         * Dynamically handle calls to the class.
2936
         *
2937
         * @param string $method
2938
         * @param array $parameters
2939
         * @return mixed 
2940
         * @throws \BadMethodCallException
2941
         * @static 
2942
         */ 
2943
        public static function macroCall($method, $parameters)
2944
        {
2945
            return \Illuminate\Cache\Repository::macroCall($method, $parameters);
2946
        }
2947
        
2948
        /**
2949
         * Remove all items from the cache.
2950
         *
2951
         * @return bool 
2952
         * @static 
2953
         */ 
2954
        public static function flush()
2955
        {
2956
            return \Illuminate\Cache\FileStore::flush();
2957
        }
2958
        
2959
        /**
2960
         * Get the Filesystem instance.
2961
         *
2962
         * @return \Illuminate\Filesystem\Filesystem 
2963
         * @static 
2964
         */ 
2965
        public static function getFilesystem()
2966
        {
2967
            return \Illuminate\Cache\FileStore::getFilesystem();
2968
        }
2969
        
2970
        /**
2971
         * Get the working directory of the cache.
2972
         *
2973
         * @return string 
2974
         * @static 
2975
         */ 
2976
        public static function getDirectory()
2977
        {
2978
            return \Illuminate\Cache\FileStore::getDirectory();
2979
        }
2980
        
2981
        /**
2982
         * Get the cache key prefix.
2983
         *
2984
         * @return string 
2985
         * @static 
2986
         */ 
2987
        public static function getPrefix()
2988
        {
2989
            return \Illuminate\Cache\FileStore::getPrefix();
2990
        }
2991
         
2992
    }
2993

2994
    class Config {
2995
        
2996
        /**
2997
         * Determine if the given configuration value exists.
2998
         *
2999
         * @param string $key
3000
         * @return bool 
3001
         * @static 
3002
         */ 
3003
        public static function has($key)
3004
        {
3005
            return \Illuminate\Config\Repository::has($key);
3006
        }
3007
        
3008
        /**
3009
         * Get the specified configuration value.
3010
         *
3011
         * @param array|string $key
3012
         * @param mixed $default
3013
         * @return mixed 
3014
         * @static 
3015
         */ 
3016
        public static function get($key, $default = null)
3017
        {
3018
            return \Illuminate\Config\Repository::get($key, $default);
3019
        }
3020
        
3021
        /**
3022
         * Get many configuration values.
3023
         *
3024
         * @param array $keys
3025
         * @return array 
3026
         * @static 
3027
         */ 
3028
        public static function getMany($keys)
3029
        {
3030
            return \Illuminate\Config\Repository::getMany($keys);
3031
        }
3032
        
3033
        /**
3034
         * Set a given configuration value.
3035
         *
3036
         * @param array|string $key
3037
         * @param mixed $value
3038
         * @return void 
3039
         * @static 
3040
         */ 
3041
        public static function set($key, $value = null)
3042
        {
3043
            \Illuminate\Config\Repository::set($key, $value);
3044
        }
3045
        
3046
        /**
3047
         * Prepend a value onto an array configuration value.
3048
         *
3049
         * @param string $key
3050
         * @param mixed $value
3051
         * @return void 
3052
         * @static 
3053
         */ 
3054
        public static function prepend($key, $value)
3055
        {
3056
            \Illuminate\Config\Repository::prepend($key, $value);
3057
        }
3058
        
3059
        /**
3060
         * Push a value onto an array configuration value.
3061
         *
3062
         * @param string $key
3063
         * @param mixed $value
3064
         * @return void 
3065
         * @static 
3066
         */ 
3067
        public static function push($key, $value)
3068
        {
3069
            \Illuminate\Config\Repository::push($key, $value);
3070
        }
3071
        
3072
        /**
3073
         * Get all of the configuration items for the application.
3074
         *
3075
         * @return array 
3076
         * @static 
3077
         */ 
3078
        public static function all()
3079
        {
3080
            return \Illuminate\Config\Repository::all();
3081
        }
3082
        
3083
        /**
3084
         * Determine if the given configuration option exists.
3085
         *
3086
         * @param string $key
3087
         * @return bool 
3088
         * @static 
3089
         */ 
3090
        public static function offsetExists($key)
3091
        {
3092
            return \Illuminate\Config\Repository::offsetExists($key);
3093
        }
3094
        
3095
        /**
3096
         * Get a configuration option.
3097
         *
3098
         * @param string $key
3099
         * @return mixed 
3100
         * @static 
3101
         */ 
3102
        public static function offsetGet($key)
3103
        {
3104
            return \Illuminate\Config\Repository::offsetGet($key);
3105
        }
3106
        
3107
        /**
3108
         * Set a configuration option.
3109
         *
3110
         * @param string $key
3111
         * @param mixed $value
3112
         * @return void 
3113
         * @static 
3114
         */ 
3115
        public static function offsetSet($key, $value)
3116
        {
3117
            \Illuminate\Config\Repository::offsetSet($key, $value);
3118
        }
3119
        
3120
        /**
3121
         * Unset a configuration option.
3122
         *
3123
         * @param string $key
3124
         * @return void 
3125
         * @static 
3126
         */ 
3127
        public static function offsetUnset($key)
3128
        {
3129
            \Illuminate\Config\Repository::offsetUnset($key);
3130
        }
3131
         
3132
    }
3133

3134
    class Cookie {
3135
        
3136
        /**
3137
         * Create a new cookie instance.
3138
         *
3139
         * @param string $name
3140
         * @param string $value
3141
         * @param int $minutes
3142
         * @param string $path
3143
         * @param string $domain
3144
         * @param bool|null $secure
3145
         * @param bool $httpOnly
3146
         * @param bool $raw
3147
         * @param string|null $sameSite
3148
         * @return \Symfony\Component\HttpFoundation\Cookie 
3149
         * @static 
3150
         */ 
3151
        public static function make($name, $value, $minutes = 0, $path = null, $domain = null, $secure = null, $httpOnly = true, $raw = false, $sameSite = null)
3152
        {
3153
            return \Illuminate\Cookie\CookieJar::make($name, $value, $minutes, $path, $domain, $secure, $httpOnly, $raw, $sameSite);
3154
        }
3155
        
3156
        /**
3157
         * Create a cookie that lasts "forever" (five years).
3158
         *
3159
         * @param string $name
3160
         * @param string $value
3161
         * @param string $path
3162
         * @param string $domain
3163
         * @param bool|null $secure
3164
         * @param bool $httpOnly
3165
         * @param bool $raw
3166
         * @param string|null $sameSite
3167
         * @return \Symfony\Component\HttpFoundation\Cookie 
3168
         * @static 
3169
         */ 
3170
        public static function forever($name, $value, $path = null, $domain = null, $secure = null, $httpOnly = true, $raw = false, $sameSite = null)
3171
        {
3172
            return \Illuminate\Cookie\CookieJar::forever($name, $value, $path, $domain, $secure, $httpOnly, $raw, $sameSite);
3173
        }
3174
        
3175
        /**
3176
         * Expire the given cookie.
3177
         *
3178
         * @param string $name
3179
         * @param string $path
3180
         * @param string $domain
3181
         * @return \Symfony\Component\HttpFoundation\Cookie 
3182
         * @static 
3183
         */ 
3184
        public static function forget($name, $path = null, $domain = null)
3185
        {
3186
            return \Illuminate\Cookie\CookieJar::forget($name, $path, $domain);
3187
        }
3188
        
3189
        /**
3190
         * Determine if a cookie has been queued.
3191
         *
3192
         * @param string $key
3193
         * @return bool 
3194
         * @static 
3195
         */ 
3196
        public static function hasQueued($key)
3197
        {
3198
            return \Illuminate\Cookie\CookieJar::hasQueued($key);
3199
        }
3200
        
3201
        /**
3202
         * Get a queued cookie instance.
3203
         *
3204
         * @param string $key
3205
         * @param mixed $default
3206
         * @return \Symfony\Component\HttpFoundation\Cookie 
3207
         * @static 
3208
         */ 
3209
        public static function queued($key, $default = null)
3210
        {
3211
            return \Illuminate\Cookie\CookieJar::queued($key, $default);
3212
        }
3213
        
3214
        /**
3215
         * Queue a cookie to send with the next response.
3216
         *
3217
         * @param array $parameters
3218
         * @return void 
3219
         * @static 
3220
         */ 
3221
        public static function queue($parameters = null)
3222
        {
3223
            \Illuminate\Cookie\CookieJar::queue($parameters);
3224
        }
3225
        
3226
        /**
3227
         * Remove a cookie from the queue.
3228
         *
3229
         * @param string $name
3230
         * @return void 
3231
         * @static 
3232
         */ 
3233
        public static function unqueue($name)
3234
        {
3235
            \Illuminate\Cookie\CookieJar::unqueue($name);
3236
        }
3237
        
3238
        /**
3239
         * Set the default path and domain for the jar.
3240
         *
3241
         * @param string $path
3242
         * @param string $domain
3243
         * @param bool $secure
3244
         * @param string $sameSite
3245
         * @return $this 
3246
         * @static 
3247
         */ 
3248
        public static function setDefaultPathAndDomain($path, $domain, $secure = false, $sameSite = null)
3249
        {
3250
            return \Illuminate\Cookie\CookieJar::setDefaultPathAndDomain($path, $domain, $secure, $sameSite);
3251
        }
3252
        
3253
        /**
3254
         * Get the cookies which have been queued for the next request.
3255
         *
3256
         * @return \Symfony\Component\HttpFoundation\Cookie[] 
3257
         * @static 
3258
         */ 
3259
        public static function getQueuedCookies()
3260
        {
3261
            return \Illuminate\Cookie\CookieJar::getQueuedCookies();
3262
        }
3263
         
3264
    }
3265

3266
    class Crypt {
3267
        
3268
        /**
3269
         * Determine if the given key and cipher combination is valid.
3270
         *
3271
         * @param string $key
3272
         * @param string $cipher
3273
         * @return bool 
3274
         * @static 
3275
         */ 
3276
        public static function supported($key, $cipher)
3277
        {
3278
            return \Illuminate\Encryption\Encrypter::supported($key, $cipher);
3279
        }
3280
        
3281
        /**
3282
         * Create a new encryption key for the given cipher.
3283
         *
3284
         * @param string $cipher
3285
         * @return string 
3286
         * @static 
3287
         */ 
3288
        public static function generateKey($cipher)
3289
        {
3290
            return \Illuminate\Encryption\Encrypter::generateKey($cipher);
3291
        }
3292
        
3293
        /**
3294
         * Encrypt the given value.
3295
         *
3296
         * @param mixed $value
3297
         * @param bool $serialize
3298
         * @return string 
3299
         * @throws \Illuminate\Contracts\Encryption\EncryptException
3300
         * @static 
3301
         */ 
3302
        public static function encrypt($value, $serialize = true)
3303
        {
3304
            return \Illuminate\Encryption\Encrypter::encrypt($value, $serialize);
3305
        }
3306
        
3307
        /**
3308
         * Encrypt a string without serialization.
3309
         *
3310
         * @param string $value
3311
         * @return string 
3312
         * @static 
3313
         */ 
3314
        public static function encryptString($value)
3315
        {
3316
            return \Illuminate\Encryption\Encrypter::encryptString($value);
3317
        }
3318
        
3319
        /**
3320
         * Decrypt the given value.
3321
         *
3322
         * @param mixed $payload
3323
         * @param bool $unserialize
3324
         * @return string 
3325
         * @throws \Illuminate\Contracts\Encryption\DecryptException
3326
         * @static 
3327
         */ 
3328
        public static function decrypt($payload, $unserialize = true)
3329
        {
3330
            return \Illuminate\Encryption\Encrypter::decrypt($payload, $unserialize);
3331
        }
3332
        
3333
        /**
3334
         * Decrypt the given string without unserialization.
3335
         *
3336
         * @param string $payload
3337
         * @return string 
3338
         * @static 
3339
         */ 
3340
        public static function decryptString($payload)
3341
        {
3342
            return \Illuminate\Encryption\Encrypter::decryptString($payload);
3343
        }
3344
        
3345
        /**
3346
         * Get the encryption key.
3347
         *
3348
         * @return string 
3349
         * @static 
3350
         */ 
3351
        public static function getKey()
3352
        {
3353
            return \Illuminate\Encryption\Encrypter::getKey();
3354
        }
3355
         
3356
    }
3357

3358
    class DB {
3359
        
3360
        /**
3361
         * Get a database connection instance.
3362
         *
3363
         * @param string $name
3364
         * @return \Illuminate\Database\Connection 
3365
         * @static 
3366
         */ 
3367
        public static function connection($name = null)
3368
        {
3369
            return \Illuminate\Database\DatabaseManager::connection($name);
3370
        }
3371
        
3372
        /**
3373
         * Disconnect from the given database and remove from local cache.
3374
         *
3375
         * @param string $name
3376
         * @return void 
3377
         * @static 
3378
         */ 
3379
        public static function purge($name = null)
3380
        {
3381
            \Illuminate\Database\DatabaseManager::purge($name);
3382
        }
3383
        
3384
        /**
3385
         * Disconnect from the given database.
3386
         *
3387
         * @param string $name
3388
         * @return void 
3389
         * @static 
3390
         */ 
3391
        public static function disconnect($name = null)
3392
        {
3393
            \Illuminate\Database\DatabaseManager::disconnect($name);
3394
        }
3395
        
3396
        /**
3397
         * Reconnect to the given database.
3398
         *
3399
         * @param string $name
3400
         * @return \Illuminate\Database\Connection 
3401
         * @static 
3402
         */ 
3403
        public static function reconnect($name = null)
3404
        {
3405
            return \Illuminate\Database\DatabaseManager::reconnect($name);
3406
        }
3407
        
3408
        /**
3409
         * Get the default connection name.
3410
         *
3411
         * @return string 
3412
         * @static 
3413
         */ 
3414
        public static function getDefaultConnection()
3415
        {
3416
            return \Illuminate\Database\DatabaseManager::getDefaultConnection();
3417
        }
3418
        
3419
        /**
3420
         * Set the default connection name.
3421
         *
3422
         * @param string $name
3423
         * @return void 
3424
         * @static 
3425
         */ 
3426
        public static function setDefaultConnection($name)
3427
        {
3428
            \Illuminate\Database\DatabaseManager::setDefaultConnection($name);
3429
        }
3430
        
3431
        /**
3432
         * Get all of the support drivers.
3433
         *
3434
         * @return array 
3435
         * @static 
3436
         */ 
3437
        public static function supportedDrivers()
3438
        {
3439
            return \Illuminate\Database\DatabaseManager::supportedDrivers();
3440
        }
3441
        
3442
        /**
3443
         * Get all of the drivers that are actually available.
3444
         *
3445
         * @return array 
3446
         * @static 
3447
         */ 
3448
        public static function availableDrivers()
3449
        {
3450
            return \Illuminate\Database\DatabaseManager::availableDrivers();
3451
        }
3452
        
3453
        /**
3454
         * Register an extension connection resolver.
3455
         *
3456
         * @param string $name
3457
         * @param callable $resolver
3458
         * @return void 
3459
         * @static 
3460
         */ 
3461
        public static function extend($name, $resolver)
3462
        {
3463
            \Illuminate\Database\DatabaseManager::extend($name, $resolver);
3464
        }
3465
        
3466
        /**
3467
         * Return all of the created connections.
3468
         *
3469
         * @return array 
3470
         * @static 
3471
         */ 
3472
        public static function getConnections()
3473
        {
3474
            return \Illuminate\Database\DatabaseManager::getConnections();
3475
        }
3476
        
3477
        /**
3478
         * Get a schema builder instance for the connection.
3479
         *
3480
         * @return \Illuminate\Database\Schema\MySqlBuilder 
3481
         * @static 
3482
         */ 
3483
        public static function getSchemaBuilder()
3484
        {
3485
            return \Illuminate\Database\MySqlConnection::getSchemaBuilder();
3486
        }
3487
        
3488
        /**
3489
         * Bind values to their parameters in the given statement.
3490
         *
3491
         * @param \PDOStatement $statement
3492
         * @param array $bindings
3493
         * @return void 
3494
         * @static 
3495
         */ 
3496
        public static function bindValues($statement, $bindings)
3497
        {
3498
            \Illuminate\Database\MySqlConnection::bindValues($statement, $bindings);
3499
        }
3500
        
3501
        /**
3502
         * Set the query grammar to the default implementation.
3503
         *
3504
         * @return void 
3505
         * @static 
3506
         */ 
3507
        public static function useDefaultQueryGrammar()
3508
        {
3509
            //Method inherited from \Illuminate\Database\Connection            
3510
            \Illuminate\Database\MySqlConnection::useDefaultQueryGrammar();
3511
        }
3512
        
3513
        /**
3514
         * Set the schema grammar to the default implementation.
3515
         *
3516
         * @return void 
3517
         * @static 
3518
         */ 
3519
        public static function useDefaultSchemaGrammar()
3520
        {
3521
            //Method inherited from \Illuminate\Database\Connection            
3522
            \Illuminate\Database\MySqlConnection::useDefaultSchemaGrammar();
3523
        }
3524
        
3525
        /**
3526
         * Set the query post processor to the default implementation.
3527
         *
3528
         * @return void 
3529
         * @static 
3530
         */ 
3531
        public static function useDefaultPostProcessor()
3532
        {
3533
            //Method inherited from \Illuminate\Database\Connection            
3534
            \Illuminate\Database\MySqlConnection::useDefaultPostProcessor();
3535
        }
3536
        
3537
        /**
3538
         * Begin a fluent query against a database table.
3539
         *
3540
         * @param string $table
3541
         * @return \Illuminate\Database\Query\Builder 
3542
         * @static 
3543
         */ 
3544
        public static function table($table)
3545
        {
3546
            //Method inherited from \Illuminate\Database\Connection            
3547
            return \Illuminate\Database\MySqlConnection::table($table);
3548
        }
3549
        
3550
        /**
3551
         * Get a new query builder instance.
3552
         *
3553
         * @return \Illuminate\Database\Query\Builder 
3554
         * @static 
3555
         */ 
3556
        public static function query()
3557
        {
3558
            //Method inherited from \Illuminate\Database\Connection            
3559
            return \Illuminate\Database\MySqlConnection::query();
3560
        }
3561
        
3562
        /**
3563
         * Run a select statement and return a single result.
3564
         *
3565
         * @param string $query
3566
         * @param array $bindings
3567
         * @param bool $useReadPdo
3568
         * @return mixed 
3569
         * @static 
3570
         */ 
3571
        public static function selectOne($query, $bindings = array(), $useReadPdo = true)
3572
        {
3573
            //Method inherited from \Illuminate\Database\Connection            
3574
            return \Illuminate\Database\MySqlConnection::selectOne($query, $bindings, $useReadPdo);
3575
        }
3576
        
3577
        /**
3578
         * Run a select statement against the database.
3579
         *
3580
         * @param string $query
3581
         * @param array $bindings
3582
         * @return array 
3583
         * @static 
3584
         */ 
3585
        public static function selectFromWriteConnection($query, $bindings = array())
3586
        {
3587
            //Method inherited from \Illuminate\Database\Connection            
3588
            return \Illuminate\Database\MySqlConnection::selectFromWriteConnection($query, $bindings);
3589
        }
3590
        
3591
        /**
3592
         * Run a select statement against the database.
3593
         *
3594
         * @param string $query
3595
         * @param array $bindings
3596
         * @param bool $useReadPdo
3597
         * @return array 
3598
         * @static 
3599
         */ 
3600
        public static function select($query, $bindings = array(), $useReadPdo = true)
3601
        {
3602
            //Method inherited from \Illuminate\Database\Connection            
3603
            return \Illuminate\Database\MySqlConnection::select($query, $bindings, $useReadPdo);
3604
        }
3605
        
3606
        /**
3607
         * Run a select statement against the database and returns a generator.
3608
         *
3609
         * @param string $query
3610
         * @param array $bindings
3611
         * @param bool $useReadPdo
3612
         * @return \Generator 
3613
         * @static 
3614
         */ 
3615
        public static function cursor($query, $bindings = array(), $useReadPdo = true)
3616
        {
3617
            //Method inherited from \Illuminate\Database\Connection            
3618
            return \Illuminate\Database\MySqlConnection::cursor($query, $bindings, $useReadPdo);
3619
        }
3620
        
3621
        /**
3622
         * Run an insert statement against the database.
3623
         *
3624
         * @param string $query
3625
         * @param array $bindings
3626
         * @return bool 
3627
         * @static 
3628
         */ 
3629
        public static function insert($query, $bindings = array())
3630
        {
3631
            //Method inherited from \Illuminate\Database\Connection            
3632
            return \Illuminate\Database\MySqlConnection::insert($query, $bindings);
3633
        }
3634
        
3635
        /**
3636
         * Run an update statement against the database.
3637
         *
3638
         * @param string $query
3639
         * @param array $bindings
3640
         * @return int 
3641
         * @static 
3642
         */ 
3643
        public static function update($query, $bindings = array())
3644
        {
3645
            //Method inherited from \Illuminate\Database\Connection            
3646
            return \Illuminate\Database\MySqlConnection::update($query, $bindings);
3647
        }
3648
        
3649
        /**
3650
         * Run a delete statement against the database.
3651
         *
3652
         * @param string $query
3653
         * @param array $bindings
3654
         * @return int 
3655
         * @static 
3656
         */ 
3657
        public static function delete($query, $bindings = array())
3658
        {
3659
            //Method inherited from \Illuminate\Database\Connection            
3660
            return \Illuminate\Database\MySqlConnection::delete($query, $bindings);
3661
        }
3662
        
3663
        /**
3664
         * Execute an SQL statement and return the boolean result.
3665
         *
3666
         * @param string $query
3667
         * @param array $bindings
3668
         * @return bool 
3669
         * @static 
3670
         */ 
3671
        public static function statement($query, $bindings = array())
3672
        {
3673
            //Method inherited from \Illuminate\Database\Connection            
3674
            return \Illuminate\Database\MySqlConnection::statement($query, $bindings);
3675
        }
3676
        
3677
        /**
3678
         * Run an SQL statement and get the number of rows affected.
3679
         *
3680
         * @param string $query
3681
         * @param array $bindings
3682
         * @return int 
3683
         * @static 
3684
         */ 
3685
        public static function affectingStatement($query, $bindings = array())
3686
        {
3687
            //Method inherited from \Illuminate\Database\Connection            
3688
            return \Illuminate\Database\MySqlConnection::affectingStatement($query, $bindings);
3689
        }
3690
        
3691
        /**
3692
         * Run a raw, unprepared query against the PDO connection.
3693
         *
3694
         * @param string $query
3695
         * @return bool 
3696
         * @static 
3697
         */ 
3698
        public static function unprepared($query)
3699
        {
3700
            //Method inherited from \Illuminate\Database\Connection            
3701
            return \Illuminate\Database\MySqlConnection::unprepared($query);
3702
        }
3703
        
3704
        /**
3705
         * Execute the given callback in "dry run" mode.
3706
         *
3707
         * @param \Closure $callback
3708
         * @return array 
3709
         * @static 
3710
         */ 
3711
        public static function pretend($callback)
3712
        {
3713
            //Method inherited from \Illuminate\Database\Connection            
3714
            return \Illuminate\Database\MySqlConnection::pretend($callback);
3715
        }
3716
        
3717
        /**
3718
         * Prepare the query bindings for execution.
3719
         *
3720
         * @param array $bindings
3721
         * @return array 
3722
         * @static 
3723
         */ 
3724
        public static function prepareBindings($bindings)
3725
        {
3726
            //Method inherited from \Illuminate\Database\Connection            
3727
            return \Illuminate\Database\MySqlConnection::prepareBindings($bindings);
3728
        }
3729
        
3730
        /**
3731
         * Log a query in the connection's query log.
3732
         *
3733
         * @param string $query
3734
         * @param array $bindings
3735
         * @param float|null $time
3736
         * @return void 
3737
         * @static 
3738
         */ 
3739
        public static function logQuery($query, $bindings, $time = null)
3740
        {
3741
            //Method inherited from \Illuminate\Database\Connection            
3742
            \Illuminate\Database\MySqlConnection::logQuery($query, $bindings, $time);
3743
        }
3744
        
3745
        /**
3746
         * Register a database query listener with the connection.
3747
         *
3748
         * @param \Closure $callback
3749
         * @return void 
3750
         * @static 
3751
         */ 
3752
        public static function listen($callback)
3753
        {
3754
            //Method inherited from \Illuminate\Database\Connection            
3755
            \Illuminate\Database\MySqlConnection::listen($callback);
3756
        }
3757
        
3758
        /**
3759
         * Get a new raw query expression.
3760
         *
3761
         * @param mixed $value
3762
         * @return \Illuminate\Database\Query\Expression 
3763
         * @static 
3764
         */ 
3765
        public static function raw($value)
3766
        {
3767
            //Method inherited from \Illuminate\Database\Connection            
3768
            return \Illuminate\Database\MySqlConnection::raw($value);
3769
        }
3770
        
3771
        /**
3772
         * Indicate if any records have been modified.
3773
         *
3774
         * @param bool $value
3775
         * @return void 
3776
         * @static 
3777
         */ 
3778
        public static function recordsHaveBeenModified($value = true)
3779
        {
3780
            //Method inherited from \Illuminate\Database\Connection            
3781
            \Illuminate\Database\MySqlConnection::recordsHaveBeenModified($value);
3782
        }
3783
        
3784
        /**
3785
         * Is Doctrine available?
3786
         *
3787
         * @return bool 
3788
         * @static 
3789
         */ 
3790
        public static function isDoctrineAvailable()
3791
        {
3792
            //Method inherited from \Illuminate\Database\Connection            
3793
            return \Illuminate\Database\MySqlConnection::isDoctrineAvailable();
3794
        }
3795
        
3796
        /**
3797
         * Get a Doctrine Schema Column instance.
3798
         *
3799
         * @param string $table
3800
         * @param string $column
3801
         * @return \Doctrine\DBAL\Schema\Column 
3802
         * @static 
3803
         */ 
3804
        public static function getDoctrineColumn($table, $column)
3805
        {
3806
            //Method inherited from \Illuminate\Database\Connection            
3807
            return \Illuminate\Database\MySqlConnection::getDoctrineColumn($table, $column);
3808
        }
3809
        
3810
        /**
3811
         * Get the Doctrine DBAL schema manager for the connection.
3812
         *
3813
         * @return \Doctrine\DBAL\Schema\AbstractSchemaManager 
3814
         * @static 
3815
         */ 
3816
        public static function getDoctrineSchemaManager()
3817
        {
3818
            //Method inherited from \Illuminate\Database\Connection            
3819
            return \Illuminate\Database\MySqlConnection::getDoctrineSchemaManager();
3820
        }
3821
        
3822
        /**
3823
         * Get the Doctrine DBAL database connection instance.
3824
         *
3825
         * @return \Doctrine\DBAL\Connection 
3826
         * @static 
3827
         */ 
3828
        public static function getDoctrineConnection()
3829
        {
3830
            //Method inherited from \Illuminate\Database\Connection            
3831
            return \Illuminate\Database\MySqlConnection::getDoctrineConnection();
3832
        }
3833
        
3834
        /**
3835
         * Get the current PDO connection.
3836
         *
3837
         * @return \PDO 
3838
         * @static 
3839
         */ 
3840
        public static function getPdo()
3841
        {
3842
            //Method inherited from \Illuminate\Database\Connection            
3843
            return \Illuminate\Database\MySqlConnection::getPdo();
3844
        }
3845
        
3846
        /**
3847
         * Get the current PDO connection used for reading.
3848
         *
3849
         * @return \PDO 
3850
         * @static 
3851
         */ 
3852
        public static function getReadPdo()
3853
        {
3854
            //Method inherited from \Illuminate\Database\Connection            
3855
            return \Illuminate\Database\MySqlConnection::getReadPdo();
3856
        }
3857
        
3858
        /**
3859
         * Set the PDO connection.
3860
         *
3861
         * @param \PDO|\Closure|null $pdo
3862
         * @return $this 
3863
         * @static 
3864
         */ 
3865
        public static function setPdo($pdo)
3866
        {
3867
            //Method inherited from \Illuminate\Database\Connection            
3868
            return \Illuminate\Database\MySqlConnection::setPdo($pdo);
3869
        }
3870
        
3871
        /**
3872
         * Set the PDO connection used for reading.
3873
         *
3874
         * @param \PDO|\Closure|null $pdo
3875
         * @return $this 
3876
         * @static 
3877
         */ 
3878
        public static function setReadPdo($pdo)
3879
        {
3880
            //Method inherited from \Illuminate\Database\Connection            
3881
            return \Illuminate\Database\MySqlConnection::setReadPdo($pdo);
3882
        }
3883
        
3884
        /**
3885
         * Set the reconnect instance on the connection.
3886
         *
3887
         * @param callable $reconnector
3888
         * @return $this 
3889
         * @static 
3890
         */ 
3891
        public static function setReconnector($reconnector)
3892
        {
3893
            //Method inherited from \Illuminate\Database\Connection            
3894
            return \Illuminate\Database\MySqlConnection::setReconnector($reconnector);
3895
        }
3896
        
3897
        /**
3898
         * Get the database connection name.
3899
         *
3900
         * @return string|null 
3901
         * @static 
3902
         */ 
3903
        public static function getName()
3904
        {
3905
            //Method inherited from \Illuminate\Database\Connection            
3906
            return \Illuminate\Database\MySqlConnection::getName();
3907
        }
3908
        
3909
        /**
3910
         * Get an option from the configuration options.
3911
         *
3912
         * @param string|null $option
3913
         * @return mixed 
3914
         * @static 
3915
         */ 
3916
        public static function getConfig($option = null)
3917
        {
3918
            //Method inherited from \Illuminate\Database\Connection            
3919
            return \Illuminate\Database\MySqlConnection::getConfig($option);
3920
        }
3921
        
3922
        /**
3923
         * Get the PDO driver name.
3924
         *
3925
         * @return string 
3926
         * @static 
3927
         */ 
3928
        public static function getDriverName()
3929
        {
3930
            //Method inherited from \Illuminate\Database\Connection            
3931
            return \Illuminate\Database\MySqlConnection::getDriverName();
3932
        }
3933
        
3934
        /**
3935
         * Get the query grammar used by the connection.
3936
         *
3937
         * @return \Illuminate\Database\Query\Grammars\Grammar 
3938
         * @static 
3939
         */ 
3940
        public static function getQueryGrammar()
3941
        {
3942
            //Method inherited from \Illuminate\Database\Connection            
3943
            return \Illuminate\Database\MySqlConnection::getQueryGrammar();
3944
        }
3945
        
3946
        /**
3947
         * Set the query grammar used by the connection.
3948
         *
3949
         * @param \Illuminate\Database\Query\Grammars\Grammar $grammar
3950
         * @return void 
3951
         * @static 
3952
         */ 
3953
        public static function setQueryGrammar($grammar)
3954
        {
3955
            //Method inherited from \Illuminate\Database\Connection            
3956
            \Illuminate\Database\MySqlConnection::setQueryGrammar($grammar);
3957
        }
3958
        
3959
        /**
3960
         * Get the schema grammar used by the connection.
3961
         *
3962
         * @return \Illuminate\Database\Schema\Grammars\Grammar 
3963
         * @static 
3964
         */ 
3965
        public static function getSchemaGrammar()
3966
        {
3967
            //Method inherited from \Illuminate\Database\Connection            
3968
            return \Illuminate\Database\MySqlConnection::getSchemaGrammar();
3969
        }
3970
        
3971
        /**
3972
         * Set the schema grammar used by the connection.
3973
         *
3974
         * @param \Illuminate\Database\Schema\Grammars\Grammar $grammar
3975
         * @return void 
3976
         * @static 
3977
         */ 
3978
        public static function setSchemaGrammar($grammar)
3979
        {
3980
            //Method inherited from \Illuminate\Database\Connection            
3981
            \Illuminate\Database\MySqlConnection::setSchemaGrammar($grammar);
3982
        }
3983
        
3984
        /**
3985
         * Get the query post processor used by the connection.
3986
         *
3987
         * @return \Illuminate\Database\Query\Processors\Processor 
3988
         * @static 
3989
         */ 
3990
        public static function getPostProcessor()
3991
        {
3992
            //Method inherited from \Illuminate\Database\Connection            
3993
            return \Illuminate\Database\MySqlConnection::getPostProcessor();
3994
        }
3995
        
3996
        /**
3997
         * Set the query post processor used by the connection.
3998
         *
3999
         * @param \Illuminate\Database\Query\Processors\Processor $processor
4000
         * @return void 
4001
         * @static 
4002
         */ 
4003
        public static function setPostProcessor($processor)
4004
        {
4005
            //Method inherited from \Illuminate\Database\Connection            
4006
            \Illuminate\Database\MySqlConnection::setPostProcessor($processor);
4007
        }
4008
        
4009
        /**
4010
         * Get the event dispatcher used by the connection.
4011
         *
4012
         * @return \Illuminate\Contracts\Events\Dispatcher 
4013
         * @static 
4014
         */ 
4015
        public static function getEventDispatcher()
4016
        {
4017
            //Method inherited from \Illuminate\Database\Connection            
4018
            return \Illuminate\Database\MySqlConnection::getEventDispatcher();
4019
        }
4020
        
4021
        /**
4022
         * Set the event dispatcher instance on the connection.
4023
         *
4024
         * @param \Illuminate\Contracts\Events\Dispatcher $events
4025
         * @return void 
4026
         * @static 
4027
         */ 
4028
        public static function setEventDispatcher($events)
4029
        {
4030
            //Method inherited from \Illuminate\Database\Connection            
4031
            \Illuminate\Database\MySqlConnection::setEventDispatcher($events);
4032
        }
4033
        
4034
        /**
4035
         * Determine if the connection in a "dry run".
4036
         *
4037
         * @return bool 
4038
         * @static 
4039
         */ 
4040
        public static function pretending()
4041
        {
4042
            //Method inherited from \Illuminate\Database\Connection            
4043
            return \Illuminate\Database\MySqlConnection::pretending();
4044
        }
4045
        
4046
        /**
4047
         * Get the connection query log.
4048
         *
4049
         * @return array 
4050
         * @static 
4051
         */ 
4052
        public static function getQueryLog()
4053
        {
4054
            //Method inherited from \Illuminate\Database\Connection            
4055
            return \Illuminate\Database\MySqlConnection::getQueryLog();
4056
        }
4057
        
4058
        /**
4059
         * Clear the query log.
4060
         *
4061
         * @return void 
4062
         * @static 
4063
         */ 
4064
        public static function flushQueryLog()
4065
        {
4066
            //Method inherited from \Illuminate\Database\Connection            
4067
            \Illuminate\Database\MySqlConnection::flushQueryLog();
4068
        }
4069
        
4070
        /**
4071
         * Enable the query log on the connection.
4072
         *
4073
         * @return void 
4074
         * @static 
4075
         */ 
4076
        public static function enableQueryLog()
4077
        {
4078
            //Method inherited from \Illuminate\Database\Connection            
4079
            \Illuminate\Database\MySqlConnection::enableQueryLog();
4080
        }
4081
        
4082
        /**
4083
         * Disable the query log on the connection.
4084
         *
4085
         * @return void 
4086
         * @static 
4087
         */ 
4088
        public static function disableQueryLog()
4089
        {
4090
            //Method inherited from \Illuminate\Database\Connection            
4091
            \Illuminate\Database\MySqlConnection::disableQueryLog();
4092
        }
4093
        
4094
        /**
4095
         * Determine whether we're logging queries.
4096
         *
4097
         * @return bool 
4098
         * @static 
4099
         */ 
4100
        public static function logging()
4101
        {
4102
            //Method inherited from \Illuminate\Database\Connection            
4103
            return \Illuminate\Database\MySqlConnection::logging();
4104
        }
4105
        
4106
        /**
4107
         * Get the name of the connected database.
4108
         *
4109
         * @return string 
4110
         * @static 
4111
         */ 
4112
        public static function getDatabaseName()
4113
        {
4114
            //Method inherited from \Illuminate\Database\Connection            
4115
            return \Illuminate\Database\MySqlConnection::getDatabaseName();
4116
        }
4117
        
4118
        /**
4119
         * Set the name of the connected database.
4120
         *
4121
         * @param string $database
4122
         * @return string 
4123
         * @static 
4124
         */ 
4125
        public static function setDatabaseName($database)
4126
        {
4127
            //Method inherited from \Illuminate\Database\Connection            
4128
            return \Illuminate\Database\MySqlConnection::setDatabaseName($database);
4129
        }
4130
        
4131
        /**
4132
         * Get the table prefix for the connection.
4133
         *
4134
         * @return string 
4135
         * @static 
4136
         */ 
4137
        public static function getTablePrefix()
4138
        {
4139
            //Method inherited from \Illuminate\Database\Connection            
4140
            return \Illuminate\Database\MySqlConnection::getTablePrefix();
4141
        }
4142
        
4143
        /**
4144
         * Set the table prefix in use by the connection.
4145
         *
4146
         * @param string $prefix
4147
         * @return void 
4148
         * @static 
4149
         */ 
4150
        public static function setTablePrefix($prefix)
4151
        {
4152
            //Method inherited from \Illuminate\Database\Connection            
4153
            \Illuminate\Database\MySqlConnection::setTablePrefix($prefix);
4154
        }
4155
        
4156
        /**
4157
         * Set the table prefix and return the grammar.
4158
         *
4159
         * @param \Illuminate\Database\Grammar $grammar
4160
         * @return \Illuminate\Database\Grammar 
4161
         * @static 
4162
         */ 
4163
        public static function withTablePrefix($grammar)
4164
        {
4165
            //Method inherited from \Illuminate\Database\Connection            
4166
            return \Illuminate\Database\MySqlConnection::withTablePrefix($grammar);
4167
        }
4168
        
4169
        /**
4170
         * Register a connection resolver.
4171
         *
4172
         * @param string $driver
4173
         * @param \Closure $callback
4174
         * @return void 
4175
         * @static 
4176
         */ 
4177
        public static function resolverFor($driver, $callback)
4178
        {
4179
            //Method inherited from \Illuminate\Database\Connection            
4180
            \Illuminate\Database\MySqlConnection::resolverFor($driver, $callback);
4181
        }
4182
        
4183
        /**
4184
         * Get the connection resolver for the given driver.
4185
         *
4186
         * @param string $driver
4187
         * @return mixed 
4188
         * @static 
4189
         */ 
4190
        public static function getResolver($driver)
4191
        {
4192
            //Method inherited from \Illuminate\Database\Connection            
4193
            return \Illuminate\Database\MySqlConnection::getResolver($driver);
4194
        }
4195
        
4196
        /**
4197
         * Execute a Closure within a transaction.
4198
         *
4199
         * @param \Closure $callback
4200
         * @param int $attempts
4201
         * @return mixed 
4202
         * @throws \Exception|\Throwable
4203
         * @static 
4204
         */ 
4205
        public static function transaction($callback, $attempts = 1)
4206
        {
4207
            //Method inherited from \Illuminate\Database\Connection            
4208
            return \Illuminate\Database\MySqlConnection::transaction($callback, $attempts);
4209
        }
4210
        
4211
        /**
4212
         * Start a new database transaction.
4213
         *
4214
         * @return void 
4215
         * @throws \Exception
4216
         * @static 
4217
         */ 
4218
        public static function beginTransaction()
4219
        {
4220
            //Method inherited from \Illuminate\Database\Connection            
4221
            \Illuminate\Database\MySqlConnection::beginTransaction();
4222
        }
4223
        
4224
        /**
4225
         * Commit the active database transaction.
4226
         *
4227
         * @return void 
4228
         * @static 
4229
         */ 
4230
        public static function commit()
4231
        {
4232
            //Method inherited from \Illuminate\Database\Connection            
4233
            \Illuminate\Database\MySqlConnection::commit();
4234
        }
4235
        
4236
        /**
4237
         * Rollback the active database transaction.
4238
         *
4239
         * @param int|null $toLevel
4240
         * @return void 
4241
         * @static 
4242
         */ 
4243
        public static function rollBack($toLevel = null)
4244
        {
4245
            //Method inherited from \Illuminate\Database\Connection            
4246
            \Illuminate\Database\MySqlConnection::rollBack($toLevel);
4247
        }
4248
        
4249
        /**
4250
         * Get the number of active transactions.
4251
         *
4252
         * @return int 
4253
         * @static 
4254
         */ 
4255
        public static function transactionLevel()
4256
        {
4257
            //Method inherited from \Illuminate\Database\Connection            
4258
            return \Illuminate\Database\MySqlConnection::transactionLevel();
4259
        }
4260
         
4261
    }
4262

4263
    class Event {
4264
        
4265
        /**
4266
         * Register an event listener with the dispatcher.
4267
         *
4268
         * @param string|array $events
4269
         * @param mixed $listener
4270
         * @return void 
4271
         * @static 
4272
         */ 
4273
        public static function listen($events, $listener)
4274
        {
4275
            \Illuminate\Events\Dispatcher::listen($events, $listener);
4276
        }
4277
        
4278
        /**
4279
         * Determine if a given event has listeners.
4280
         *
4281
         * @param string $eventName
4282
         * @return bool 
4283
         * @static 
4284
         */ 
4285
        public static function hasListeners($eventName)
4286
        {
4287
            return \Illuminate\Events\Dispatcher::hasListeners($eventName);
4288
        }
4289
        
4290
        /**
4291
         * Register an event and payload to be fired later.
4292
         *
4293
         * @param string $event
4294
         * @param array $payload
4295
         * @return void 
4296
         * @static 
4297
         */ 
4298
        public static function push($event, $payload = array())
4299
        {
4300
            \Illuminate\Events\Dispatcher::push($event, $payload);
4301
        }
4302
        
4303
        /**
4304
         * Flush a set of pushed events.
4305
         *
4306
         * @param string $event
4307
         * @return void 
4308
         * @static 
4309
         */ 
4310
        public static function flush($event)
4311
        {
4312
            \Illuminate\Events\Dispatcher::flush($event);
4313
        }
4314
        
4315
        /**
4316
         * Register an event subscriber with the dispatcher.
4317
         *
4318
         * @param object|string $subscriber
4319
         * @return void 
4320
         * @static 
4321
         */ 
4322
        public static function subscribe($subscriber)
4323
        {
4324
            \Illuminate\Events\Dispatcher::subscribe($subscriber);
4325
        }
4326
        
4327
        /**
4328
         * Fire an event until the first non-null response is returned.
4329
         *
4330
         * @param string|object $event
4331
         * @param mixed $payload
4332
         * @return array|null 
4333
         * @static 
4334
         */ 
4335
        public static function until($event, $payload = array())
4336
        {
4337
            return \Illuminate\Events\Dispatcher::until($event, $payload);
4338
        }
4339
        
4340
        /**
4341
         * Fire an event and call the listeners.
4342
         *
4343
         * @param string|object $event
4344
         * @param mixed $payload
4345
         * @param bool $halt
4346
         * @return array|null 
4347
         * @static 
4348
         */ 
4349
        public static function fire($event, $payload = array(), $halt = false)
4350
        {
4351
            return \Illuminate\Events\Dispatcher::fire($event, $payload, $halt);
4352
        }
4353
        
4354
        /**
4355
         * Fire an event and call the listeners.
4356
         *
4357
         * @param string|object $event
4358
         * @param mixed $payload
4359
         * @param bool $halt
4360
         * @return array|null 
4361
         * @static 
4362
         */ 
4363
        public static function dispatch($event, $payload = array(), $halt = false)
4364
        {
4365
            return \Illuminate\Events\Dispatcher::dispatch($event, $payload, $halt);
4366
        }
4367
        
4368
        /**
4369
         * Get all of the listeners for a given event name.
4370
         *
4371
         * @param string $eventName
4372
         * @return array 
4373
         * @static 
4374
         */ 
4375
        public static function getListeners($eventName)
4376
        {
4377
            return \Illuminate\Events\Dispatcher::getListeners($eventName);
4378
        }
4379
        
4380
        /**
4381
         * Register an event listener with the dispatcher.
4382
         *
4383
         * @param \Closure|string $listener
4384
         * @param bool $wildcard
4385
         * @return \Closure 
4386
         * @static 
4387
         */ 
4388
        public static function makeListener($listener, $wildcard = false)
4389
        {
4390
            return \Illuminate\Events\Dispatcher::makeListener($listener, $wildcard);
4391
        }
4392
        
4393
        /**
4394
         * Create a class based listener using the IoC container.
4395
         *
4396
         * @param string $listener
4397
         * @param bool $wildcard
4398
         * @return \Closure 
4399
         * @static 
4400
         */ 
4401
        public static function createClassListener($listener, $wildcard = false)
4402
        {
4403
            return \Illuminate\Events\Dispatcher::createClassListener($listener, $wildcard);
4404
        }
4405
        
4406
        /**
4407
         * Remove a set of listeners from the dispatcher.
4408
         *
4409
         * @param string $event
4410
         * @return void 
4411
         * @static 
4412
         */ 
4413
        public static function forget($event)
4414
        {
4415
            \Illuminate\Events\Dispatcher::forget($event);
4416
        }
4417
        
4418
        /**
4419
         * Forget all of the pushed listeners.
4420
         *
4421
         * @return void 
4422
         * @static 
4423
         */ 
4424
        public static function forgetPushed()
4425
        {
4426
            \Illuminate\Events\Dispatcher::forgetPushed();
4427
        }
4428
        
4429
        /**
4430
         * Set the queue resolver implementation.
4431
         *
4432
         * @param callable $resolver
4433
         * @return $this 
4434
         * @static 
4435
         */ 
4436
        public static function setQueueResolver($resolver)
4437
        {
4438
            return \Illuminate\Events\Dispatcher::setQueueResolver($resolver);
4439
        }
4440
         
4441
    }
4442

4443
    class File {
4444
        
4445
        /**
4446
         * Determine if a file or directory exists.
4447
         *
4448
         * @param string $path
4449
         * @return bool 
4450
         * @static 
4451
         */ 
4452
        public static function exists($path)
4453
        {
4454
            return \Illuminate\Filesystem\Filesystem::exists($path);
4455
        }
4456
        
4457
        /**
4458
         * Get the contents of a file.
4459
         *
4460
         * @param string $path
4461
         * @param bool $lock
4462
         * @return string 
4463
         * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
4464
         * @static 
4465
         */ 
4466
        public static function get($path, $lock = false)
4467
        {
4468
            return \Illuminate\Filesystem\Filesystem::get($path, $lock);
4469
        }
4470
        
4471
        /**
4472
         * Get contents of a file with shared access.
4473
         *
4474
         * @param string $path
4475
         * @return string 
4476
         * @static 
4477
         */ 
4478
        public static function sharedGet($path)
4479
        {
4480
            return \Illuminate\Filesystem\Filesystem::sharedGet($path);
4481
        }
4482
        
4483
        /**
4484
         * Get the returned value of a file.
4485
         *
4486
         * @param string $path
4487
         * @return mixed 
4488
         * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
4489
         * @static 
4490
         */ 
4491
        public static function getRequire($path)
4492
        {
4493
            return \Illuminate\Filesystem\Filesystem::getRequire($path);
4494
        }
4495
        
4496
        /**
4497
         * Require the given file once.
4498
         *
4499
         * @param string $file
4500
         * @return mixed 
4501
         * @static 
4502
         */ 
4503
        public static function requireOnce($file)
4504
        {
4505
            return \Illuminate\Filesystem\Filesystem::requireOnce($file);
4506
        }
4507
        
4508
        /**
4509
         * Get the MD5 hash of the file at the given path.
4510
         *
4511
         * @param string $path
4512
         * @return string 
4513
         * @static 
4514
         */ 
4515
        public static function hash($path)
4516
        {
4517
            return \Illuminate\Filesystem\Filesystem::hash($path);
4518
        }
4519
        
4520
        /**
4521
         * Write the contents of a file.
4522
         *
4523
         * @param string $path
4524
         * @param string $contents
4525
         * @param bool $lock
4526
         * @return int 
4527
         * @static 
4528
         */ 
4529
        public static function put($path, $contents, $lock = false)
4530
        {
4531
            return \Illuminate\Filesystem\Filesystem::put($path, $contents, $lock);
4532
        }
4533
        
4534
        /**
4535
         * Prepend to a file.
4536
         *
4537
         * @param string $path
4538
         * @param string $data
4539
         * @return int 
4540
         * @static 
4541
         */ 
4542
        public static function prepend($path, $data)
4543
        {
4544
            return \Illuminate\Filesystem\Filesystem::prepend($path, $data);
4545
        }
4546
        
4547
        /**
4548
         * Append to a file.
4549
         *
4550
         * @param string $path
4551
         * @param string $data
4552
         * @return int 
4553
         * @static 
4554
         */ 
4555
        public static function append($path, $data)
4556
        {
4557
            return \Illuminate\Filesystem\Filesystem::append($path, $data);
4558
        }
4559
        
4560
        /**
4561
         * Get or set UNIX mode of a file or directory.
4562
         *
4563
         * @param string $path
4564
         * @param int $mode
4565
         * @return mixed 
4566
         * @static 
4567
         */ 
4568
        public static function chmod($path, $mode = null)
4569
        {
4570
            return \Illuminate\Filesystem\Filesystem::chmod($path, $mode);
4571
        }
4572
        
4573
        /**
4574
         * Delete the file at a given path.
4575
         *
4576
         * @param string|array $paths
4577
         * @return bool 
4578
         * @static 
4579
         */ 
4580
        public static function delete($paths)
4581
        {
4582
            return \Illuminate\Filesystem\Filesystem::delete($paths);
4583
        }
4584
        
4585
        /**
4586
         * Move a file to a new location.
4587
         *
4588
         * @param string $path
4589
         * @param string $target
4590
         * @return bool 
4591
         * @static 
4592
         */ 
4593
        public static function move($path, $target)
4594
        {
4595
            return \Illuminate\Filesystem\Filesystem::move($path, $target);
4596
        }
4597
        
4598
        /**
4599
         * Copy a file to a new location.
4600
         *
4601
         * @param string $path
4602
         * @param string $target
4603
         * @return bool 
4604
         * @static 
4605
         */ 
4606
        public static function copy($path, $target)
4607
        {
4608
            return \Illuminate\Filesystem\Filesystem::copy($path, $target);
4609
        }
4610
        
4611
        /**
4612
         * Create a hard link to the target file or directory.
4613
         *
4614
         * @param string $target
4615
         * @param string $link
4616
         * @return void 
4617
         * @static 
4618
         */ 
4619
        public static function link($target, $link)
4620
        {
4621
            \Illuminate\Filesystem\Filesystem::link($target, $link);
4622
        }
4623
        
4624
        /**
4625
         * Extract the file name from a file path.
4626
         *
4627
         * @param string $path
4628
         * @return string 
4629
         * @static 
4630
         */ 
4631
        public static function name($path)
4632
        {
4633
            return \Illuminate\Filesystem\Filesystem::name($path);
4634
        }
4635
        
4636
        /**
4637
         * Extract the trailing name component from a file path.
4638
         *
4639
         * @param string $path
4640
         * @return string 
4641
         * @static 
4642
         */ 
4643
        public static function basename($path)
4644
        {
4645
            return \Illuminate\Filesystem\Filesystem::basename($path);
4646
        }
4647
        
4648
        /**
4649
         * Extract the parent directory from a file path.
4650
         *
4651
         * @param string $path
4652
         * @return string 
4653
         * @static 
4654
         */ 
4655
        public static function dirname($path)
4656
        {
4657
            return \Illuminate\Filesystem\Filesystem::dirname($path);
4658
        }
4659
        
4660
        /**
4661
         * Extract the file extension from a file path.
4662
         *
4663
         * @param string $path
4664
         * @return string 
4665
         * @static 
4666
         */ 
4667
        public static function extension($path)
4668
        {
4669
            return \Illuminate\Filesystem\Filesystem::extension($path);
4670
        }
4671
        
4672
        /**
4673
         * Get the file type of a given file.
4674
         *
4675
         * @param string $path
4676
         * @return string 
4677
         * @static 
4678
         */ 
4679
        public static function type($path)
4680
        {
4681
            return \Illuminate\Filesystem\Filesystem::type($path);
4682
        }
4683
        
4684
        /**
4685
         * Get the mime-type of a given file.
4686
         *
4687
         * @param string $path
4688
         * @return string|false 
4689
         * @static 
4690
         */ 
4691
        public static function mimeType($path)
4692
        {
4693
            return \Illuminate\Filesystem\Filesystem::mimeType($path);
4694
        }
4695
        
4696
        /**
4697
         * Get the file size of a given file.
4698
         *
4699
         * @param string $path
4700
         * @return int 
4701
         * @static 
4702
         */ 
4703
        public static function size($path)
4704
        {
4705
            return \Illuminate\Filesystem\Filesystem::size($path);
4706
        }
4707
        
4708
        /**
4709
         * Get the file's last modification time.
4710
         *
4711
         * @param string $path
4712
         * @return int 
4713
         * @static 
4714
         */ 
4715
        public static function lastModified($path)
4716
        {
4717
            return \Illuminate\Filesystem\Filesystem::lastModified($path);
4718
        }
4719
        
4720
        /**
4721
         * Determine if the given path is a directory.
4722
         *
4723
         * @param string $directory
4724
         * @return bool 
4725
         * @static 
4726
         */ 
4727
        public static function isDirectory($directory)
4728
        {
4729
            return \Illuminate\Filesystem\Filesystem::isDirectory($directory);
4730
        }
4731
        
4732
        /**
4733
         * Determine if the given path is readable.
4734
         *
4735
         * @param string $path
4736
         * @return bool 
4737
         * @static 
4738
         */ 
4739
        public static function isReadable($path)
4740
        {
4741
            return \Illuminate\Filesystem\Filesystem::isReadable($path);
4742
        }
4743
        
4744
        /**
4745
         * Determine if the given path is writable.
4746
         *
4747
         * @param string $path
4748
         * @return bool 
4749
         * @static 
4750
         */ 
4751
        public static function isWritable($path)
4752
        {
4753
            return \Illuminate\Filesystem\Filesystem::isWritable($path);
4754
        }
4755
        
4756
        /**
4757
         * Determine if the given path is a file.
4758
         *
4759
         * @param string $file
4760
         * @return bool 
4761
         * @static 
4762
         */ 
4763
        public static function isFile($file)
4764
        {
4765
            return \Illuminate\Filesystem\Filesystem::isFile($file);
4766
        }
4767
        
4768
        /**
4769
         * Find path names matching a given pattern.
4770
         *
4771
         * @param string $pattern
4772
         * @param int $flags
4773
         * @return array 
4774
         * @static 
4775
         */ 
4776
        public static function glob($pattern, $flags = 0)
4777
        {
4778
            return \Illuminate\Filesystem\Filesystem::glob($pattern, $flags);
4779
        }
4780
        
4781
        /**
4782
         * Get an array of all files in a directory.
4783
         *
4784
         * @param string $directory
4785
         * @param bool $hidden
4786
         * @return \Symfony\Component\Finder\SplFileInfo[] 
4787
         * @static 
4788
         */ 
4789
        public static function files($directory, $hidden = false)
4790
        {
4791
            return \Illuminate\Filesystem\Filesystem::files($directory, $hidden);
4792
        }
4793
        
4794
        /**
4795
         * Get all of the files from the given directory (recursive).
4796
         *
4797
         * @param string $directory
4798
         * @param bool $hidden
4799
         * @return \Symfony\Component\Finder\SplFileInfo[] 
4800
         * @static 
4801
         */ 
4802
        public static function allFiles($directory, $hidden = false)
4803
        {
4804
            return \Illuminate\Filesystem\Filesystem::allFiles($directory, $hidden);
4805
        }
4806
        
4807
        /**
4808
         * Get all of the directories within a given directory.
4809
         *
4810
         * @param string $directory
4811
         * @return array 
4812
         * @static 
4813
         */ 
4814
        public static function directories($directory)
4815
        {
4816
            return \Illuminate\Filesystem\Filesystem::directories($directory);
4817
        }
4818
        
4819
        /**
4820
         * Create a directory.
4821
         *
4822
         * @param string $path
4823
         * @param int $mode
4824
         * @param bool $recursive
4825
         * @param bool $force
4826
         * @return bool 
4827
         * @static 
4828
         */ 
4829
        public static function makeDirectory($path, $mode = 493, $recursive = false, $force = false)
4830
        {
4831
            return \Illuminate\Filesystem\Filesystem::makeDirectory($path, $mode, $recursive, $force);
4832
        }
4833
        
4834
        /**
4835
         * Move a directory.
4836
         *
4837
         * @param string $from
4838
         * @param string $to
4839
         * @param bool $overwrite
4840
         * @return bool 
4841
         * @static 
4842
         */ 
4843
        public static function moveDirectory($from, $to, $overwrite = false)
4844
        {
4845
            return \Illuminate\Filesystem\Filesystem::moveDirectory($from, $to, $overwrite);
4846
        }
4847
        
4848
        /**
4849
         * Copy a directory from one location to another.
4850
         *
4851
         * @param string $directory
4852
         * @param string $destination
4853
         * @param int $options
4854
         * @return bool 
4855
         * @static 
4856
         */ 
4857
        public static function copyDirectory($directory, $destination, $options = null)
4858
        {
4859
            return \Illuminate\Filesystem\Filesystem::copyDirectory($directory, $destination, $options);
4860
        }
4861
        
4862
        /**
4863
         * Recursively delete a directory.
4864
         * 
4865
         * The directory itself may be optionally preserved.
4866
         *
4867
         * @param string $directory
4868
         * @param bool $preserve
4869
         * @return bool 
4870
         * @static 
4871
         */ 
4872
        public static function deleteDirectory($directory, $preserve = false)
4873
        {
4874
            return \Illuminate\Filesystem\Filesystem::deleteDirectory($directory, $preserve);
4875
        }
4876
        
4877
        /**
4878
         * Empty the specified directory of all files and folders.
4879
         *
4880
         * @param string $directory
4881
         * @return bool 
4882
         * @static 
4883
         */ 
4884
        public static function cleanDirectory($directory)
4885
        {
4886
            return \Illuminate\Filesystem\Filesystem::cleanDirectory($directory);
4887
        }
4888
        
4889
        /**
4890
         * Register a custom macro.
4891
         *
4892
         * @param string $name
4893
         * @param object|callable $macro
4894
         * @return void 
4895
         * @static 
4896
         */ 
4897
        public static function macro($name, $macro)
4898
        {
4899
            \Illuminate\Filesystem\Filesystem::macro($name, $macro);
4900
        }
4901
        
4902
        /**
4903
         * Mix another object into the class.
4904
         *
4905
         * @param object $mixin
4906
         * @return void 
4907
         * @static 
4908
         */ 
4909
        public static function mixin($mixin)
4910
        {
4911
            \Illuminate\Filesystem\Filesystem::mixin($mixin);
4912
        }
4913
        
4914
        /**
4915
         * Checks if macro is registered.
4916
         *
4917
         * @param string $name
4918
         * @return bool 
4919
         * @static 
4920
         */ 
4921
        public static function hasMacro($name)
4922
        {
4923
            return \Illuminate\Filesystem\Filesystem::hasMacro($name);
4924
        }
4925
         
4926
    }
4927

4928
    class Gate {
4929
        
4930
        /**
4931
         * Determine if a given ability has been defined.
4932
         *
4933
         * @param string|array $ability
4934
         * @return bool 
4935
         * @static 
4936
         */ 
4937
        public static function has($ability)
4938
        {
4939
            return \Illuminate\Auth\Access\Gate::has($ability);
4940
        }
4941
        
4942
        /**
4943
         * Define a new ability.
4944
         *
4945
         * @param string $ability
4946
         * @param callable|string $callback
4947
         * @return $this 
4948
         * @throws \InvalidArgumentException
4949
         * @static 
4950
         */ 
4951
        public static function define($ability, $callback)
4952
        {
4953
            return \Illuminate\Auth\Access\Gate::define($ability, $callback);
4954
        }
4955
        
4956
        /**
4957
         * Define abilities for a resource.
4958
         *
4959
         * @param string $name
4960
         * @param string $class
4961
         * @param array $abilities
4962
         * @return $this 
4963
         * @static 
4964
         */ 
4965
        public static function resource($name, $class, $abilities = null)
4966
        {
4967
            return \Illuminate\Auth\Access\Gate::resource($name, $class, $abilities);
4968
        }
4969
        
4970
        /**
4971
         * Define a policy class for a given class type.
4972
         *
4973
         * @param string $class
4974
         * @param string $policy
4975
         * @return $this 
4976
         * @static 
4977
         */ 
4978
        public static function policy($class, $policy)
4979
        {
4980
            return \Illuminate\Auth\Access\Gate::policy($class, $policy);
4981
        }
4982
        
4983
        /**
4984
         * Register a callback to run before all Gate checks.
4985
         *
4986
         * @param callable $callback
4987
         * @return $this 
4988
         * @static 
4989
         */ 
4990
        public static function before($callback)
4991
        {
4992
            return \Illuminate\Auth\Access\Gate::before($callback);
4993
        }
4994
        
4995
        /**
4996
         * Register a callback to run after all Gate checks.
4997
         *
4998
         * @param callable $callback
4999
         * @return $this 
5000
         * @static 
5001
         */ 
5002
        public static function after($callback)
5003
        {
5004
            return \Illuminate\Auth\Access\Gate::after($callback);
5005
        }
5006
        
5007
        /**
5008
         * Determine if the given ability should be granted for the current user.
5009
         *
5010
         * @param string $ability
5011
         * @param array|mixed $arguments
5012
         * @return bool 
5013
         * @static 
5014
         */ 
5015
        public static function allows($ability, $arguments = array())
5016
        {
5017
            return \Illuminate\Auth\Access\Gate::allows($ability, $arguments);
5018
        }
5019
        
5020
        /**
5021
         * Determine if the given ability should be denied for the current user.
5022
         *
5023
         * @param string $ability
5024
         * @param array|mixed $arguments
5025
         * @return bool 
5026
         * @static 
5027
         */ 
5028
        public static function denies($ability, $arguments = array())
5029
        {
5030
            return \Illuminate\Auth\Access\Gate::denies($ability, $arguments);
5031
        }
5032
        
5033
        /**
5034
         * Determine if all of the given abilities should be granted for the current user.
5035
         *
5036
         * @param \Illuminate\Auth\Access\iterable|string $abilities
5037
         * @param array|mixed $arguments
5038
         * @return bool 
5039
         * @static 
5040
         */ 
5041
        public static function check($abilities, $arguments = array())
5042
        {
5043
            return \Illuminate\Auth\Access\Gate::check($abilities, $arguments);
5044
        }
5045
        
5046
        /**
5047
         * Determine if any one of the given abilities should be granted for the current user.
5048
         *
5049
         * @param \Illuminate\Auth\Access\iterable|string $abilities
5050
         * @param array|mixed $arguments
5051
         * @return bool 
5052
         * @static 
5053
         */ 
5054
        public static function any($abilities, $arguments = array())
5055
        {
5056
            return \Illuminate\Auth\Access\Gate::any($abilities, $arguments);
5057
        }
5058
        
5059
        /**
5060
         * Determine if the given ability should be granted for the current user.
5061
         *
5062
         * @param string $ability
5063
         * @param array|mixed $arguments
5064
         * @return \Illuminate\Auth\Access\Response 
5065
         * @throws \Illuminate\Auth\Access\AuthorizationException
5066
         * @static 
5067
         */ 
5068
        public static function authorize($ability, $arguments = array())
5069
        {
5070
            return \Illuminate\Auth\Access\Gate::authorize($ability, $arguments);
5071
        }
5072
        
5073
        /**
5074
         * Get a policy instance for a given class.
5075
         *
5076
         * @param object|string $class
5077
         * @return mixed 
5078
         * @static 
5079
         */ 
5080
        public static function getPolicyFor($class)
5081
        {
5082
            return \Illuminate\Auth\Access\Gate::getPolicyFor($class);
5083
        }
5084
        
5085
        /**
5086
         * Build a policy class instance of the given type.
5087
         *
5088
         * @param object|string $class
5089
         * @return mixed 
5090
         * @static 
5091
         */ 
5092
        public static function resolvePolicy($class)
5093
        {
5094
            return \Illuminate\Auth\Access\Gate::resolvePolicy($class);
5095
        }
5096
        
5097
        /**
5098
         * Get a gate instance for the given user.
5099
         *
5100
         * @param \Illuminate\Contracts\Auth\Authenticatable|mixed $user
5101
         * @return static 
5102
         * @static 
5103
         */ 
5104
        public static function forUser($user)
5105
        {
5106
            return \Illuminate\Auth\Access\Gate::forUser($user);
5107
        }
5108
        
5109
        /**
5110
         * Get all of the defined abilities.
5111
         *
5112
         * @return array 
5113
         * @static 
5114
         */ 
5115
        public static function abilities()
5116
        {
5117
            return \Illuminate\Auth\Access\Gate::abilities();
5118
        }
5119
        
5120
        /**
5121
         * Get all of the defined policies.
5122
         *
5123
         * @return array 
5124
         * @static 
5125
         */ 
5126
        public static function policies()
5127
        {
5128
            return \Illuminate\Auth\Access\Gate::policies();
5129
        }
5130
         
5131
    }
5132

5133
    class Hash {
5134
        
5135
        /**
5136
         * Create an instance of the Bcrypt hash Driver.
5137
         *
5138
         * @return \Illuminate\Hashing\BcryptHasher 
5139
         * @static 
5140
         */ 
5141
        public static function createBcryptDriver()
5142
        {
5143
            return \Illuminate\Hashing\HashManager::createBcryptDriver();
5144
        }
5145
        
5146
        /**
5147
         * Create an instance of the Argon2 hash Driver.
5148
         *
5149
         * @return \Illuminate\Hashing\ArgonHasher 
5150
         * @static 
5151
         */ 
5152
        public static function createArgonDriver()
5153
        {
5154
            return \Illuminate\Hashing\HashManager::createArgonDriver();
5155
        }
5156
        
5157
        /**
5158
         * Get information about the given hashed value.
5159
         *
5160
         * @param string $hashedValue
5161
         * @return array 
5162
         * @static 
5163
         */ 
5164
        public static function info($hashedValue)
5165
        {
5166
            return \Illuminate\Hashing\HashManager::info($hashedValue);
5167
        }
5168
        
5169
        /**
5170
         * Hash the given value.
5171
         *
5172
         * @param string $value
5173
         * @param array $options
5174
         * @return string 
5175
         * @static 
5176
         */ 
5177
        public static function make($value, $options = array())
5178
        {
5179
            return \Illuminate\Hashing\HashManager::make($value, $options);
5180
        }
5181
        
5182
        /**
5183
         * Check the given plain value against a hash.
5184
         *
5185
         * @param string $value
5186
         * @param string $hashedValue
5187
         * @param array $options
5188
         * @return bool 
5189
         * @static 
5190
         */ 
5191
        public static function check($value, $hashedValue, $options = array())
5192
        {
5193
            return \Illuminate\Hashing\HashManager::check($value, $hashedValue, $options);
5194
        }
5195
        
5196
        /**
5197
         * Check if the given hash has been hashed using the given options.
5198
         *
5199
         * @param string $hashedValue
5200
         * @param array $options
5201
         * @return bool 
5202
         * @static 
5203
         */ 
5204
        public static function needsRehash($hashedValue, $options = array())
5205
        {
5206
            return \Illuminate\Hashing\HashManager::needsRehash($hashedValue, $options);
5207
        }
5208
        
5209
        /**
5210
         * Get the default driver name.
5211
         *
5212
         * @return string 
5213
         * @static 
5214
         */ 
5215
        public static function getDefaultDriver()
5216
        {
5217
            return \Illuminate\Hashing\HashManager::getDefaultDriver();
5218
        }
5219
        
5220
        /**
5221
         * Get a driver instance.
5222
         *
5223
         * @param string $driver
5224
         * @return mixed 
5225
         * @static 
5226
         */ 
5227
        public static function driver($driver = null)
5228
        {
5229
            //Method inherited from \Illuminate\Support\Manager            
5230
            return \Illuminate\Hashing\HashManager::driver($driver);
5231
        }
5232
        
5233
        /**
5234
         * Register a custom driver creator Closure.
5235
         *
5236
         * @param string $driver
5237
         * @param \Closure $callback
5238
         * @return $this 
5239
         * @static 
5240
         */ 
5241
        public static function extend($driver, $callback)
5242
        {
5243
            //Method inherited from \Illuminate\Support\Manager            
5244
            return \Illuminate\Hashing\HashManager::extend($driver, $callback);
5245
        }
5246
        
5247
        /**
5248
         * Get all of the created "drivers".
5249
         *
5250
         * @return array 
5251
         * @static 
5252
         */ 
5253
        public static function getDrivers()
5254
        {
5255
            //Method inherited from \Illuminate\Support\Manager            
5256
            return \Illuminate\Hashing\HashManager::getDrivers();
5257
        }
5258
         
5259
    }
5260

5261
    class Lang {
5262
        
5263
        /**
5264
         * Determine if a translation exists for a given locale.
5265
         *
5266
         * @param string $key
5267
         * @param string|null $locale
5268
         * @return bool 
5269
         * @static 
5270
         */ 
5271
        public static function hasForLocale($key, $locale = null)
5272
        {
5273
            return \Illuminate\Translation\Translator::hasForLocale($key, $locale);
5274
        }
5275
        
5276
        /**
5277
         * Determine if a translation exists.
5278
         *
5279
         * @param string $key
5280
         * @param string|null $locale
5281
         * @param bool $fallback
5282
         * @return bool 
5283
         * @static 
5284
         */ 
5285
        public static function has($key, $locale = null, $fallback = true)
5286
        {
5287
            return \Illuminate\Translation\Translator::has($key, $locale, $fallback);
5288
        }
5289
        
5290
        /**
5291
         * Get the translation for a given key.
5292
         *
5293
         * @param string $key
5294
         * @param array $replace
5295
         * @param string $locale
5296
         * @return string|array|null 
5297
         * @static 
5298
         */ 
5299
        public static function trans($key, $replace = array(), $locale = null)
5300
        {
5301
            return \Illuminate\Translation\Translator::trans($key, $replace, $locale);
5302
        }
5303
        
5304
        /**
5305
         * Get the translation for the given key.
5306
         *
5307
         * @param string $key
5308
         * @param array $replace
5309
         * @param string|null $locale
5310
         * @param bool $fallback
5311
         * @return string|array|null 
5312
         * @static 
5313
         */ 
5314
        public static function get($key, $replace = array(), $locale = null, $fallback = true)
5315
        {
5316
            return \Illuminate\Translation\Translator::get($key, $replace, $locale, $fallback);
5317
        }
5318
        
5319
        /**
5320
         * Get the translation for a given key from the JSON translation files.
5321
         *
5322
         * @param string $key
5323
         * @param array $replace
5324
         * @param string $locale
5325
         * @return string|array|null 
5326
         * @static 
5327
         */ 
5328
        public static function getFromJson($key, $replace = array(), $locale = null)
5329
        {
5330
            return \Illuminate\Translation\Translator::getFromJson($key, $replace, $locale);
5331
        }
5332
        
5333
        /**
5334
         * Get a translation according to an integer value.
5335
         *
5336
         * @param string $key
5337
         * @param int|array|\Countable $number
5338
         * @param array $replace
5339
         * @param string $locale
5340
         * @return string 
5341
         * @static 
5342
         */ 
5343
        public static function transChoice($key, $number, $replace = array(), $locale = null)
5344
        {
5345
            return \Illuminate\Translation\Translator::transChoice($key, $number, $replace, $locale);
5346
        }
5347
        
5348
        /**
5349
         * Get a translation according to an integer value.
5350
         *
5351
         * @param string $key
5352
         * @param int|array|\Countable $number
5353
         * @param array $replace
5354
         * @param string $locale
5355
         * @return string 
5356
         * @static 
5357
         */ 
5358
        public static function choice($key, $number, $replace = array(), $locale = null)
5359
        {
5360
            return \Illuminate\Translation\Translator::choice($key, $number, $replace, $locale);
5361
        }
5362
        
5363
        /**
5364
         * Add translation lines to the given locale.
5365
         *
5366
         * @param array $lines
5367
         * @param string $locale
5368
         * @param string $namespace
5369
         * @return void 
5370
         * @static 
5371
         */ 
5372
        public static function addLines($lines, $locale, $namespace = '*')
5373
        {
5374
            \Illuminate\Translation\Translator::addLines($lines, $locale, $namespace);
5375
        }
5376
        
5377
        /**
5378
         * Load the specified language group.
5379
         *
5380
         * @param string $namespace
5381
         * @param string $group
5382
         * @param string $locale
5383
         * @return void 
5384
         * @static 
5385
         */ 
5386
        public static function load($namespace, $group, $locale)
5387
        {
5388
            \Illuminate\Translation\Translator::load($namespace, $group, $locale);
5389
        }
5390
        
5391
        /**
5392
         * Add a new namespace to the loader.
5393
         *
5394
         * @param string $namespace
5395
         * @param string $hint
5396
         * @return void 
5397
         * @static 
5398
         */ 
5399
        public static function addNamespace($namespace, $hint)
5400
        {
5401
            \Illuminate\Translation\Translator::addNamespace($namespace, $hint);
5402
        }
5403
        
5404
        /**
5405
         * Add a new JSON path to the loader.
5406
         *
5407
         * @param string $path
5408
         * @return void 
5409
         * @static 
5410
         */ 
5411
        public static function addJsonPath($path)
5412
        {
5413
            \Illuminate\Translation\Translator::addJsonPath($path);
5414
        }
5415
        
5416
        /**
5417
         * Parse a key into namespace, group, and item.
5418
         *
5419
         * @param string $key
5420
         * @return array 
5421
         * @static 
5422
         */ 
5423
        public static function parseKey($key)
5424
        {
5425
            return \Illuminate\Translation\Translator::parseKey($key);
5426
        }
5427
        
5428
        /**
5429
         * Get the message selector instance.
5430
         *
5431
         * @return \Illuminate\Translation\MessageSelector 
5432
         * @static 
5433
         */ 
5434
        public static function getSelector()
5435
        {
5436
            return \Illuminate\Translation\Translator::getSelector();
5437
        }
5438
        
5439
        /**
5440
         * Set the message selector instance.
5441
         *
5442
         * @param \Illuminate\Translation\MessageSelector $selector
5443
         * @return void 
5444
         * @static 
5445
         */ 
5446
        public static function setSelector($selector)
5447
        {
5448
            \Illuminate\Translation\Translator::setSelector($selector);
5449
        }
5450
        
5451
        /**
5452
         * Get the language line loader implementation.
5453
         *
5454
         * @return \Illuminate\Contracts\Translation\Loader 
5455
         * @static 
5456
         */ 
5457
        public static function getLoader()
5458
        {
5459
            return \Illuminate\Translation\Translator::getLoader();
5460
        }
5461
        
5462
        /**
5463
         * Get the default locale being used.
5464
         *
5465
         * @return string 
5466
         * @static 
5467
         */ 
5468
        public static function locale()
5469
        {
5470
            return \Illuminate\Translation\Translator::locale();
5471
        }
5472
        
5473
        /**
5474
         * Get the default locale being used.
5475
         *
5476
         * @return string 
5477
         * @static 
5478
         */ 
5479
        public static function getLocale()
5480
        {
5481
            return \Illuminate\Translation\Translator::getLocale();
5482
        }
5483
        
5484
        /**
5485
         * Set the default locale.
5486
         *
5487
         * @param string $locale
5488
         * @return void 
5489
         * @static 
5490
         */ 
5491
        public static function setLocale($locale)
5492
        {
5493
            \Illuminate\Translation\Translator::setLocale($locale);
5494
        }
5495
        
5496
        /**
5497
         * Get the fallback locale being used.
5498
         *
5499
         * @return string 
5500
         * @static 
5501
         */ 
5502
        public static function getFallback()
5503
        {
5504
            return \Illuminate\Translation\Translator::getFallback();
5505
        }
5506
        
5507
        /**
5508
         * Set the fallback locale being used.
5509
         *
5510
         * @param string $fallback
5511
         * @return void 
5512
         * @static 
5513
         */ 
5514
        public static function setFallback($fallback)
5515
        {
5516
            \Illuminate\Translation\Translator::setFallback($fallback);
5517
        }
5518
        
5519
        /**
5520
         * Set the loaded translation groups.
5521
         *
5522
         * @param array $loaded
5523
         * @return void 
5524
         * @static 
5525
         */ 
5526
        public static function setLoaded($loaded)
5527
        {
5528
            \Illuminate\Translation\Translator::setLoaded($loaded);
5529
        }
5530
        
5531
        /**
5532
         * Set the parsed value of a key.
5533
         *
5534
         * @param string $key
5535
         * @param array $parsed
5536
         * @return void 
5537
         * @static 
5538
         */ 
5539
        public static function setParsedKey($key, $parsed)
5540
        {
5541
            //Method inherited from \Illuminate\Support\NamespacedItemResolver            
5542
            \Illuminate\Translation\Translator::setParsedKey($key, $parsed);
5543
        }
5544
        
5545
        /**
5546
         * Register a custom macro.
5547
         *
5548
         * @param string $name
5549
         * @param object|callable $macro
5550
         * @return void 
5551
         * @static 
5552
         */ 
5553
        public static function macro($name, $macro)
5554
        {
5555
            \Illuminate\Translation\Translator::macro($name, $macro);
5556
        }
5557
        
5558
        /**
5559
         * Mix another object into the class.
5560
         *
5561
         * @param object $mixin
5562
         * @return void 
5563
         * @static 
5564
         */ 
5565
        public static function mixin($mixin)
5566
        {
5567
            \Illuminate\Translation\Translator::mixin($mixin);
5568
        }
5569
        
5570
        /**
5571
         * Checks if macro is registered.
5572
         *
5573
         * @param string $name
5574
         * @return bool 
5575
         * @static 
5576
         */ 
5577
        public static function hasMacro($name)
5578
        {
5579
            return \Illuminate\Translation\Translator::hasMacro($name);
5580
        }
5581
         
5582
    }
5583

5584
    class Log {
5585
        
5586
        /**
5587
         * Adds a log record at the DEBUG level.
5588
         *
5589
         * @param string $message The log message
5590
         * @param array $context The log context
5591
         * @return Boolean Whether the record has been processed
5592
         * @static 
5593
         */ 
5594
        public static function debug($message, $context = array())
5595
        {
5596
            return \Monolog\Logger::debug($message, $context);
5597
        }
5598
        
5599
        /**
5600
         * Adds a log record at the INFO level.
5601
         *
5602
         * @param string $message The log message
5603
         * @param array $context The log context
5604
         * @return Boolean Whether the record has been processed
5605
         * @static 
5606
         */ 
5607
        public static function info($message, $context = array())
5608
        {
5609
            return \Monolog\Logger::info($message, $context);
5610
        }
5611
        
5612
        /**
5613
         * Adds a log record at the NOTICE level.
5614
         *
5615
         * @param string $message The log message
5616
         * @param array $context The log context
5617
         * @return Boolean Whether the record has been processed
5618
         * @static 
5619
         */ 
5620
        public static function notice($message, $context = array())
5621
        {
5622
            return \Monolog\Logger::notice($message, $context);
5623
        }
5624
        
5625
        /**
5626
         * Adds a log record at the WARNING level.
5627
         *
5628
         * @param string $message The log message
5629
         * @param array $context The log context
5630
         * @return Boolean Whether the record has been processed
5631
         * @static 
5632
         */ 
5633
        public static function warning($message, $context = array())
5634
        {
5635
            return \Monolog\Logger::warning($message, $context);
5636
        }
5637
        
5638
        /**
5639
         * Adds a log record at the ERROR level.
5640
         *
5641
         * @param string $message The log message
5642
         * @param array $context The log context
5643
         * @return Boolean Whether the record has been processed
5644
         * @static 
5645
         */ 
5646
        public static function error($message, $context = array())
5647
        {
5648
            return \Monolog\Logger::error($message, $context);
5649
        }
5650
        
5651
        /**
5652
         * Adds a log record at the CRITICAL level.
5653
         *
5654
         * @param string $message The log message
5655
         * @param array $context The log context
5656
         * @return Boolean Whether the record has been processed
5657
         * @static 
5658
         */ 
5659
        public static function critical($message, $context = array())
5660
        {
5661
            return \Monolog\Logger::critical($message, $context);
5662
        }
5663
        
5664
        /**
5665
         * Adds a log record at the ALERT level.
5666
         *
5667
         * @param string $message The log message
5668
         * @param array $context The log context
5669
         * @return Boolean Whether the record has been processed
5670
         * @static 
5671
         */ 
5672
        public static function alert($message, $context = array())
5673
        {
5674
            return \Monolog\Logger::alert($message, $context);
5675
        }
5676
        
5677
        /**
5678
         * Adds a log record at the EMERGENCY level.
5679
         *
5680
         * @param string $message The log message
5681
         * @param array $context The log context
5682
         * @return Boolean Whether the record has been processed
5683
         * @static 
5684
         */ 
5685
        public static function emergency($message, $context = array())
5686
        {
5687
            return \Monolog\Logger::emergency($message, $context);
5688
        }
5689
        
5690
        /**
5691
         * Create a new, on-demand aggregate logger instance.
5692
         *
5693
         * @param array $channels
5694
         * @param string|null $channel
5695
         * @return \Psr\Log\LoggerInterface 
5696
         * @static 
5697
         */ 
5698
        public static function stack($channels, $channel = null)
5699
        {
5700
            return \Illuminate\Log\LogManager::stack($channels, $channel);
5701
        }
5702
        
5703
        /**
5704
         * Get a log channel instance.
5705
         *
5706
         * @param string|null $channel
5707
         * @return mixed 
5708
         * @static 
5709
         */ 
5710
        public static function channel($channel = null)
5711
        {
5712
            return \Illuminate\Log\LogManager::channel($channel);
5713
        }
5714
        
5715
        /**
5716
         * Get a log driver instance.
5717
         *
5718
         * @param string|null $driver
5719
         * @return mixed 
5720
         * @static 
5721
         */ 
5722
        public static function driver($driver = null)
5723
        {
5724
            return \Illuminate\Log\LogManager::driver($driver);
5725
        }
5726
        
5727
        /**
5728
         * Get the default log driver name.
5729
         *
5730
         * @return string 
5731
         * @static 
5732
         */ 
5733
        public static function getDefaultDriver()
5734
        {
5735
            return \Illuminate\Log\LogManager::getDefaultDriver();
5736
        }
5737
        
5738
        /**
5739
         * Set the default log driver name.
5740
         *
5741
         * @param string $name
5742
         * @return void 
5743
         * @static 
5744
         */ 
5745
        public static function setDefaultDriver($name)
5746
        {
5747
            \Illuminate\Log\LogManager::setDefaultDriver($name);
5748
        }
5749
        
5750
        /**
5751
         * Register a custom driver creator Closure.
5752
         *
5753
         * @param string $driver
5754
         * @param \Closure $callback
5755
         * @return $this 
5756
         * @static 
5757
         */ 
5758
        public static function extend($driver, $callback)
5759
        {
5760
            return \Illuminate\Log\LogManager::extend($driver, $callback);
5761
        }
5762
        
5763
        /**
5764
         * Logs with an arbitrary level.
5765
         *
5766
         * @param mixed $level
5767
         * @param string $message
5768
         * @param array $context
5769
         * @return void 
5770
         * @static 
5771
         */ 
5772
        public static function log($level, $message, $context = array())
5773
        {
5774
            \Illuminate\Log\LogManager::log($level, $message, $context);
5775
        }
5776
         
5777
    }
5778

5779
    class Mail {
5780
        
5781
        /**
5782
         * Set the global from address and name.
5783
         *
5784
         * @param string $address
5785
         * @param string|null $name
5786
         * @return void 
5787
         * @static 
5788
         */ 
5789
        public static function alwaysFrom($address, $name = null)
5790
        {
5791
            \Illuminate\Mail\Mailer::alwaysFrom($address, $name);
5792
        }
5793
        
5794
        /**
5795
         * Set the global reply-to address and name.
5796
         *
5797
         * @param string $address
5798
         * @param string|null $name
5799
         * @return void 
5800
         * @static 
5801
         */ 
5802
        public static function alwaysReplyTo($address, $name = null)
5803
        {
5804
            \Illuminate\Mail\Mailer::alwaysReplyTo($address, $name);
5805
        }
5806
        
5807
        /**
5808
         * Set the global to address and name.
5809
         *
5810
         * @param string $address
5811
         * @param string|null $name
5812
         * @return void 
5813
         * @static 
5814
         */ 
5815
        public static function alwaysTo($address, $name = null)
5816
        {
5817
            \Illuminate\Mail\Mailer::alwaysTo($address, $name);
5818
        }
5819
        
5820
        /**
5821
         * Begin the process of mailing a mailable class instance.
5822
         *
5823
         * @param mixed $users
5824
         * @return \Illuminate\Mail\PendingMail 
5825
         * @static 
5826
         */ 
5827
        public static function to($users)
5828
        {
5829
            return \Illuminate\Mail\Mailer::to($users);
5830
        }
5831
        
5832
        /**
5833
         * Begin the process of mailing a mailable class instance.
5834
         *
5835
         * @param mixed $users
5836
         * @return \Illuminate\Mail\PendingMail 
5837
         * @static 
5838
         */ 
5839
        public static function bcc($users)
5840
        {
5841
            return \Illuminate\Mail\Mailer::bcc($users);
5842
        }
5843
        
5844
        /**
5845
         * Send a new message with only an HTML part.
5846
         *
5847
         * @param string $html
5848
         * @param mixed $callback
5849
         * @return void 
5850
         * @static 
5851
         */ 
5852
        public static function html($html, $callback)
5853
        {
5854
            \Illuminate\Mail\Mailer::html($html, $callback);
5855
        }
5856
        
5857
        /**
5858
         * Send a new message when only a raw text part.
5859
         *
5860
         * @param string $text
5861
         * @param mixed $callback
5862
         * @return void 
5863
         * @static 
5864
         */ 
5865
        public static function raw($text, $callback)
5866
        {
5867
            \Illuminate\Mail\Mailer::raw($text, $callback);
5868
        }
5869
        
5870
        /**
5871
         * Send a new message when only a plain part.
5872
         *
5873
         * @param string $view
5874
         * @param array $data
5875
         * @param mixed $callback
5876
         * @return void 
5877
         * @static 
5878
         */ 
5879
        public static function plain($view, $data, $callback)
5880
        {
5881
            \Illuminate\Mail\Mailer::plain($view, $data, $callback);
5882
        }
5883
        
5884
        /**
5885
         * Render the given message as a view.
5886
         *
5887
         * @param string|array $view
5888
         * @param array $data
5889
         * @return string 
5890
         * @static 
5891
         */ 
5892
        public static function render($view, $data = array())
5893
        {
5894
            return \Illuminate\Mail\Mailer::render($view, $data);
5895
        }
5896
        
5897
        /**
5898
         * Send a new message using a view.
5899
         *
5900
         * @param string|array|\Illuminate\Mail\MailableContract $view
5901
         * @param array $data
5902
         * @param \Closure|string $callback
5903
         * @return void 
5904
         * @static 
5905
         */ 
5906
        public static function send($view, $data = array(), $callback = null)
5907
        {
5908
            \Illuminate\Mail\Mailer::send($view, $data, $callback);
5909
        }
5910
        
5911
        /**
5912
         * Queue a new e-mail message for sending.
5913
         *
5914
         * @param string|array|\Illuminate\Mail\MailableContract $view
5915
         * @param string|null $queue
5916
         * @return mixed 
5917
         * @static 
5918
         */ 
5919
        public static function queue($view, $queue = null)
5920
        {
5921
            return \Illuminate\Mail\Mailer::queue($view, $queue);
5922
        }
5923
        
5924
        /**
5925
         * Queue a new e-mail message for sending on the given queue.
5926
         *
5927
         * @param string $queue
5928
         * @param string|array $view
5929
         * @return mixed 
5930
         * @static 
5931
         */ 
5932
        public static function onQueue($queue, $view)
5933
        {
5934
            return \Illuminate\Mail\Mailer::onQueue($queue, $view);
5935
        }
5936
        
5937
        /**
5938
         * Queue a new e-mail message for sending on the given queue.
5939
         * 
5940
         * This method didn't match rest of framework's "onQueue" phrasing. Added "onQueue".
5941
         *
5942
         * @param string $queue
5943
         * @param string|array $view
5944
         * @return mixed 
5945
         * @static 
5946
         */ 
5947
        public static function queueOn($queue, $view)
5948
        {
5949
            return \Illuminate\Mail\Mailer::queueOn($queue, $view);
5950
        }
5951
        
5952
        /**
5953
         * Queue a new e-mail message for sending after (n) seconds.
5954
         *
5955
         * @param \DateTimeInterface|\DateInterval|int $delay
5956
         * @param string|array|\Illuminate\Mail\MailableContract $view
5957
         * @param string|null $queue
5958
         * @return mixed 
5959
         * @static 
5960
         */ 
5961
        public static function later($delay, $view, $queue = null)
5962
        {
5963
            return \Illuminate\Mail\Mailer::later($delay, $view, $queue);
5964
        }
5965
        
5966
        /**
5967
         * Queue a new e-mail message for sending after (n) seconds on the given queue.
5968
         *
5969
         * @param string $queue
5970
         * @param \DateTimeInterface|\DateInterval|int $delay
5971
         * @param string|array $view
5972
         * @return mixed 
5973
         * @static 
5974
         */ 
5975
        public static function laterOn($queue, $delay, $view)
5976
        {
5977
            return \Illuminate\Mail\Mailer::laterOn($queue, $delay, $view);
5978
        }
5979
        
5980
        /**
5981
         * Get the view factory instance.
5982
         *
5983
         * @return \Illuminate\Contracts\View\Factory 
5984
         * @static 
5985
         */ 
5986
        public static function getViewFactory()
5987
        {
5988
            return \Illuminate\Mail\Mailer::getViewFactory();
5989
        }
5990
        
5991
        /**
5992
         * Get the Swift Mailer instance.
5993
         *
5994
         * @return \Swift_Mailer 
5995
         * @static 
5996
         */ 
5997
        public static function getSwiftMailer()
5998
        {
5999
            return \Illuminate\Mail\Mailer::getSwiftMailer();
6000
        }
6001
        
6002
        /**
6003
         * Get the array of failed recipients.
6004
         *
6005
         * @return array 
6006
         * @static 
6007
         */ 
6008
        public static function failures()
6009
        {
6010
            return \Illuminate\Mail\Mailer::failures();
6011
        }
6012
        
6013
        /**
6014
         * Set the Swift Mailer instance.
6015
         *
6016
         * @param \Swift_Mailer $swift
6017
         * @return void 
6018
         * @static 
6019
         */ 
6020
        public static function setSwiftMailer($swift)
6021
        {
6022
            \Illuminate\Mail\Mailer::setSwiftMailer($swift);
6023
        }
6024
        
6025
        /**
6026
         * Set the queue manager instance.
6027
         *
6028
         * @param \Illuminate\Contracts\Queue\Factory $queue
6029
         * @return $this 
6030
         * @static 
6031
         */ 
6032
        public static function setQueue($queue)
6033
        {
6034
            return \Illuminate\Mail\Mailer::setQueue($queue);
6035
        }
6036
        
6037
        /**
6038
         * Register a custom macro.
6039
         *
6040
         * @param string $name
6041
         * @param object|callable $macro
6042
         * @return void 
6043
         * @static 
6044
         */ 
6045
        public static function macro($name, $macro)
6046
        {
6047
            \Illuminate\Mail\Mailer::macro($name, $macro);
6048
        }
6049
        
6050
        /**
6051
         * Mix another object into the class.
6052
         *
6053
         * @param object $mixin
6054
         * @return void 
6055
         * @static 
6056
         */ 
6057
        public static function mixin($mixin)
6058
        {
6059
            \Illuminate\Mail\Mailer::mixin($mixin);
6060
        }
6061
        
6062
        /**
6063
         * Checks if macro is registered.
6064
         *
6065
         * @param string $name
6066
         * @return bool 
6067
         * @static 
6068
         */ 
6069
        public static function hasMacro($name)
6070
        {
6071
            return \Illuminate\Mail\Mailer::hasMacro($name);
6072
        }
6073
         
6074
    }
6075

6076
    class Notification {
6077
        
6078
        /**
6079
         * Send the given notification to the given notifiable entities.
6080
         *
6081
         * @param \Illuminate\Support\Collection|array|mixed $notifiables
6082
         * @param mixed $notification
6083
         * @return void 
6084
         * @static 
6085
         */ 
6086
        public static function send($notifiables, $notification)
6087
        {
6088
            \Illuminate\Notifications\ChannelManager::send($notifiables, $notification);
6089
        }
6090
        
6091
        /**
6092
         * Send the given notification immediately.
6093
         *
6094
         * @param \Illuminate\Support\Collection|array|mixed $notifiables
6095
         * @param mixed $notification
6096
         * @param array|null $channels
6097
         * @return void 
6098
         * @static 
6099
         */ 
6100
        public static function sendNow($notifiables, $notification, $channels = null)
6101
        {
6102
            \Illuminate\Notifications\ChannelManager::sendNow($notifiables, $notification, $channels);
6103
        }
6104
        
6105
        /**
6106
         * Get a channel instance.
6107
         *
6108
         * @param string|null $name
6109
         * @return mixed 
6110
         * @static 
6111
         */ 
6112
        public static function channel($name = null)
6113
        {
6114
            return \Illuminate\Notifications\ChannelManager::channel($name);
6115
        }
6116
        
6117
        /**
6118
         * Get the default channel driver name.
6119
         *
6120
         * @return string 
6121
         * @static 
6122
         */ 
6123
        public static function getDefaultDriver()
6124
        {
6125
            return \Illuminate\Notifications\ChannelManager::getDefaultDriver();
6126
        }
6127
        
6128
        /**
6129
         * Get the default channel driver name.
6130
         *
6131
         * @return string 
6132
         * @static 
6133
         */ 
6134
        public static function deliversVia()
6135
        {
6136
            return \Illuminate\Notifications\ChannelManager::deliversVia();
6137
        }
6138
        
6139
        /**
6140
         * Set the default channel driver name.
6141
         *
6142
         * @param string $channel
6143
         * @return void 
6144
         * @static 
6145
         */ 
6146
        public static function deliverVia($channel)
6147
        {
6148
            \Illuminate\Notifications\ChannelManager::deliverVia($channel);
6149
        }
6150
        
6151
        /**
6152
         * Get a driver instance.
6153
         *
6154
         * @param string $driver
6155
         * @return mixed 
6156
         * @static 
6157
         */ 
6158
        public static function driver($driver = null)
6159
        {
6160
            //Method inherited from \Illuminate\Support\Manager            
6161
            return \Illuminate\Notifications\ChannelManager::driver($driver);
6162
        }
6163
        
6164
        /**
6165
         * Register a custom driver creator Closure.
6166
         *
6167
         * @param string $driver
6168
         * @param \Closure $callback
6169
         * @return $this 
6170
         * @static 
6171
         */ 
6172
        public static function extend($driver, $callback)
6173
        {
6174
            //Method inherited from \Illuminate\Support\Manager            
6175
            return \Illuminate\Notifications\ChannelManager::extend($driver, $callback);
6176
        }
6177
        
6178
        /**
6179
         * Get all of the created "drivers".
6180
         *
6181
         * @return array 
6182
         * @static 
6183
         */ 
6184
        public static function getDrivers()
6185
        {
6186
            //Method inherited from \Illuminate\Support\Manager            
6187
            return \Illuminate\Notifications\ChannelManager::getDrivers();
6188
        }
6189
         
6190
    }
6191

6192
    class Password {
6193
        
6194
        /**
6195
         * Attempt to get the broker from the local cache.
6196
         *
6197
         * @param string $name
6198
         * @return \Illuminate\Contracts\Auth\PasswordBroker 
6199
         * @static 
6200
         */ 
6201
        public static function broker($name = null)
6202
        {
6203
            return \Illuminate\Auth\Passwords\PasswordBrokerManager::broker($name);
6204
        }
6205
        
6206
        /**
6207
         * Get the default password broker name.
6208
         *
6209
         * @return string 
6210
         * @static 
6211
         */ 
6212
        public static function getDefaultDriver()
6213
        {
6214
            return \Illuminate\Auth\Passwords\PasswordBrokerManager::getDefaultDriver();
6215
        }
6216
        
6217
        /**
6218
         * Set the default password broker name.
6219
         *
6220
         * @param string $name
6221
         * @return void 
6222
         * @static 
6223
         */ 
6224
        public static function setDefaultDriver($name)
6225
        {
6226
            \Illuminate\Auth\Passwords\PasswordBrokerManager::setDefaultDriver($name);
6227
        }
6228
         
6229
    }
6230

6231
    class Queue {
6232
        
6233
        /**
6234
         * Register an event listener for the before job event.
6235
         *
6236
         * @param mixed $callback
6237
         * @return void 
6238
         * @static 
6239
         */ 
6240
        public static function before($callback)
6241
        {
6242
            \Illuminate\Queue\QueueManager::before($callback);
6243
        }
6244
        
6245
        /**
6246
         * Register an event listener for the after job event.
6247
         *
6248
         * @param mixed $callback
6249
         * @return void 
6250
         * @static 
6251
         */ 
6252
        public static function after($callback)
6253
        {
6254
            \Illuminate\Queue\QueueManager::after($callback);
6255
        }
6256
        
6257
        /**
6258
         * Register an event listener for the exception occurred job event.
6259
         *
6260
         * @param mixed $callback
6261
         * @return void 
6262
         * @static 
6263
         */ 
6264
        public static function exceptionOccurred($callback)
6265
        {
6266
            \Illuminate\Queue\QueueManager::exceptionOccurred($callback);
6267
        }
6268
        
6269
        /**
6270
         * Register an event listener for the daemon queue loop.
6271
         *
6272
         * @param mixed $callback
6273
         * @return void 
6274
         * @static 
6275
         */ 
6276
        public static function looping($callback)
6277
        {
6278
            \Illuminate\Queue\QueueManager::looping($callback);
6279
        }
6280
        
6281
        /**
6282
         * Register an event listener for the failed job event.
6283
         *
6284
         * @param mixed $callback
6285
         * @return void 
6286
         * @static 
6287
         */ 
6288
        public static function failing($callback)
6289
        {
6290
            \Illuminate\Queue\QueueManager::failing($callback);
6291
        }
6292
        
6293
        /**
6294
         * Register an event listener for the daemon queue stopping.
6295
         *
6296
         * @param mixed $callback
6297
         * @return void 
6298
         * @static 
6299
         */ 
6300
        public static function stopping($callback)
6301
        {
6302
            \Illuminate\Queue\QueueManager::stopping($callback);
6303
        }
6304
        
6305
        /**
6306
         * Determine if the driver is connected.
6307
         *
6308
         * @param string $name
6309
         * @return bool 
6310
         * @static 
6311
         */ 
6312
        public static function connected($name = null)
6313
        {
6314
            return \Illuminate\Queue\QueueManager::connected($name);
6315
        }
6316
        
6317
        /**
6318
         * Resolve a queue connection instance.
6319
         *
6320
         * @param string $name
6321
         * @return \Illuminate\Contracts\Queue\Queue 
6322
         * @static 
6323
         */ 
6324
        public static function connection($name = null)
6325
        {
6326
            return \Illuminate\Queue\QueueManager::connection($name);
6327
        }
6328
        
6329
        /**
6330
         * Add a queue connection resolver.
6331
         *
6332
         * @param string $driver
6333
         * @param \Closure $resolver
6334
         * @return void 
6335
         * @static 
6336
         */ 
6337
        public static function extend($driver, $resolver)
6338
        {
6339
            \Illuminate\Queue\QueueManager::extend($driver, $resolver);
6340
        }
6341
        
6342
        /**
6343
         * Add a queue connection resolver.
6344
         *
6345
         * @param string $driver
6346
         * @param \Closure $resolver
6347
         * @return void 
6348
         * @static 
6349
         */ 
6350
        public static function addConnector($driver, $resolver)
6351
        {
6352
            \Illuminate\Queue\QueueManager::addConnector($driver, $resolver);
6353
        }
6354
        
6355
        /**
6356
         * Get the name of the default queue connection.
6357
         *
6358
         * @return string 
6359
         * @static 
6360
         */ 
6361
        public static function getDefaultDriver()
6362
        {
6363
            return \Illuminate\Queue\QueueManager::getDefaultDriver();
6364
        }
6365
        
6366
        /**
6367
         * Set the name of the default queue connection.
6368
         *
6369
         * @param string $name
6370
         * @return void 
6371
         * @static 
6372
         */ 
6373
        public static function setDefaultDriver($name)
6374
        {
6375
            \Illuminate\Queue\QueueManager::setDefaultDriver($name);
6376
        }
6377
        
6378
        /**
6379
         * Get the full name for the given connection.
6380
         *
6381
         * @param string $connection
6382
         * @return string 
6383
         * @static 
6384
         */ 
6385
        public static function getName($connection = null)
6386
        {
6387
            return \Illuminate\Queue\QueueManager::getName($connection);
6388
        }
6389
        
6390
        /**
6391
         * Determine if the application is in maintenance mode.
6392
         *
6393
         * @return bool 
6394
         * @static 
6395
         */ 
6396
        public static function isDownForMaintenance()
6397
        {
6398
            return \Illuminate\Queue\QueueManager::isDownForMaintenance();
6399
        }
6400
        
6401
        /**
6402
         * Get the size of the queue.
6403
         *
6404
         * @param string $queue
6405
         * @return int 
6406
         * @static 
6407
         */ 
6408
        public static function size($queue = null)
6409
        {
6410
            return \Illuminate\Queue\SyncQueue::size($queue);
6411
        }
6412
        
6413
        /**
6414
         * Push a new job onto the queue.
6415
         *
6416
         * @param string $job
6417
         * @param mixed $data
6418
         * @param string $queue
6419
         * @return mixed 
6420
         * @throws \Exception|\Throwable
6421
         * @static 
6422
         */ 
6423
        public static function push($job, $data = '', $queue = null)
6424
        {
6425
            return \Illuminate\Queue\SyncQueue::push($job, $data, $queue);
6426
        }
6427
        
6428
        /**
6429
         * Push a raw payload onto the queue.
6430
         *
6431
         * @param string $payload
6432
         * @param string $queue
6433
         * @param array $options
6434
         * @return mixed 
6435
         * @static 
6436
         */ 
6437
        public static function pushRaw($payload, $queue = null, $options = array())
6438
        {
6439
            return \Illuminate\Queue\SyncQueue::pushRaw($payload, $queue, $options);
6440
        }
6441
        
6442
        /**
6443
         * Push a new job onto the queue after a delay.
6444
         *
6445
         * @param \DateTimeInterface|\DateInterval|int $delay
6446
         * @param string $job
6447
         * @param mixed $data
6448
         * @param string $queue
6449
         * @return mixed 
6450
         * @static 
6451
         */ 
6452
        public static function later($delay, $job, $data = '', $queue = null)
6453
        {
6454
            return \Illuminate\Queue\SyncQueue::later($delay, $job, $data, $queue);
6455
        }
6456
        
6457
        /**
6458
         * Pop the next job off of the queue.
6459
         *
6460
         * @param string $queue
6461
         * @return \Illuminate\Contracts\Queue\Job|null 
6462
         * @static 
6463
         */ 
6464
        public static function pop($queue = null)
6465
        {
6466
            return \Illuminate\Queue\SyncQueue::pop($queue);
6467
        }
6468
        
6469
        /**
6470
         * Push a new job onto the queue.
6471
         *
6472
         * @param string $queue
6473
         * @param string $job
6474
         * @param mixed $data
6475
         * @return mixed 
6476
         * @static 
6477
         */ 
6478
        public static function pushOn($queue, $job, $data = '')
6479
        {
6480
            //Method inherited from \Illuminate\Queue\Queue            
6481
            return \Illuminate\Queue\SyncQueue::pushOn($queue, $job, $data);
6482
        }
6483
        
6484
        /**
6485
         * Push a new job onto the queue after a delay.
6486
         *
6487
         * @param string $queue
6488
         * @param \DateTimeInterface|\DateInterval|int $delay
6489
         * @param string $job
6490
         * @param mixed $data
6491
         * @return mixed 
6492
         * @static 
6493
         */ 
6494
        public static function laterOn($queue, $delay, $job, $data = '')
6495
        {
6496
            //Method inherited from \Illuminate\Queue\Queue            
6497
            return \Illuminate\Queue\SyncQueue::laterOn($queue, $delay, $job, $data);
6498
        }
6499
        
6500
        /**
6501
         * Push an array of jobs onto the queue.
6502
         *
6503
         * @param array $jobs
6504
         * @param mixed $data
6505
         * @param string $queue
6506
         * @return mixed 
6507
         * @static 
6508
         */ 
6509
        public static function bulk($jobs, $data = '', $queue = null)
6510
        {
6511
            //Method inherited from \Illuminate\Queue\Queue            
6512
            return \Illuminate\Queue\SyncQueue::bulk($jobs, $data, $queue);
6513
        }
6514
        
6515
        /**
6516
         * Get the expiration timestamp for an object-based queue handler.
6517
         *
6518
         * @param mixed $job
6519
         * @return mixed 
6520
         * @static 
6521
         */ 
6522
        public static function getJobExpiration($job)
6523
        {
6524
            //Method inherited from \Illuminate\Queue\Queue            
6525
            return \Illuminate\Queue\SyncQueue::getJobExpiration($job);
6526
        }
6527
        
6528
        /**
6529
         * Get the connection name for the queue.
6530
         *
6531
         * @return string 
6532
         * @static 
6533
         */ 
6534
        public static function getConnectionName()
6535
        {
6536
            //Method inherited from \Illuminate\Queue\Queue            
6537
            return \Illuminate\Queue\SyncQueue::getConnectionName();
6538
        }
6539
        
6540
        /**
6541
         * Set the connection name for the queue.
6542
         *
6543
         * @param string $name
6544
         * @return $this 
6545
         * @static 
6546
         */ 
6547
        public static function setConnectionName($name)
6548
        {
6549
            //Method inherited from \Illuminate\Queue\Queue            
6550
            return \Illuminate\Queue\SyncQueue::setConnectionName($name);
6551
        }
6552
        
6553
        /**
6554
         * Set the IoC container instance.
6555
         *
6556
         * @param \Illuminate\Container\Container $container
6557
         * @return void 
6558
         * @static 
6559
         */ 
6560
        public static function setContainer($container)
6561
        {
6562
            //Method inherited from \Illuminate\Queue\Queue            
6563
            \Illuminate\Queue\SyncQueue::setContainer($container);
6564
        }
6565
         
6566
    }
6567

6568
    class Redirect {
6569
        
6570
        /**
6571
         * Create a new redirect response to the "home" route.
6572
         *
6573
         * @param int $status
6574
         * @return \Illuminate\Http\RedirectResponse 
6575
         * @static 
6576
         */ 
6577
        public static function home($status = 302)
6578
        {
6579
            return \Illuminate\Routing\Redirector::home($status);
6580
        }
6581
        
6582
        /**
6583
         * Create a new redirect response to the previous location.
6584
         *
6585
         * @param int $status
6586
         * @param array $headers
6587
         * @param mixed $fallback
6588
         * @return \Illuminate\Http\RedirectResponse 
6589
         * @static 
6590
         */ 
6591
        public static function back($status = 302, $headers = array(), $fallback = false)
6592
        {
6593
            return \Illuminate\Routing\Redirector::back($status, $headers, $fallback);
6594
        }
6595
        
6596
        /**
6597
         * Create a new redirect response to the current URI.
6598
         *
6599
         * @param int $status
6600
         * @param array $headers
6601
         * @return \Illuminate\Http\RedirectResponse 
6602
         * @static 
6603
         */ 
6604
        public static function refresh($status = 302, $headers = array())
6605
        {
6606
            return \Illuminate\Routing\Redirector::refresh($status, $headers);
6607
        }
6608
        
6609
        /**
6610
         * Create a new redirect response, while putting the current URL in the session.
6611
         *
6612
         * @param string $path
6613
         * @param int $status
6614
         * @param array $headers
6615
         * @param bool $secure
6616
         * @return \Illuminate\Http\RedirectResponse 
6617
         * @static 
6618
         */ 
6619
        public static function guest($path, $status = 302, $headers = array(), $secure = null)
6620
        {
6621
            return \Illuminate\Routing\Redirector::guest($path, $status, $headers, $secure);
6622
        }
6623
        
6624
        /**
6625
         * Create a new redirect response to the previously intended location.
6626
         *
6627
         * @param string $default
6628
         * @param int $status
6629
         * @param array $headers
6630
         * @param bool $secure
6631
         * @return \Illuminate\Http\RedirectResponse 
6632
         * @static 
6633
         */ 
6634
        public static function intended($default = '/', $status = 302, $headers = array(), $secure = null)
6635
        {
6636
            return \Illuminate\Routing\Redirector::intended($default, $status, $headers, $secure);
6637
        }
6638
        
6639
        /**
6640
         * Create a new redirect response to the given path.
6641
         *
6642
         * @param string $path
6643
         * @param int $status
6644
         * @param array $headers
6645
         * @param bool $secure
6646
         * @return \Illuminate\Http\RedirectResponse 
6647
         * @static 
6648
         */ 
6649
        public static function to($path, $status = 302, $headers = array(), $secure = null)
6650
        {
6651
            return \Illuminate\Routing\Redirector::to($path, $status, $headers, $secure);
6652
        }
6653
        
6654
        /**
6655
         * Create a new redirect response to an external URL (no validation).
6656
         *
6657
         * @param string $path
6658
         * @param int $status
6659
         * @param array $headers
6660
         * @return \Illuminate\Http\RedirectResponse 
6661
         * @static 
6662
         */ 
6663
        public static function away($path, $status = 302, $headers = array())
6664
        {
6665
            return \Illuminate\Routing\Redirector::away($path, $status, $headers);
6666
        }
6667
        
6668
        /**
6669
         * Create a new redirect response to the given HTTPS path.
6670
         *
6671
         * @param string $path
6672
         * @param int $status
6673
         * @param array $headers
6674
         * @return \Illuminate\Http\RedirectResponse 
6675
         * @static 
6676
         */ 
6677
        public static function secure($path, $status = 302, $headers = array())
6678
        {
6679
            return \Illuminate\Routing\Redirector::secure($path, $status, $headers);
6680
        }
6681
        
6682
        /**
6683
         * Create a new redirect response to a named route.
6684
         *
6685
         * @param string $route
6686
         * @param array $parameters
6687
         * @param int $status
6688
         * @param array $headers
6689
         * @return \Illuminate\Http\RedirectResponse 
6690
         * @static 
6691
         */ 
6692
        public static function route($route, $parameters = array(), $status = 302, $headers = array())
6693
        {
6694
            return \Illuminate\Routing\Redirector::route($route, $parameters, $status, $headers);
6695
        }
6696
        
6697
        /**
6698
         * Create a new redirect response to a controller action.
6699
         *
6700
         * @param string $action
6701
         * @param array $parameters
6702
         * @param int $status
6703
         * @param array $headers
6704
         * @return \Illuminate\Http\RedirectResponse 
6705
         * @static 
6706
         */ 
6707
        public static function action($action, $parameters = array(), $status = 302, $headers = array())
6708
        {
6709
            return \Illuminate\Routing\Redirector::action($action, $parameters, $status, $headers);
6710
        }
6711
        
6712
        /**
6713
         * Get the URL generator instance.
6714
         *
6715
         * @return \Illuminate\Routing\UrlGenerator 
6716
         * @static 
6717
         */ 
6718
        public static function getUrlGenerator()
6719
        {
6720
            return \Illuminate\Routing\Redirector::getUrlGenerator();
6721
        }
6722
        
6723
        /**
6724
         * Set the active session store.
6725
         *
6726
         * @param \Illuminate\Session\Store $session
6727
         * @return void 
6728
         * @static 
6729
         */ 
6730
        public static function setSession($session)
6731
        {
6732
            \Illuminate\Routing\Redirector::setSession($session);
6733
        }
6734
        
6735
        /**
6736
         * Register a custom macro.
6737
         *
6738
         * @param string $name
6739
         * @param object|callable $macro
6740
         * @return void 
6741
         * @static 
6742
         */ 
6743
        public static function macro($name, $macro)
6744
        {
6745
            \Illuminate\Routing\Redirector::macro($name, $macro);
6746
        }
6747
        
6748
        /**
6749
         * Mix another object into the class.
6750
         *
6751
         * @param object $mixin
6752
         * @return void 
6753
         * @static 
6754
         */ 
6755
        public static function mixin($mixin)
6756
        {
6757
            \Illuminate\Routing\Redirector::mixin($mixin);
6758
        }
6759
        
6760
        /**
6761
         * Checks if macro is registered.
6762
         *
6763
         * @param string $name
6764
         * @return bool 
6765
         * @static 
6766
         */ 
6767
        public static function hasMacro($name)
6768
        {
6769
            return \Illuminate\Routing\Redirector::hasMacro($name);
6770
        }
6771
         
6772
    }
6773

6774
    class Request {
6775
        
6776
        /**
6777
         * Create a new Illuminate HTTP request from server variables.
6778
         *
6779
         * @return static 
6780
         * @static 
6781
         */ 
6782
        public static function capture()
6783
        {
6784
            return \Illuminate\Http\Request::capture();
6785
        }
6786
        
6787
        /**
6788
         * Return the Request instance.
6789
         *
6790
         * @return $this 
6791
         * @static 
6792
         */ 
6793
        public static function instance()
6794
        {
6795
            return \Illuminate\Http\Request::instance();
6796
        }
6797
        
6798
        /**
6799
         * Get the request method.
6800
         *
6801
         * @return string 
6802
         * @static 
6803
         */ 
6804
        public static function method()
6805
        {
6806
            return \Illuminate\Http\Request::method();
6807
        }
6808
        
6809
        /**
6810
         * Get the root URL for the application.
6811
         *
6812
         * @return string 
6813
         * @static 
6814
         */ 
6815
        public static function root()
6816
        {
6817
            return \Illuminate\Http\Request::root();
6818
        }
6819
        
6820
        /**
6821
         * Get the URL (no query string) for the request.
6822
         *
6823
         * @return string 
6824
         * @static 
6825
         */ 
6826
        public static function url()
6827
        {
6828
            return \Illuminate\Http\Request::url();
6829
        }
6830
        
6831
        /**
6832
         * Get the full URL for the request.
6833
         *
6834
         * @return string 
6835
         * @static 
6836
         */ 
6837
        public static function fullUrl()
6838
        {
6839
            return \Illuminate\Http\Request::fullUrl();
6840
        }
6841
        
6842
        /**
6843
         * Get the full URL for the request with the added query string parameters.
6844
         *
6845
         * @param array $query
6846
         * @return string 
6847
         * @static 
6848
         */ 
6849
        public static function fullUrlWithQuery($query)
6850
        {
6851
            return \Illuminate\Http\Request::fullUrlWithQuery($query);
6852
        }
6853
        
6854
        /**
6855
         * Get the current path info for the request.
6856
         *
6857
         * @return string 
6858
         * @static 
6859
         */ 
6860
        public static function path()
6861
        {
6862
            return \Illuminate\Http\Request::path();
6863
        }
6864
        
6865
        /**
6866
         * Get the current decoded path info for the request.
6867
         *
6868
         * @return string 
6869
         * @static 
6870
         */ 
6871
        public static function decodedPath()
6872
        {
6873
            return \Illuminate\Http\Request::decodedPath();
6874
        }
6875
        
6876
        /**
6877
         * Get a segment from the URI (1 based index).
6878
         *
6879
         * @param int $index
6880
         * @param string|null $default
6881
         * @return string|null 
6882
         * @static 
6883
         */ 
6884
        public static function segment($index, $default = null)
6885
        {
6886
            return \Illuminate\Http\Request::segment($index, $default);
6887
        }
6888
        
6889
        /**
6890
         * Get all of the segments for the request path.
6891
         *
6892
         * @return array 
6893
         * @static 
6894
         */ 
6895
        public static function segments()
6896
        {
6897
            return \Illuminate\Http\Request::segments();
6898
        }
6899
        
6900
        /**
6901
         * Determine if the current request URI matches a pattern.
6902
         *
6903
         * @param mixed $patterns
6904
         * @return bool 
6905
         * @static 
6906
         */ 
6907
        public static function is($patterns = null)
6908
        {
6909
            return \Illuminate\Http\Request::is($patterns);
6910
        }
6911
        
6912
        /**
6913
         * Determine if the route name matches a given pattern.
6914
         *
6915
         * @param mixed $patterns
6916
         * @return bool 
6917
         * @static 
6918
         */ 
6919
        public static function routeIs($patterns = null)
6920
        {
6921
            return \Illuminate\Http\Request::routeIs($patterns);
6922
        }
6923
        
6924
        /**
6925
         * Determine if the current request URL and query string matches a pattern.
6926
         *
6927
         * @param mixed $patterns
6928
         * @return bool 
6929
         * @static 
6930
         */ 
6931
        public static function fullUrlIs($patterns = null)
6932
        {
6933
            return \Illuminate\Http\Request::fullUrlIs($patterns);
6934
        }
6935
        
6936
        /**
6937
         * Determine if the request is the result of an AJAX call.
6938
         *
6939
         * @return bool 
6940
         * @static 
6941
         */ 
6942
        public static function ajax()
6943
        {
6944
            return \Illuminate\Http\Request::ajax();
6945
        }
6946
        
6947
        /**
6948
         * Determine if the request is the result of an PJAX call.
6949
         *
6950
         * @return bool 
6951
         * @static 
6952
         */ 
6953
        public static function pjax()
6954
        {
6955
            return \Illuminate\Http\Request::pjax();
6956
        }
6957
        
6958
        /**
6959
         * Determine if the request is over HTTPS.
6960
         *
6961
         * @return bool 
6962
         * @static 
6963
         */ 
6964
        public static function secure()
6965
        {
6966
            return \Illuminate\Http\Request::secure();
6967
        }
6968
        
6969
        /**
6970
         * Get the client IP address.
6971
         *
6972
         * @return string 
6973
         * @static 
6974
         */ 
6975
        public static function ip()
6976
        {
6977
            return \Illuminate\Http\Request::ip();
6978
        }
6979
        
6980
        /**
6981
         * Get the client IP addresses.
6982
         *
6983
         * @return array 
6984
         * @static 
6985
         */ 
6986
        public static function ips()
6987
        {
6988
            return \Illuminate\Http\Request::ips();
6989
        }
6990
        
6991
        /**
6992
         * Get the client user agent.
6993
         *
6994
         * @return string 
6995
         * @static 
6996
         */ 
6997
        public static function userAgent()
6998
        {
6999
            return \Illuminate\Http\Request::userAgent();
7000
        }
7001
        
7002
        /**
7003
         * Merge new input into the current request's input array.
7004
         *
7005
         * @param array $input
7006
         * @return \Illuminate\Http\Request 
7007
         * @static 
7008
         */ 
7009
        public static function merge($input)
7010
        {
7011
            return \Illuminate\Http\Request::merge($input);
7012
        }
7013
        
7014
        /**
7015
         * Replace the input for the current request.
7016
         *
7017
         * @param array $input
7018
         * @return \Illuminate\Http\Request 
7019
         * @static 
7020
         */ 
7021
        public static function replace($input)
7022
        {
7023
            return \Illuminate\Http\Request::replace($input);
7024
        }
7025
        
7026
        /**
7027
         * Get the JSON payload for the request.
7028
         *
7029
         * @param string $key
7030
         * @param mixed $default
7031
         * @return \Symfony\Component\HttpFoundation\ParameterBag|mixed 
7032
         * @static 
7033
         */ 
7034
        public static function json($key = null, $default = null)
7035
        {
7036
            return \Illuminate\Http\Request::json($key, $default);
7037
        }
7038
        
7039
        /**
7040
         * Create a new request instance from the given Laravel request.
7041
         *
7042
         * @param \Illuminate\Http\Request $from
7043
         * @param \Illuminate\Http\Request|null $to
7044
         * @return static 
7045
         * @static 
7046
         */ 
7047
        public static function createFrom($from, $to = null)
7048
        {
7049
            return \Illuminate\Http\Request::createFrom($from, $to);
7050
        }
7051
        
7052
        /**
7053
         * Create an Illuminate request from a Symfony instance.
7054
         *
7055
         * @param \Symfony\Component\HttpFoundation\Request $request
7056
         * @return \Illuminate\Http\Request 
7057
         * @static 
7058
         */ 
7059
        public static function createFromBase($request)
7060
        {
7061
            return \Illuminate\Http\Request::createFromBase($request);
7062
        }
7063
        
7064
        /**
7065
         * Clones a request and overrides some of its parameters.
7066
         *
7067
         * @param array $query The GET parameters
7068
         * @param array $request The POST parameters
7069
         * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
7070
         * @param array $cookies The COOKIE parameters
7071
         * @param array $files The FILES parameters
7072
         * @param array $server The SERVER parameters
7073
         * @return static 
7074
         * @static 
7075
         */ 
7076
        public static function duplicate($query = null, $request = null, $attributes = null, $cookies = null, $files = null, $server = null)
7077
        {
7078
            return \Illuminate\Http\Request::duplicate($query, $request, $attributes, $cookies, $files, $server);
7079
        }
7080
        
7081
        /**
7082
         * Get the session associated with the request.
7083
         *
7084
         * @return \Illuminate\Session\Store 
7085
         * @throws \RuntimeException
7086
         * @static 
7087
         */ 
7088
        public static function session()
7089
        {
7090
            return \Illuminate\Http\Request::session();
7091
        }
7092
        
7093
        /**
7094
         * Get the session associated with the request.
7095
         *
7096
         * @return \Illuminate\Session\Store|null 
7097
         * @static 
7098
         */ 
7099
        public static function getSession()
7100
        {
7101
            return \Illuminate\Http\Request::getSession();
7102
        }
7103
        
7104
        /**
7105
         * Set the session instance on the request.
7106
         *
7107
         * @param \Illuminate\Contracts\Session\Session $session
7108
         * @return void 
7109
         * @static 
7110
         */ 
7111
        public static function setLaravelSession($session)
7112
        {
7113
            \Illuminate\Http\Request::setLaravelSession($session);
7114
        }
7115
        
7116
        /**
7117
         * Get the user making the request.
7118
         *
7119
         * @param string|null $guard
7120
         * @return mixed 
7121
         * @static 
7122
         */ 
7123
        public static function user($guard = null)
7124
        {
7125
            return \Illuminate\Http\Request::user($guard);
7126
        }
7127
        
7128
        /**
7129
         * Get the route handling the request.
7130
         *
7131
         * @param string|null $param
7132
         * @return \Illuminate\Routing\Route|object|string 
7133
         * @static 
7134
         */ 
7135
        public static function route($param = null)
7136
        {
7137
            return \Illuminate\Http\Request::route($param);
7138
        }
7139
        
7140
        /**
7141
         * Get a unique fingerprint for the request / route / IP address.
7142
         *
7143
         * @return string 
7144
         * @throws \RuntimeException
7145
         * @static 
7146
         */ 
7147
        public static function fingerprint()
7148
        {
7149
            return \Illuminate\Http\Request::fingerprint();
7150
        }
7151
        
7152
        /**
7153
         * Set the JSON payload for the request.
7154
         *
7155
         * @param \Symfony\Component\HttpFoundation\ParameterBag $json
7156
         * @return $this 
7157
         * @static 
7158
         */ 
7159
        public static function setJson($json)
7160
        {
7161
            return \Illuminate\Http\Request::setJson($json);
7162
        }
7163
        
7164
        /**
7165
         * Get the user resolver callback.
7166
         *
7167
         * @return \Closure 
7168
         * @static 
7169
         */ 
7170
        public static function getUserResolver()
7171
        {
7172
            return \Illuminate\Http\Request::getUserResolver();
7173
        }
7174
        
7175
        /**
7176
         * Set the user resolver callback.
7177
         *
7178
         * @param \Closure $callback
7179
         * @return $this 
7180
         * @static 
7181
         */ 
7182
        public static function setUserResolver($callback)
7183
        {
7184
            return \Illuminate\Http\Request::setUserResolver($callback);
7185
        }
7186
        
7187
        /**
7188
         * Get the route resolver callback.
7189
         *
7190
         * @return \Closure 
7191
         * @static 
7192
         */ 
7193
        public static function getRouteResolver()
7194
        {
7195
            return \Illuminate\Http\Request::getRouteResolver();
7196
        }
7197
        
7198
        /**
7199
         * Set the route resolver callback.
7200
         *
7201
         * @param \Closure $callback
7202
         * @return $this 
7203
         * @static 
7204
         */ 
7205
        public static function setRouteResolver($callback)
7206
        {
7207
            return \Illuminate\Http\Request::setRouteResolver($callback);
7208
        }
7209
        
7210
        /**
7211
         * Get all of the input and files for the request.
7212
         *
7213
         * @return array 
7214
         * @static 
7215
         */ 
7216
        public static function toArray()
7217
        {
7218
            return \Illuminate\Http\Request::toArray();
7219
        }
7220
        
7221
        /**
7222
         * Determine if the given offset exists.
7223
         *
7224
         * @param string $offset
7225
         * @return bool 
7226
         * @static 
7227
         */ 
7228
        public static function offsetExists($offset)
7229
        {
7230
            return \Illuminate\Http\Request::offsetExists($offset);
7231
        }
7232
        
7233
        /**
7234
         * Get the value at the given offset.
7235
         *
7236
         * @param string $offset
7237
         * @return mixed 
7238
         * @static 
7239
         */ 
7240
        public static function offsetGet($offset)
7241
        {
7242
            return \Illuminate\Http\Request::offsetGet($offset);
7243
        }
7244
        
7245
        /**
7246
         * Set the value at the given offset.
7247
         *
7248
         * @param string $offset
7249
         * @param mixed $value
7250
         * @return void 
7251
         * @static 
7252
         */ 
7253
        public static function offsetSet($offset, $value)
7254
        {
7255
            \Illuminate\Http\Request::offsetSet($offset, $value);
7256
        }
7257
        
7258
        /**
7259
         * Remove the value at the given offset.
7260
         *
7261
         * @param string $offset
7262
         * @return void 
7263
         * @static 
7264
         */ 
7265
        public static function offsetUnset($offset)
7266
        {
7267
            \Illuminate\Http\Request::offsetUnset($offset);
7268
        }
7269
        
7270
        /**
7271
         * Sets the parameters for this request.
7272
         * 
7273
         * This method also re-initializes all properties.
7274
         *
7275
         * @param array $query The GET parameters
7276
         * @param array $request The POST parameters
7277
         * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
7278
         * @param array $cookies The COOKIE parameters
7279
         * @param array $files The FILES parameters
7280
         * @param array $server The SERVER parameters
7281
         * @param string|resource|null $content The raw body data
7282
         * @static 
7283
         */ 
7284
        public static function initialize($query = array(), $request = array(), $attributes = array(), $cookies = array(), $files = array(), $server = array(), $content = null)
7285
        {
7286
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7287
            return \Illuminate\Http\Request::initialize($query, $request, $attributes, $cookies, $files, $server, $content);
7288
        }
7289
        
7290
        /**
7291
         * Creates a new request with values from PHP's super globals.
7292
         *
7293
         * @return static 
7294
         * @static 
7295
         */ 
7296
        public static function createFromGlobals()
7297
        {
7298
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7299
            return \Illuminate\Http\Request::createFromGlobals();
7300
        }
7301
        
7302
        /**
7303
         * Creates a Request based on a given URI and configuration.
7304
         * 
7305
         * The information contained in the URI always take precedence
7306
         * over the other information (server and parameters).
7307
         *
7308
         * @param string $uri The URI
7309
         * @param string $method The HTTP method
7310
         * @param array $parameters The query (GET) or request (POST) parameters
7311
         * @param array $cookies The request cookies ($_COOKIE)
7312
         * @param array $files The request files ($_FILES)
7313
         * @param array $server The server parameters ($_SERVER)
7314
         * @param string|resource|null $content The raw body data
7315
         * @return static 
7316
         * @static 
7317
         */ 
7318
        public static function create($uri, $method = 'GET', $parameters = array(), $cookies = array(), $files = array(), $server = array(), $content = null)
7319
        {
7320
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7321
            return \Illuminate\Http\Request::create($uri, $method, $parameters, $cookies, $files, $server, $content);
7322
        }
7323
        
7324
        /**
7325
         * Sets a callable able to create a Request instance.
7326
         * 
7327
         * This is mainly useful when you need to override the Request class
7328
         * to keep BC with an existing system. It should not be used for any
7329
         * other purpose.
7330
         *
7331
         * @param callable|null $callable A PHP callable
7332
         * @static 
7333
         */ 
7334
        public static function setFactory($callable)
7335
        {
7336
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7337
            return \Illuminate\Http\Request::setFactory($callable);
7338
        }
7339
        
7340
        /**
7341
         * Overrides the PHP global variables according to this request instance.
7342
         * 
7343
         * It overrides $_GET, $_POST, $_REQUEST, $_SERVER, $_COOKIE.
7344
         * $_FILES is never overridden, see rfc1867
7345
         *
7346
         * @static 
7347
         */ 
7348
        public static function overrideGlobals()
7349
        {
7350
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7351
            return \Illuminate\Http\Request::overrideGlobals();
7352
        }
7353
        
7354
        /**
7355
         * Sets a list of trusted proxies.
7356
         * 
7357
         * You should only list the reverse proxies that you manage directly.
7358
         *
7359
         * @param array $proxies A list of trusted proxies
7360
         * @param int $trustedHeaderSet A bit field of Request::HEADER_*, to set which headers to trust from your proxies
7361
         * @throws \InvalidArgumentException When $trustedHeaderSet is invalid
7362
         * @static 
7363
         */ 
7364
        public static function setTrustedProxies($proxies, $trustedHeaderSet)
7365
        {
7366
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7367
            return \Illuminate\Http\Request::setTrustedProxies($proxies, $trustedHeaderSet);
7368
        }
7369
        
7370
        /**
7371
         * Gets the list of trusted proxies.
7372
         *
7373
         * @return array An array of trusted proxies
7374
         * @static 
7375
         */ 
7376
        public static function getTrustedProxies()
7377
        {
7378
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7379
            return \Illuminate\Http\Request::getTrustedProxies();
7380
        }
7381
        
7382
        /**
7383
         * Gets the set of trusted headers from trusted proxies.
7384
         *
7385
         * @return int A bit field of Request::HEADER_* that defines which headers are trusted from your proxies
7386
         * @static 
7387
         */ 
7388
        public static function getTrustedHeaderSet()
7389
        {
7390
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7391
            return \Illuminate\Http\Request::getTrustedHeaderSet();
7392
        }
7393
        
7394
        /**
7395
         * Sets a list of trusted host patterns.
7396
         * 
7397
         * You should only list the hosts you manage using regexs.
7398
         *
7399
         * @param array $hostPatterns A list of trusted host patterns
7400
         * @static 
7401
         */ 
7402
        public static function setTrustedHosts($hostPatterns)
7403
        {
7404
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7405
            return \Illuminate\Http\Request::setTrustedHosts($hostPatterns);
7406
        }
7407
        
7408
        /**
7409
         * Gets the list of trusted host patterns.
7410
         *
7411
         * @return array An array of trusted host patterns
7412
         * @static 
7413
         */ 
7414
        public static function getTrustedHosts()
7415
        {
7416
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7417
            return \Illuminate\Http\Request::getTrustedHosts();
7418
        }
7419
        
7420
        /**
7421
         * Normalizes a query string.
7422
         * 
7423
         * It builds a normalized query string, where keys/value pairs are alphabetized,
7424
         * have consistent escaping and unneeded delimiters are removed.
7425
         *
7426
         * @param string $qs Query string
7427
         * @return string A normalized query string for the Request
7428
         * @static 
7429
         */ 
7430
        public static function normalizeQueryString($qs)
7431
        {
7432
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7433
            return \Illuminate\Http\Request::normalizeQueryString($qs);
7434
        }
7435
        
7436
        /**
7437
         * Enables support for the _method request parameter to determine the intended HTTP method.
7438
         * 
7439
         * Be warned that enabling this feature might lead to CSRF issues in your code.
7440
         * Check that you are using CSRF tokens when required.
7441
         * If the HTTP method parameter override is enabled, an html-form with method "POST" can be altered
7442
         * and used to send a "PUT" or "DELETE" request via the _method request parameter.
7443
         * If these methods are not protected against CSRF, this presents a possible vulnerability.
7444
         * 
7445
         * The HTTP method can only be overridden when the real HTTP method is POST.
7446
         *
7447
         * @static 
7448
         */ 
7449
        public static function enableHttpMethodParameterOverride()
7450
        {
7451
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7452
            return \Illuminate\Http\Request::enableHttpMethodParameterOverride();
7453
        }
7454
        
7455
        /**
7456
         * Checks whether support for the _method request parameter is enabled.
7457
         *
7458
         * @return bool True when the _method request parameter is enabled, false otherwise
7459
         * @static 
7460
         */ 
7461
        public static function getHttpMethodParameterOverride()
7462
        {
7463
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7464
            return \Illuminate\Http\Request::getHttpMethodParameterOverride();
7465
        }
7466
        
7467
        /**
7468
         * Gets a "parameter" value from any bag.
7469
         * 
7470
         * This method is mainly useful for libraries that want to provide some flexibility. If you don't need the
7471
         * flexibility in controllers, it is better to explicitly get request parameters from the appropriate
7472
         * public property instead (attributes, query, request).
7473
         * 
7474
         * Order of precedence: PATH (routing placeholders or custom attributes), GET, BODY
7475
         *
7476
         * @param string $key The key
7477
         * @param mixed $default The default value if the parameter key does not exist
7478
         * @return mixed 
7479
         * @static 
7480
         */ 
7481
        public static function get($key, $default = null)
7482
        {
7483
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7484
            return \Illuminate\Http\Request::get($key, $default);
7485
        }
7486
        
7487
        /**
7488
         * Whether the request contains a Session which was started in one of the
7489
         * previous requests.
7490
         *
7491
         * @return bool 
7492
         * @static 
7493
         */ 
7494
        public static function hasPreviousSession()
7495
        {
7496
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7497
            return \Illuminate\Http\Request::hasPreviousSession();
7498
        }
7499
        
7500
        /**
7501
         * Whether the request contains a Session object.
7502
         * 
7503
         * This method does not give any information about the state of the session object,
7504
         * like whether the session is started or not. It is just a way to check if this Request
7505
         * is associated with a Session instance.
7506
         *
7507
         * @return bool true when the Request contains a Session object, false otherwise
7508
         * @static 
7509
         */ 
7510
        public static function hasSession()
7511
        {
7512
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7513
            return \Illuminate\Http\Request::hasSession();
7514
        }
7515
        
7516
        /**
7517
         * Sets the Session.
7518
         *
7519
         * @param \Symfony\Component\HttpFoundation\SessionInterface $session The Session
7520
         * @static 
7521
         */ 
7522
        public static function setSession($session)
7523
        {
7524
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7525
            return \Illuminate\Http\Request::setSession($session);
7526
        }
7527
        
7528
        /**
7529
         * Returns the client IP addresses.
7530
         * 
7531
         * In the returned array the most trusted IP address is first, and the
7532
         * least trusted one last. The "real" client IP address is the last one,
7533
         * but this is also the least trusted one. Trusted proxies are stripped.
7534
         * 
7535
         * Use this method carefully; you should use getClientIp() instead.
7536
         *
7537
         * @return array The client IP addresses
7538
         * @see getClientIp()
7539
         * @static 
7540
         */ 
7541
        public static function getClientIps()
7542
        {
7543
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7544
            return \Illuminate\Http\Request::getClientIps();
7545
        }
7546
        
7547
        /**
7548
         * Returns the client IP address.
7549
         * 
7550
         * This method can read the client IP address from the "X-Forwarded-For" header
7551
         * when trusted proxies were set via "setTrustedProxies()". The "X-Forwarded-For"
7552
         * header value is a comma+space separated list of IP addresses, the left-most
7553
         * being the original client, and each successive proxy that passed the request
7554
         * adding the IP address where it received the request from.
7555
         *
7556
         * @return string|null The client IP address
7557
         * @see getClientIps()
7558
         * @see http://en.wikipedia.org/wiki/X-Forwarded-For
7559
         * @static 
7560
         */ 
7561
        public static function getClientIp()
7562
        {
7563
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7564
            return \Illuminate\Http\Request::getClientIp();
7565
        }
7566
        
7567
        /**
7568
         * Returns current script name.
7569
         *
7570
         * @return string 
7571
         * @static 
7572
         */ 
7573
        public static function getScriptName()
7574
        {
7575
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7576
            return \Illuminate\Http\Request::getScriptName();
7577
        }
7578
        
7579
        /**
7580
         * Returns the path being requested relative to the executed script.
7581
         * 
7582
         * The path info always starts with a /.
7583
         * 
7584
         * Suppose this request is instantiated from /mysite on localhost:
7585
         * 
7586
         *  * http://localhost/mysite              returns an empty string
7587
         *  * http://localhost/mysite/about        returns '/about'
7588
         *  * http://localhost/mysite/enco%20ded   returns '/enco%20ded'
7589
         *  * http://localhost/mysite/about?var=1  returns '/about'
7590
         *
7591
         * @return string The raw path (i.e. not urldecoded)
7592
         * @static 
7593
         */ 
7594
        public static function getPathInfo()
7595
        {
7596
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7597
            return \Illuminate\Http\Request::getPathInfo();
7598
        }
7599
        
7600
        /**
7601
         * Returns the root path from which this request is executed.
7602
         * 
7603
         * Suppose that an index.php file instantiates this request object:
7604
         * 
7605
         *  * http://localhost/index.php         returns an empty string
7606
         *  * http://localhost/index.php/page    returns an empty string
7607
         *  * http://localhost/web/index.php     returns '/web'
7608
         *  * http://localhost/we%20b/index.php  returns '/we%20b'
7609
         *
7610
         * @return string The raw path (i.e. not urldecoded)
7611
         * @static 
7612
         */ 
7613
        public static function getBasePath()
7614
        {
7615
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7616
            return \Illuminate\Http\Request::getBasePath();
7617
        }
7618
        
7619
        /**
7620
         * Returns the root URL from which this request is executed.
7621
         * 
7622
         * The base URL never ends with a /.
7623
         * 
7624
         * This is similar to getBasePath(), except that it also includes the
7625
         * script filename (e.g. index.php) if one exists.
7626
         *
7627
         * @return string The raw URL (i.e. not urldecoded)
7628
         * @static 
7629
         */ 
7630
        public static function getBaseUrl()
7631
        {
7632
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7633
            return \Illuminate\Http\Request::getBaseUrl();
7634
        }
7635
        
7636
        /**
7637
         * Gets the request's scheme.
7638
         *
7639
         * @return string 
7640
         * @static 
7641
         */ 
7642
        public static function getScheme()
7643
        {
7644
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7645
            return \Illuminate\Http\Request::getScheme();
7646
        }
7647
        
7648
        /**
7649
         * Returns the port on which the request is made.
7650
         * 
7651
         * This method can read the client port from the "X-Forwarded-Port" header
7652
         * when trusted proxies were set via "setTrustedProxies()".
7653
         * 
7654
         * The "X-Forwarded-Port" header must contain the client port.
7655
         *
7656
         * @return int|string can be a string if fetched from the server bag
7657
         * @static 
7658
         */ 
7659
        public static function getPort()
7660
        {
7661
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7662
            return \Illuminate\Http\Request::getPort();
7663
        }
7664
        
7665
        /**
7666
         * Returns the user.
7667
         *
7668
         * @return string|null 
7669
         * @static 
7670
         */ 
7671
        public static function getUser()
7672
        {
7673
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7674
            return \Illuminate\Http\Request::getUser();
7675
        }
7676
        
7677
        /**
7678
         * Returns the password.
7679
         *
7680
         * @return string|null 
7681
         * @static 
7682
         */ 
7683
        public static function getPassword()
7684
        {
7685
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7686
            return \Illuminate\Http\Request::getPassword();
7687
        }
7688
        
7689
        /**
7690
         * Gets the user info.
7691
         *
7692
         * @return string A user name and, optionally, scheme-specific information about how to gain authorization to access the server
7693
         * @static 
7694
         */ 
7695
        public static function getUserInfo()
7696
        {
7697
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7698
            return \Illuminate\Http\Request::getUserInfo();
7699
        }
7700
        
7701
        /**
7702
         * Returns the HTTP host being requested.
7703
         * 
7704
         * The port name will be appended to the host if it's non-standard.
7705
         *
7706
         * @return string 
7707
         * @static 
7708
         */ 
7709
        public static function getHttpHost()
7710
        {
7711
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7712
            return \Illuminate\Http\Request::getHttpHost();
7713
        }
7714
        
7715
        /**
7716
         * Returns the requested URI (path and query string).
7717
         *
7718
         * @return string The raw URI (i.e. not URI decoded)
7719
         * @static 
7720
         */ 
7721
        public static function getRequestUri()
7722
        {
7723
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7724
            return \Illuminate\Http\Request::getRequestUri();
7725
        }
7726
        
7727
        /**
7728
         * Gets the scheme and HTTP host.
7729
         * 
7730
         * If the URL was called with basic authentication, the user
7731
         * and the password are not added to the generated string.
7732
         *
7733
         * @return string The scheme and HTTP host
7734
         * @static 
7735
         */ 
7736
        public static function getSchemeAndHttpHost()
7737
        {
7738
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7739
            return \Illuminate\Http\Request::getSchemeAndHttpHost();
7740
        }
7741
        
7742
        /**
7743
         * Generates a normalized URI (URL) for the Request.
7744
         *
7745
         * @return string A normalized URI (URL) for the Request
7746
         * @see getQueryString()
7747
         * @static 
7748
         */ 
7749
        public static function getUri()
7750
        {
7751
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7752
            return \Illuminate\Http\Request::getUri();
7753
        }
7754
        
7755
        /**
7756
         * Generates a normalized URI for the given path.
7757
         *
7758
         * @param string $path A path to use instead of the current one
7759
         * @return string The normalized URI for the path
7760
         * @static 
7761
         */ 
7762
        public static function getUriForPath($path)
7763
        {
7764
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7765
            return \Illuminate\Http\Request::getUriForPath($path);
7766
        }
7767
        
7768
        /**
7769
         * Returns the path as relative reference from the current Request path.
7770
         * 
7771
         * Only the URIs path component (no schema, host etc.) is relevant and must be given.
7772
         * Both paths must be absolute and not contain relative parts.
7773
         * Relative URLs from one resource to another are useful when generating self-contained downloadable document archives.
7774
         * Furthermore, they can be used to reduce the link size in documents.
7775
         * 
7776
         * Example target paths, given a base path of "/a/b/c/d":
7777
         * - "/a/b/c/d"     -> ""
7778
         * - "/a/b/c/"      -> "./"
7779
         * - "/a/b/"        -> "../"
7780
         * - "/a/b/c/other" -> "other"
7781
         * - "/a/x/y"       -> "../../x/y"
7782
         *
7783
         * @param string $path The target path
7784
         * @return string The relative target path
7785
         * @static 
7786
         */ 
7787
        public static function getRelativeUriForPath($path)
7788
        {
7789
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7790
            return \Illuminate\Http\Request::getRelativeUriForPath($path);
7791
        }
7792
        
7793
        /**
7794
         * Generates the normalized query string for the Request.
7795
         * 
7796
         * It builds a normalized query string, where keys/value pairs are alphabetized
7797
         * and have consistent escaping.
7798
         *
7799
         * @return string|null A normalized query string for the Request
7800
         * @static 
7801
         */ 
7802
        public static function getQueryString()
7803
        {
7804
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7805
            return \Illuminate\Http\Request::getQueryString();
7806
        }
7807
        
7808
        /**
7809
         * Checks whether the request is secure or not.
7810
         * 
7811
         * This method can read the client protocol from the "X-Forwarded-Proto" header
7812
         * when trusted proxies were set via "setTrustedProxies()".
7813
         * 
7814
         * The "X-Forwarded-Proto" header must contain the protocol: "https" or "http".
7815
         *
7816
         * @return bool 
7817
         * @static 
7818
         */ 
7819
        public static function isSecure()
7820
        {
7821
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7822
            return \Illuminate\Http\Request::isSecure();
7823
        }
7824
        
7825
        /**
7826
         * Returns the host name.
7827
         * 
7828
         * This method can read the client host name from the "X-Forwarded-Host" header
7829
         * when trusted proxies were set via "setTrustedProxies()".
7830
         * 
7831
         * The "X-Forwarded-Host" header must contain the client host name.
7832
         *
7833
         * @return string 
7834
         * @throws SuspiciousOperationException when the host name is invalid or not trusted
7835
         * @static 
7836
         */ 
7837
        public static function getHost()
7838
        {
7839
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7840
            return \Illuminate\Http\Request::getHost();
7841
        }
7842
        
7843
        /**
7844
         * Sets the request method.
7845
         *
7846
         * @param string $method
7847
         * @static 
7848
         */ 
7849
        public static function setMethod($method)
7850
        {
7851
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7852
            return \Illuminate\Http\Request::setMethod($method);
7853
        }
7854
        
7855
        /**
7856
         * Gets the request "intended" method.
7857
         * 
7858
         * If the X-HTTP-Method-Override header is set, and if the method is a POST,
7859
         * then it is used to determine the "real" intended HTTP method.
7860
         * 
7861
         * The _method request parameter can also be used to determine the HTTP method,
7862
         * but only if enableHttpMethodParameterOverride() has been called.
7863
         * 
7864
         * The method is always an uppercased string.
7865
         *
7866
         * @return string The request method
7867
         * @see getRealMethod()
7868
         * @static 
7869
         */ 
7870
        public static function getMethod()
7871
        {
7872
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7873
            return \Illuminate\Http\Request::getMethod();
7874
        }
7875
        
7876
        /**
7877
         * Gets the "real" request method.
7878
         *
7879
         * @return string The request method
7880
         * @see getMethod()
7881
         * @static 
7882
         */ 
7883
        public static function getRealMethod()
7884
        {
7885
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7886
            return \Illuminate\Http\Request::getRealMethod();
7887
        }
7888
        
7889
        /**
7890
         * Gets the mime type associated with the format.
7891
         *
7892
         * @param string $format The format
7893
         * @return string The associated mime type (null if not found)
7894
         * @static 
7895
         */ 
7896
        public static function getMimeType($format)
7897
        {
7898
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7899
            return \Illuminate\Http\Request::getMimeType($format);
7900
        }
7901
        
7902
        /**
7903
         * Gets the mime types associated with the format.
7904
         *
7905
         * @param string $format The format
7906
         * @return array The associated mime types
7907
         * @static 
7908
         */ 
7909
        public static function getMimeTypes($format)
7910
        {
7911
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7912
            return \Illuminate\Http\Request::getMimeTypes($format);
7913
        }
7914
        
7915
        /**
7916
         * Gets the format associated with the mime type.
7917
         *
7918
         * @param string $mimeType The associated mime type
7919
         * @return string|null The format (null if not found)
7920
         * @static 
7921
         */ 
7922
        public static function getFormat($mimeType)
7923
        {
7924
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7925
            return \Illuminate\Http\Request::getFormat($mimeType);
7926
        }
7927
        
7928
        /**
7929
         * Associates a format with mime types.
7930
         *
7931
         * @param string $format The format
7932
         * @param string|array $mimeTypes The associated mime types (the preferred one must be the first as it will be used as the content type)
7933
         * @static 
7934
         */ 
7935
        public static function setFormat($format, $mimeTypes)
7936
        {
7937
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7938
            return \Illuminate\Http\Request::setFormat($format, $mimeTypes);
7939
        }
7940
        
7941
        /**
7942
         * Gets the request format.
7943
         * 
7944
         * Here is the process to determine the format:
7945
         * 
7946
         *  * format defined by the user (with setRequestFormat())
7947
         *  * _format request attribute
7948
         *  * $default
7949
         *
7950
         * @param string $default The default format
7951
         * @return string The request format
7952
         * @static 
7953
         */ 
7954
        public static function getRequestFormat($default = 'html')
7955
        {
7956
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7957
            return \Illuminate\Http\Request::getRequestFormat($default);
7958
        }
7959
        
7960
        /**
7961
         * Sets the request format.
7962
         *
7963
         * @param string $format The request format
7964
         * @static 
7965
         */ 
7966
        public static function setRequestFormat($format)
7967
        {
7968
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7969
            return \Illuminate\Http\Request::setRequestFormat($format);
7970
        }
7971
        
7972
        /**
7973
         * Gets the format associated with the request.
7974
         *
7975
         * @return string|null The format (null if no content type is present)
7976
         * @static 
7977
         */ 
7978
        public static function getContentType()
7979
        {
7980
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7981
            return \Illuminate\Http\Request::getContentType();
7982
        }
7983
        
7984
        /**
7985
         * Sets the default locale.
7986
         *
7987
         * @param string $locale
7988
         * @static 
7989
         */ 
7990
        public static function setDefaultLocale($locale)
7991
        {
7992
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
7993
            return \Illuminate\Http\Request::setDefaultLocale($locale);
7994
        }
7995
        
7996
        /**
7997
         * Get the default locale.
7998
         *
7999
         * @return string 
8000
         * @static 
8001
         */ 
8002
        public static function getDefaultLocale()
8003
        {
8004
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8005
            return \Illuminate\Http\Request::getDefaultLocale();
8006
        }
8007
        
8008
        /**
8009
         * Sets the locale.
8010
         *
8011
         * @param string $locale
8012
         * @static 
8013
         */ 
8014
        public static function setLocale($locale)
8015
        {
8016
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8017
            return \Illuminate\Http\Request::setLocale($locale);
8018
        }
8019
        
8020
        /**
8021
         * Get the locale.
8022
         *
8023
         * @return string 
8024
         * @static 
8025
         */ 
8026
        public static function getLocale()
8027
        {
8028
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8029
            return \Illuminate\Http\Request::getLocale();
8030
        }
8031
        
8032
        /**
8033
         * Checks if the request method is of specified type.
8034
         *
8035
         * @param string $method Uppercase request method (GET, POST etc)
8036
         * @return bool 
8037
         * @static 
8038
         */ 
8039
        public static function isMethod($method)
8040
        {
8041
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8042
            return \Illuminate\Http\Request::isMethod($method);
8043
        }
8044
        
8045
        /**
8046
         * Checks whether or not the method is safe.
8047
         *
8048
         * @see https://tools.ietf.org/html/rfc7231#section-4.2.1
8049
         * @param bool $andCacheable Adds the additional condition that the method should be cacheable. True by default.
8050
         * @return bool 
8051
         * @static 
8052
         */ 
8053
        public static function isMethodSafe()
8054
        {
8055
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8056
            return \Illuminate\Http\Request::isMethodSafe();
8057
        }
8058
        
8059
        /**
8060
         * Checks whether or not the method is idempotent.
8061
         *
8062
         * @return bool 
8063
         * @static 
8064
         */ 
8065
        public static function isMethodIdempotent()
8066
        {
8067
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8068
            return \Illuminate\Http\Request::isMethodIdempotent();
8069
        }
8070
        
8071
        /**
8072
         * Checks whether the method is cacheable or not.
8073
         *
8074
         * @see https://tools.ietf.org/html/rfc7231#section-4.2.3
8075
         * @return bool 
8076
         * @static 
8077
         */ 
8078
        public static function isMethodCacheable()
8079
        {
8080
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8081
            return \Illuminate\Http\Request::isMethodCacheable();
8082
        }
8083
        
8084
        /**
8085
         * Returns the protocol version.
8086
         * 
8087
         * If the application is behind a proxy, the protocol version used in the
8088
         * requests between the client and the proxy and between the proxy and the
8089
         * server might be different. This returns the former (from the "Via" header)
8090
         * if the proxy is trusted (see "setTrustedProxies()"), otherwise it returns
8091
         * the latter (from the "SERVER_PROTOCOL" server parameter).
8092
         *
8093
         * @return string 
8094
         * @static 
8095
         */ 
8096
        public static function getProtocolVersion()
8097
        {
8098
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8099
            return \Illuminate\Http\Request::getProtocolVersion();
8100
        }
8101
        
8102
        /**
8103
         * Returns the request body content.
8104
         *
8105
         * @param bool $asResource If true, a resource will be returned
8106
         * @return string|resource The request body content or a resource to read the body stream
8107
         * @throws \LogicException
8108
         * @static 
8109
         */ 
8110
        public static function getContent($asResource = false)
8111
        {
8112
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8113
            return \Illuminate\Http\Request::getContent($asResource);
8114
        }
8115
        
8116
        /**
8117
         * Gets the Etags.
8118
         *
8119
         * @return array The entity tags
8120
         * @static 
8121
         */ 
8122
        public static function getETags()
8123
        {
8124
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8125
            return \Illuminate\Http\Request::getETags();
8126
        }
8127
        
8128
        /**
8129
         * 
8130
         *
8131
         * @return bool 
8132
         * @static 
8133
         */ 
8134
        public static function isNoCache()
8135
        {
8136
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8137
            return \Illuminate\Http\Request::isNoCache();
8138
        }
8139
        
8140
        /**
8141
         * Returns the preferred language.
8142
         *
8143
         * @param array $locales An array of ordered available locales
8144
         * @return string|null The preferred locale
8145
         * @static 
8146
         */ 
8147
        public static function getPreferredLanguage($locales = null)
8148
        {
8149
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8150
            return \Illuminate\Http\Request::getPreferredLanguage($locales);
8151
        }
8152
        
8153
        /**
8154
         * Gets a list of languages acceptable by the client browser.
8155
         *
8156
         * @return array Languages ordered in the user browser preferences
8157
         * @static 
8158
         */ 
8159
        public static function getLanguages()
8160
        {
8161
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8162
            return \Illuminate\Http\Request::getLanguages();
8163
        }
8164
        
8165
        /**
8166
         * Gets a list of charsets acceptable by the client browser.
8167
         *
8168
         * @return array List of charsets in preferable order
8169
         * @static 
8170
         */ 
8171
        public static function getCharsets()
8172
        {
8173
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8174
            return \Illuminate\Http\Request::getCharsets();
8175
        }
8176
        
8177
        /**
8178
         * Gets a list of encodings acceptable by the client browser.
8179
         *
8180
         * @return array List of encodings in preferable order
8181
         * @static 
8182
         */ 
8183
        public static function getEncodings()
8184
        {
8185
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8186
            return \Illuminate\Http\Request::getEncodings();
8187
        }
8188
        
8189
        /**
8190
         * Gets a list of content types acceptable by the client browser.
8191
         *
8192
         * @return array List of content types in preferable order
8193
         * @static 
8194
         */ 
8195
        public static function getAcceptableContentTypes()
8196
        {
8197
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8198
            return \Illuminate\Http\Request::getAcceptableContentTypes();
8199
        }
8200
        
8201
        /**
8202
         * Returns true if the request is a XMLHttpRequest.
8203
         * 
8204
         * It works if your JavaScript library sets an X-Requested-With HTTP header.
8205
         * It is known to work with common JavaScript frameworks:
8206
         *
8207
         * @see http://en.wikipedia.org/wiki/List_of_Ajax_frameworks#JavaScript
8208
         * @return bool true if the request is an XMLHttpRequest, false otherwise
8209
         * @static 
8210
         */ 
8211
        public static function isXmlHttpRequest()
8212
        {
8213
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8214
            return \Illuminate\Http\Request::isXmlHttpRequest();
8215
        }
8216
        
8217
        /**
8218
         * Indicates whether this request originated from a trusted proxy.
8219
         * 
8220
         * This can be useful to determine whether or not to trust the
8221
         * contents of a proxy-specific header.
8222
         *
8223
         * @return bool true if the request came from a trusted proxy, false otherwise
8224
         * @static 
8225
         */ 
8226
        public static function isFromTrustedProxy()
8227
        {
8228
            //Method inherited from \Symfony\Component\HttpFoundation\Request            
8229
            return \Illuminate\Http\Request::isFromTrustedProxy();
8230
        }
8231
        
8232
        /**
8233
         * Determine if the given content types match.
8234
         *
8235
         * @param string $actual
8236
         * @param string $type
8237
         * @return bool 
8238
         * @static 
8239
         */ 
8240
        public static function matchesType($actual, $type)
8241
        {
8242
            return \Illuminate\Http\Request::matchesType($actual, $type);
8243
        }
8244
        
8245
        /**
8246
         * Determine if the request is sending JSON.
8247
         *
8248
         * @return bool 
8249
         * @static 
8250
         */ 
8251
        public static function isJson()
8252
        {
8253
            return \Illuminate\Http\Request::isJson();
8254
        }
8255
        
8256
        /**
8257
         * Determine if the current request probably expects a JSON response.
8258
         *
8259
         * @return bool 
8260
         * @static 
8261
         */ 
8262
        public static function expectsJson()
8263
        {
8264
            return \Illuminate\Http\Request::expectsJson();
8265
        }
8266
        
8267
        /**
8268
         * Determine if the current request is asking for JSON.
8269
         *
8270
         * @return bool 
8271
         * @static 
8272
         */ 
8273
        public static function wantsJson()
8274
        {
8275
            return \Illuminate\Http\Request::wantsJson();
8276
        }
8277
        
8278
        /**
8279
         * Determines whether the current requests accepts a given content type.
8280
         *
8281
         * @param string|array $contentTypes
8282
         * @return bool 
8283
         * @static 
8284
         */ 
8285
        public static function accepts($contentTypes)
8286
        {
8287
            return \Illuminate\Http\Request::accepts($contentTypes);
8288
        }
8289
        
8290
        /**
8291
         * Return the most suitable content type from the given array based on content negotiation.
8292
         *
8293
         * @param string|array $contentTypes
8294
         * @return string|null 
8295
         * @static 
8296
         */ 
8297
        public static function prefers($contentTypes)
8298
        {
8299
            return \Illuminate\Http\Request::prefers($contentTypes);
8300
        }
8301
        
8302
        /**
8303
         * Determine if the current request accepts any content type.
8304
         *
8305
         * @return bool 
8306
         * @static 
8307
         */ 
8308
        public static function acceptsAnyContentType()
8309
        {
8310
            return \Illuminate\Http\Request::acceptsAnyContentType();
8311
        }
8312
        
8313
        /**
8314
         * Determines whether a request accepts JSON.
8315
         *
8316
         * @return bool 
8317
         * @static 
8318
         */ 
8319
        public static function acceptsJson()
8320
        {
8321
            return \Illuminate\Http\Request::acceptsJson();
8322
        }
8323
        
8324
        /**
8325
         * Determines whether a request accepts HTML.
8326
         *
8327
         * @return bool 
8328
         * @static 
8329
         */ 
8330
        public static function acceptsHtml()
8331
        {
8332
            return \Illuminate\Http\Request::acceptsHtml();
8333
        }
8334
        
8335
        /**
8336
         * Get the data format expected in the response.
8337
         *
8338
         * @param string $default
8339
         * @return string 
8340
         * @static 
8341
         */ 
8342
        public static function format($default = 'html')
8343
        {
8344
            return \Illuminate\Http\Request::format($default);
8345
        }
8346
        
8347
        /**
8348
         * Retrieve an old input item.
8349
         *
8350
         * @param string $key
8351
         * @param string|array|null $default
8352
         * @return string|array 
8353
         * @static 
8354
         */ 
8355
        public static function old($key = null, $default = null)
8356
        {
8357
            return \Illuminate\Http\Request::old($key, $default);
8358
        }
8359
        
8360
        /**
8361
         * Flash the input for the current request to the session.
8362
         *
8363
         * @return void 
8364
         * @static 
8365
         */ 
8366
        public static function flash()
8367
        {
8368
            \Illuminate\Http\Request::flash();
8369
        }
8370
        
8371
        /**
8372
         * Flash only some of the input to the session.
8373
         *
8374
         * @param array|mixed $keys
8375
         * @return void 
8376
         * @static 
8377
         */ 
8378
        public static function flashOnly($keys)
8379
        {
8380
            \Illuminate\Http\Request::flashOnly($keys);
8381
        }
8382
        
8383
        /**
8384
         * Flash only some of the input to the session.
8385
         *
8386
         * @param array|mixed $keys
8387
         * @return void 
8388
         * @static 
8389
         */ 
8390
        public static function flashExcept($keys)
8391
        {
8392
            \Illuminate\Http\Request::flashExcept($keys);
8393
        }
8394
        
8395
        /**
8396
         * Flush all of the old input from the session.
8397
         *
8398
         * @return void 
8399
         * @static 
8400
         */ 
8401
        public static function flush()
8402
        {
8403
            \Illuminate\Http\Request::flush();
8404
        }
8405
        
8406
        /**
8407
         * Retrieve a server variable from the request.
8408
         *
8409
         * @param string $key
8410
         * @param string|array|null $default
8411
         * @return string|array 
8412
         * @static 
8413
         */ 
8414
        public static function server($key = null, $default = null)
8415
        {
8416
            return \Illuminate\Http\Request::server($key, $default);
8417
        }
8418
        
8419
        /**
8420
         * Determine if a header is set on the request.
8421
         *
8422
         * @param string $key
8423
         * @return bool 
8424
         * @static 
8425
         */ 
8426
        public static function hasHeader($key)
8427
        {
8428
            return \Illuminate\Http\Request::hasHeader($key);
8429
        }
8430
        
8431
        /**
8432
         * Retrieve a header from the request.
8433
         *
8434
         * @param string $key
8435
         * @param string|array|null $default
8436
         * @return string|array 
8437
         * @static 
8438
         */ 
8439
        public static function header($key = null, $default = null)
8440
        {
8441
            return \Illuminate\Http\Request::header($key, $default);
8442
        }
8443
        
8444
        /**
8445
         * Get the bearer token from the request headers.
8446
         *
8447
         * @return string|null 
8448
         * @static 
8449
         */ 
8450
        public static function bearerToken()
8451
        {
8452
            return \Illuminate\Http\Request::bearerToken();
8453
        }
8454
        
8455
        /**
8456
         * Determine if the request contains a given input item key.
8457
         *
8458
         * @param string|array $key
8459
         * @return bool 
8460
         * @static 
8461
         */ 
8462
        public static function exists($key)
8463
        {
8464
            return \Illuminate\Http\Request::exists($key);
8465
        }
8466
        
8467
        /**
8468
         * Determine if the request contains a given input item key.
8469
         *
8470
         * @param string|array $key
8471
         * @return bool 
8472
         * @static 
8473
         */ 
8474
        public static function has($key)
8475
        {
8476
            return \Illuminate\Http\Request::has($key);
8477
        }
8478
        
8479
        /**
8480
         * Determine if the request contains any of the given inputs.
8481
         *
8482
         * @param string|array $key
8483
         * @return bool 
8484
         * @static 
8485
         */ 
8486
        public static function hasAny($keys)
8487
        {
8488
            return \Illuminate\Http\Request::hasAny($keys);
8489
        }
8490
        
8491
        /**
8492
         * Determine if the request contains a non-empty value for an input item.
8493
         *
8494
         * @param string|array $key
8495
         * @return bool 
8496
         * @static 
8497
         */ 
8498
        public static function filled($key)
8499
        {
8500
            return \Illuminate\Http\Request::filled($key);
8501
        }
8502
        
8503
        /**
8504
         * Determine if the request contains a non-empty value for any of the given inputs.
8505
         *
8506
         * @param string|array $keys
8507
         * @return bool 
8508
         * @static 
8509
         */ 
8510
        public static function anyFilled($keys)
8511
        {
8512
            return \Illuminate\Http\Request::anyFilled($keys);
8513
        }
8514
        
8515
        /**
8516
         * Get the keys for all of the input and files.
8517
         *
8518
         * @return array 
8519
         * @static 
8520
         */ 
8521
        public static function keys()
8522
        {
8523
            return \Illuminate\Http\Request::keys();
8524
        }
8525
        
8526
        /**
8527
         * Get all of the input and files for the request.
8528
         *
8529
         * @param array|mixed $keys
8530
         * @return array 
8531
         * @static 
8532
         */ 
8533
        public static function all($keys = null)
8534
        {
8535
            return \Illuminate\Http\Request::all($keys);
8536
        }
8537
        
8538
        /**
8539
         * Retrieve an input item from the request.
8540
         *
8541
         * @param string|null $key
8542
         * @param string|array|null $default
8543
         * @return string|array|null 
8544
         * @static 
8545
         */ 
8546
        public static function input($key = null, $default = null)
8547
        {
8548
            return \Illuminate\Http\Request::input($key, $default);
8549
        }
8550
        
8551
        /**
8552
         * Get a subset containing the provided keys with values from the input data.
8553
         *
8554
         * @param array|mixed $keys
8555
         * @return array 
8556
         * @static 
8557
         */ 
8558
        public static function only($keys)
8559
        {
8560
            return \Illuminate\Http\Request::only($keys);
8561
        }
8562
        
8563
        /**
8564
         * Get all of the input except for a specified array of items.
8565
         *
8566
         * @param array|mixed $keys
8567
         * @return array 
8568
         * @static 
8569
         */ 
8570
        public static function except($keys)
8571
        {
8572
            return \Illuminate\Http\Request::except($keys);
8573
        }
8574
        
8575
        /**
8576
         * Retrieve a query string item from the request.
8577
         *
8578
         * @param string $key
8579
         * @param string|array|null $default
8580
         * @return string|array 
8581
         * @static 
8582
         */ 
8583
        public static function query($key = null, $default = null)
8584
        {
8585
            return \Illuminate\Http\Request::query($key, $default);
8586
        }
8587
        
8588
        /**
8589
         * Retrieve a request payload item from the request.
8590
         *
8591
         * @param string $key
8592
         * @param string|array|null $default
8593
         * @return string|array 
8594
         * @static 
8595
         */ 
8596
        public static function post($key = null, $default = null)
8597
        {
8598
            return \Illuminate\Http\Request::post($key, $default);
8599
        }
8600
        
8601
        /**
8602
         * Determine if a cookie is set on the request.
8603
         *
8604
         * @param string $key
8605
         * @return bool 
8606
         * @static 
8607
         */ 
8608
        public static function hasCookie($key)
8609
        {
8610
            return \Illuminate\Http\Request::hasCookie($key);
8611
        }
8612
        
8613
        /**
8614
         * Retrieve a cookie from the request.
8615
         *
8616
         * @param string $key
8617
         * @param string|array|null $default
8618
         * @return string|array 
8619
         * @static 
8620
         */ 
8621
        public static function cookie($key = null, $default = null)
8622
        {
8623
            return \Illuminate\Http\Request::cookie($key, $default);
8624
        }
8625
        
8626
        /**
8627
         * Get an array of all of the files on the request.
8628
         *
8629
         * @return array 
8630
         * @static 
8631
         */ 
8632
        public static function allFiles()
8633
        {
8634
            return \Illuminate\Http\Request::allFiles();
8635
        }
8636
        
8637
        /**
8638
         * Determine if the uploaded data contains a file.
8639
         *
8640
         * @param string $key
8641
         * @return bool 
8642
         * @static 
8643
         */ 
8644
        public static function hasFile($key)
8645
        {
8646
            return \Illuminate\Http\Request::hasFile($key);
8647
        }
8648
        
8649
        /**
8650
         * Retrieve a file from the request.
8651
         *
8652
         * @param string $key
8653
         * @param mixed $default
8654
         * @return \Illuminate\Http\UploadedFile|array|null 
8655
         * @static 
8656
         */ 
8657
        public static function file($key = null, $default = null)
8658
        {
8659
            return \Illuminate\Http\Request::file($key, $default);
8660
        }
8661
        
8662
        /**
8663
         * Register a custom macro.
8664
         *
8665
         * @param string $name
8666
         * @param object|callable $macro
8667
         * @return void 
8668
         * @static 
8669
         */ 
8670
        public static function macro($name, $macro)
8671
        {
8672
            \Illuminate\Http\Request::macro($name, $macro);
8673
        }
8674
        
8675
        /**
8676
         * Mix another object into the class.
8677
         *
8678
         * @param object $mixin
8679
         * @return void 
8680
         * @static 
8681
         */ 
8682
        public static function mixin($mixin)
8683
        {
8684
            \Illuminate\Http\Request::mixin($mixin);
8685
        }
8686
        
8687
        /**
8688
         * Checks if macro is registered.
8689
         *
8690
         * @param string $name
8691
         * @return bool 
8692
         * @static 
8693
         */ 
8694
        public static function hasMacro($name)
8695
        {
8696
            return \Illuminate\Http\Request::hasMacro($name);
8697
        }
8698
        
8699
        /**
8700
         * 
8701
         *
8702
         * @static 
8703
         */ 
8704
        public static function validate($rules, $params = null)
8705
        {
8706
            return \Illuminate\Http\Request::validate($rules, $params);
8707
        }
8708
        
8709
        /**
8710
         * 
8711
         *
8712
         * @static 
8713
         */ 
8714
        public static function hasValidSignature()
8715
        {
8716
            return \Illuminate\Http\Request::hasValidSignature();
8717
        }
8718
         
8719
    }
8720

8721
    class Response {
8722
        
8723
        /**
8724
         * Return a new response from the application.
8725
         *
8726
         * @param string $content
8727
         * @param int $status
8728
         * @param array $headers
8729
         * @return \Illuminate\Http\Response 
8730
         * @static 
8731
         */ 
8732
        public static function make($content = '', $status = 200, $headers = array())
8733
        {
8734
            return \Illuminate\Routing\ResponseFactory::make($content, $status, $headers);
8735
        }
8736
        
8737
        /**
8738
         * Return a new view response from the application.
8739
         *
8740
         * @param string $view
8741
         * @param array $data
8742
         * @param int $status
8743
         * @param array $headers
8744
         * @return \Illuminate\Http\Response 
8745
         * @static 
8746
         */ 
8747
        public static function view($view, $data = array(), $status = 200, $headers = array())
8748
        {
8749
            return \Illuminate\Routing\ResponseFactory::view($view, $data, $status, $headers);
8750
        }
8751
        
8752
        /**
8753
         * Return a new JSON response from the application.
8754
         *
8755
         * @param mixed $data
8756
         * @param int $status
8757
         * @param array $headers
8758
         * @param int $options
8759
         * @return \Illuminate\Http\JsonResponse 
8760
         * @static 
8761
         */ 
8762
        public static function json($data = array(), $status = 200, $headers = array(), $options = 0)
8763
        {
8764
            return \Illuminate\Routing\ResponseFactory::json($data, $status, $headers, $options);
8765
        }
8766
        
8767
        /**
8768
         * Return a new JSONP response from the application.
8769
         *
8770
         * @param string $callback
8771
         * @param mixed $data
8772
         * @param int $status
8773
         * @param array $headers
8774
         * @param int $options
8775
         * @return \Illuminate\Http\JsonResponse 
8776
         * @static 
8777
         */ 
8778
        public static function jsonp($callback, $data = array(), $status = 200, $headers = array(), $options = 0)
8779
        {
8780
            return \Illuminate\Routing\ResponseFactory::jsonp($callback, $data, $status, $headers, $options);
8781
        }
8782
        
8783
        /**
8784
         * Return a new streamed response from the application.
8785
         *
8786
         * @param \Closure $callback
8787
         * @param int $status
8788
         * @param array $headers
8789
         * @return \Symfony\Component\HttpFoundation\StreamedResponse 
8790
         * @static 
8791
         */ 
8792
        public static function stream($callback, $status = 200, $headers = array())
8793
        {
8794
            return \Illuminate\Routing\ResponseFactory::stream($callback, $status, $headers);
8795
        }
8796
        
8797
        /**
8798
         * Return a new streamed response as a file download from the application.
8799
         *
8800
         * @param \Closure $callback
8801
         * @param string|null $name
8802
         * @param array $headers
8803
         * @param string|null $disposition
8804
         * @return \Symfony\Component\HttpFoundation\StreamedResponse 
8805
         * @static 
8806
         */ 
8807
        public static function streamDownload($callback, $name = null, $headers = array(), $disposition = 'attachment')
8808
        {
8809
            return \Illuminate\Routing\ResponseFactory::streamDownload($callback, $name, $headers, $disposition);
8810
        }
8811
        
8812
        /**
8813
         * Create a new file download response.
8814
         *
8815
         * @param \SplFileInfo|string $file
8816
         * @param string|null $name
8817
         * @param array $headers
8818
         * @param string|null $disposition
8819
         * @return \Symfony\Component\HttpFoundation\BinaryFileResponse 
8820
         * @static 
8821
         */ 
8822
        public static function download($file, $name = null, $headers = array(), $disposition = 'attachment')
8823
        {
8824
            return \Illuminate\Routing\ResponseFactory::download($file, $name, $headers, $disposition);
8825
        }
8826
        
8827
        /**
8828
         * Return the raw contents of a binary file.
8829
         *
8830
         * @param \SplFileInfo|string $file
8831
         * @param array $headers
8832
         * @return \Symfony\Component\HttpFoundation\BinaryFileResponse 
8833
         * @static 
8834
         */ 
8835
        public static function file($file, $headers = array())
8836
        {
8837
            return \Illuminate\Routing\ResponseFactory::file($file, $headers);
8838
        }
8839
        
8840
        /**
8841
         * Create a new redirect response to the given path.
8842
         *
8843
         * @param string $path
8844
         * @param int $status
8845
         * @param array $headers
8846
         * @param bool|null $secure
8847
         * @return \Illuminate\Http\RedirectResponse 
8848
         * @static 
8849
         */ 
8850
        public static function redirectTo($path, $status = 302, $headers = array(), $secure = null)
8851
        {
8852
            return \Illuminate\Routing\ResponseFactory::redirectTo($path, $status, $headers, $secure);
8853
        }
8854
        
8855
        /**
8856
         * Create a new redirect response to a named route.
8857
         *
8858
         * @param string $route
8859
         * @param array $parameters
8860
         * @param int $status
8861
         * @param array $headers
8862
         * @return \Illuminate\Http\RedirectResponse 
8863
         * @static 
8864
         */ 
8865
        public static function redirectToRoute($route, $parameters = array(), $status = 302, $headers = array())
8866
        {
8867
            return \Illuminate\Routing\ResponseFactory::redirectToRoute($route, $parameters, $status, $headers);
8868
        }
8869
        
8870
        /**
8871
         * Create a new redirect response to a controller action.
8872
         *
8873
         * @param string $action
8874
         * @param array $parameters
8875
         * @param int $status
8876
         * @param array $headers
8877
         * @return \Illuminate\Http\RedirectResponse 
8878
         * @static 
8879
         */ 
8880
        public static function redirectToAction($action, $parameters = array(), $status = 302, $headers = array())
8881
        {
8882
            return \Illuminate\Routing\ResponseFactory::redirectToAction($action, $parameters, $status, $headers);
8883
        }
8884
        
8885
        /**
8886
         * Create a new redirect response, while putting the current URL in the session.
8887
         *
8888
         * @param string $path
8889
         * @param int $status
8890
         * @param array $headers
8891
         * @param bool|null $secure
8892
         * @return \Illuminate\Http\RedirectResponse 
8893
         * @static 
8894
         */ 
8895
        public static function redirectGuest($path, $status = 302, $headers = array(), $secure = null)
8896
        {
8897
            return \Illuminate\Routing\ResponseFactory::redirectGuest($path, $status, $headers, $secure);
8898
        }
8899
        
8900
        /**
8901
         * Create a new redirect response to the previously intended location.
8902
         *
8903
         * @param string $default
8904
         * @param int $status
8905
         * @param array $headers
8906
         * @param bool|null $secure
8907
         * @return \Illuminate\Http\RedirectResponse 
8908
         * @static 
8909
         */ 
8910
        public static function redirectToIntended($default = '/', $status = 302, $headers = array(), $secure = null)
8911
        {
8912
            return \Illuminate\Routing\ResponseFactory::redirectToIntended($default, $status, $headers, $secure);
8913
        }
8914
        
8915
        /**
8916
         * Register a custom macro.
8917
         *
8918
         * @param string $name
8919
         * @param object|callable $macro
8920
         * @return void 
8921
         * @static 
8922
         */ 
8923
        public static function macro($name, $macro)
8924
        {
8925
            \Illuminate\Routing\ResponseFactory::macro($name, $macro);
8926
        }
8927
        
8928
        /**
8929
         * Mix another object into the class.
8930
         *
8931
         * @param object $mixin
8932
         * @return void 
8933
         * @static 
8934
         */ 
8935
        public static function mixin($mixin)
8936
        {
8937
            \Illuminate\Routing\ResponseFactory::mixin($mixin);
8938
        }
8939
        
8940
        /**
8941
         * Checks if macro is registered.
8942
         *
8943
         * @param string $name
8944
         * @return bool 
8945
         * @static 
8946
         */ 
8947
        public static function hasMacro($name)
8948
        {
8949
            return \Illuminate\Routing\ResponseFactory::hasMacro($name);
8950
        }
8951
         
8952
    }
8953

8954
    class Route {
8955
        
8956
        /**
8957
         * Register a new GET route with the router.
8958
         *
8959
         * @param string $uri
8960
         * @param \Closure|array|string|null $action
8961
         * @return \Illuminate\Routing\Route 
8962
         * @static 
8963
         */ 
8964
        public static function get($uri, $action = null)
8965
        {
8966
            return \Illuminate\Routing\Router::get($uri, $action);
8967
        }
8968
        
8969
        /**
8970
         * Register a new POST route with the router.
8971
         *
8972
         * @param string $uri
8973
         * @param \Closure|array|string|null $action
8974
         * @return \Illuminate\Routing\Route 
8975
         * @static 
8976
         */ 
8977
        public static function post($uri, $action = null)
8978
        {
8979
            return \Illuminate\Routing\Router::post($uri, $action);
8980
        }
8981
        
8982
        /**
8983
         * Register a new PUT route with the router.
8984
         *
8985
         * @param string $uri
8986
         * @param \Closure|array|string|null $action
8987
         * @return \Illuminate\Routing\Route 
8988
         * @static 
8989
         */ 
8990
        public static function put($uri, $action = null)
8991
        {
8992
            return \Illuminate\Routing\Router::put($uri, $action);
8993
        }
8994
        
8995
        /**
8996
         * Register a new PATCH route with the router.
8997
         *
8998
         * @param string $uri
8999
         * @param \Closure|array|string|null $action
9000
         * @return \Illuminate\Routing\Route 
9001
         * @static 
9002
         */ 
9003
        public static function patch($uri, $action = null)
9004
        {
9005
            return \Illuminate\Routing\Router::patch($uri, $action);
9006
        }
9007
        
9008
        /**
9009
         * Register a new DELETE route with the router.
9010
         *
9011
         * @param string $uri
9012
         * @param \Closure|array|string|null $action
9013
         * @return \Illuminate\Routing\Route 
9014
         * @static 
9015
         */ 
9016
        public static function delete($uri, $action = null)
9017
        {
9018
            return \Illuminate\Routing\Router::delete($uri, $action);
9019
        }
9020
        
9021
        /**
9022
         * Register a new OPTIONS route with the router.
9023
         *
9024
         * @param string $uri
9025
         * @param \Closure|array|string|null $action
9026
         * @return \Illuminate\Routing\Route 
9027
         * @static 
9028
         */ 
9029
        public static function options($uri, $action = null)
9030
        {
9031
            return \Illuminate\Routing\Router::options($uri, $action);
9032
        }
9033
        
9034
        /**
9035
         * Register a new route responding to all verbs.
9036
         *
9037
         * @param string $uri
9038
         * @param \Closure|array|string|null $action
9039
         * @return \Illuminate\Routing\Route 
9040
         * @static 
9041
         */ 
9042
        public static function any($uri, $action = null)
9043
        {
9044
            return \Illuminate\Routing\Router::any($uri, $action);
9045
        }
9046
        
9047
        /**
9048
         * Register a new Fallback route with the router.
9049
         *
9050
         * @param \Closure|array|string|null $action
9051
         * @return \Illuminate\Routing\Route 
9052
         * @static 
9053
         */ 
9054
        public static function fallback($action)
9055
        {
9056
            return \Illuminate\Routing\Router::fallback($action);
9057
        }
9058
        
9059
        /**
9060
         * Create a redirect from one URI to another.
9061
         *
9062
         * @param string $uri
9063
         * @param string $destination
9064
         * @param int $status
9065
         * @return \Illuminate\Routing\Route 
9066
         * @static 
9067
         */ 
9068
        public static function redirect($uri, $destination, $status = 301)
9069
        {
9070
            return \Illuminate\Routing\Router::redirect($uri, $destination, $status);
9071
        }
9072
        
9073
        /**
9074
         * Register a new route that returns a view.
9075
         *
9076
         * @param string $uri
9077
         * @param string $view
9078
         * @param array $data
9079
         * @return \Illuminate\Routing\Route 
9080
         * @static 
9081
         */ 
9082
        public static function view($uri, $view, $data = array())
9083
        {
9084
            return \Illuminate\Routing\Router::view($uri, $view, $data);
9085
        }
9086
        
9087
        /**
9088
         * Register a new route with the given verbs.
9089
         *
9090
         * @param array|string $methods
9091
         * @param string $uri
9092
         * @param \Closure|array|string|null $action
9093
         * @return \Illuminate\Routing\Route 
9094
         * @static 
9095
         */ 
9096
        public static function match($methods, $uri, $action = null)
9097
        {
9098
            return \Illuminate\Routing\Router::match($methods, $uri, $action);
9099
        }
9100
        
9101
        /**
9102
         * Register an array of resource controllers.
9103
         *
9104
         * @param array $resources
9105
         * @return void 
9106
         * @static 
9107
         */ 
9108
        public static function resources($resources)
9109
        {
9110
            \Illuminate\Routing\Router::resources($resources);
9111
        }
9112
        
9113
        /**
9114
         * Route a resource to a controller.
9115
         *
9116
         * @param string $name
9117
         * @param string $controller
9118
         * @param array $options
9119
         * @return \Illuminate\Routing\PendingResourceRegistration 
9120
         * @static 
9121
         */ 
9122
        public static function resource($name, $controller, $options = array())
9123
        {
9124
            return \Illuminate\Routing\Router::resource($name, $controller, $options);
9125
        }
9126
        
9127
        /**
9128
         * Register an array of API resource controllers.
9129
         *
9130
         * @param array $resources
9131
         * @return void 
9132
         * @static 
9133
         */ 
9134
        public static function apiResources($resources)
9135
        {
9136
            \Illuminate\Routing\Router::apiResources($resources);
9137
        }
9138
        
9139
        /**
9140
         * Route an API resource to a controller.
9141
         *
9142
         * @param string $name
9143
         * @param string $controller
9144
         * @param array $options
9145
         * @return \Illuminate\Routing\PendingResourceRegistration 
9146
         * @static 
9147
         */ 
9148
        public static function apiResource($name, $controller, $options = array())
9149
        {
9150
            return \Illuminate\Routing\Router::apiResource($name, $controller, $options);
9151
        }
9152
        
9153
        /**
9154
         * Create a route group with shared attributes.
9155
         *
9156
         * @param array $attributes
9157
         * @param \Closure|string $routes
9158
         * @return void 
9159
         * @static 
9160
         */ 
9161
        public static function group($attributes, $routes)
9162
        {
9163
            \Illuminate\Routing\Router::group($attributes, $routes);
9164
        }
9165
        
9166
        /**
9167
         * Merge the given array with the last group stack.
9168
         *
9169
         * @param array $new
9170
         * @return array 
9171
         * @static 
9172
         */ 
9173
        public static function mergeWithLastGroup($new)
9174
        {
9175
            return \Illuminate\Routing\Router::mergeWithLastGroup($new);
9176
        }
9177
        
9178
        /**
9179
         * Get the prefix from the last group on the stack.
9180
         *
9181
         * @return string 
9182
         * @static 
9183
         */ 
9184
        public static function getLastGroupPrefix()
9185
        {
9186
            return \Illuminate\Routing\Router::getLastGroupPrefix();
9187
        }
9188
        
9189
        /**
9190
         * Return the response returned by the given route.
9191
         *
9192
         * @param string $name
9193
         * @return mixed 
9194
         * @static 
9195
         */ 
9196
        public static function respondWithRoute($name)
9197
        {
9198
            return \Illuminate\Routing\Router::respondWithRoute($name);
9199
        }
9200
        
9201
        /**
9202
         * Dispatch the request to the application.
9203
         *
9204
         * @param \Illuminate\Http\Request $request
9205
         * @return \Illuminate\Http\Response|\Illuminate\Http\JsonResponse 
9206
         * @static 
9207
         */ 
9208
        public static function dispatch($request)
9209
        {
9210
            return \Illuminate\Routing\Router::dispatch($request);
9211
        }
9212
        
9213
        /**
9214
         * Dispatch the request to a route and return the response.
9215
         *
9216
         * @param \Illuminate\Http\Request $request
9217
         * @return mixed 
9218
         * @static 
9219
         */ 
9220
        public static function dispatchToRoute($request)
9221
        {
9222
            return \Illuminate\Routing\Router::dispatchToRoute($request);
9223
        }
9224
        
9225
        /**
9226
         * Gather the middleware for the given route with resolved class names.
9227
         *
9228
         * @param \Illuminate\Routing\Route $route
9229
         * @return array 
9230
         * @static 
9231
         */ 
9232
        public static function gatherRouteMiddleware($route)
9233
        {
9234
            return \Illuminate\Routing\Router::gatherRouteMiddleware($route);
9235
        }
9236
        
9237
        /**
9238
         * Create a response instance from the given value.
9239
         *
9240
         * @param \Symfony\Component\HttpFoundation\Request $request
9241
         * @param mixed $response
9242
         * @return \Illuminate\Http\Response|\Illuminate\Http\JsonResponse 
9243
         * @static 
9244
         */ 
9245
        public static function prepareResponse($request, $response)
9246
        {
9247
            return \Illuminate\Routing\Router::prepareResponse($request, $response);
9248
        }
9249
        
9250
        /**
9251
         * Static version of prepareResponse.
9252
         *
9253
         * @param \Symfony\Component\HttpFoundation\Request $request
9254
         * @param mixed $response
9255
         * @return \Illuminate\Http\Response|\Illuminate\Http\JsonResponse 
9256
         * @static 
9257
         */ 
9258
        public static function toResponse($request, $response)
9259
        {
9260
            return \Illuminate\Routing\Router::toResponse($request, $response);
9261
        }
9262
        
9263
        /**
9264
         * Substitute the route bindings onto the route.
9265
         *
9266
         * @param \Illuminate\Routing\Route $route
9267
         * @return \Illuminate\Routing\Route 
9268
         * @static 
9269
         */ 
9270
        public static function substituteBindings($route)
9271
        {
9272
            return \Illuminate\Routing\Router::substituteBindings($route);
9273
        }
9274
        
9275
        /**
9276
         * Substitute the implicit Eloquent model bindings for the route.
9277
         *
9278
         * @param \Illuminate\Routing\Route $route
9279
         * @return void 
9280
         * @static 
9281
         */ 
9282
        public static function substituteImplicitBindings($route)
9283
        {
9284
            \Illuminate\Routing\Router::substituteImplicitBindings($route);
9285
        }
9286
        
9287
        /**
9288
         * Register a route matched event listener.
9289
         *
9290
         * @param string|callable $callback
9291
         * @return void 
9292
         * @static 
9293
         */ 
9294
        public static function matched($callback)
9295
        {
9296
            \Illuminate\Routing\Router::matched($callback);
9297
        }
9298
        
9299
        /**
9300
         * Get all of the defined middleware short-hand names.
9301
         *
9302
         * @return array 
9303
         * @static 
9304
         */ 
9305
        public static function getMiddleware()
9306
        {
9307
            return \Illuminate\Routing\Router::getMiddleware();
9308
        }
9309
        
9310
        /**
9311
         * Register a short-hand name for a middleware.
9312
         *
9313
         * @param string $name
9314
         * @param string $class
9315
         * @return $this 
9316
         * @static 
9317
         */ 
9318
        public static function aliasMiddleware($name, $class)
9319
        {
9320
            return \Illuminate\Routing\Router::aliasMiddleware($name, $class);
9321
        }
9322
        
9323
        /**
9324
         * Check if a middlewareGroup with the given name exists.
9325
         *
9326
         * @param string $name
9327
         * @return bool 
9328
         * @static 
9329
         */ 
9330
        public static function hasMiddlewareGroup($name)
9331
        {
9332
            return \Illuminate\Routing\Router::hasMiddlewareGroup($name);
9333
        }
9334
        
9335
        /**
9336
         * Get all of the defined middleware groups.
9337
         *
9338
         * @return array 
9339
         * @static 
9340
         */ 
9341
        public static function getMiddlewareGroups()
9342
        {
9343
            return \Illuminate\Routing\Router::getMiddlewareGroups();
9344
        }
9345
        
9346
        /**
9347
         * Register a group of middleware.
9348
         *
9349
         * @param string $name
9350
         * @param array $middleware
9351
         * @return $this 
9352
         * @static 
9353
         */ 
9354
        public static function middlewareGroup($name, $middleware)
9355
        {
9356
            return \Illuminate\Routing\Router::middlewareGroup($name, $middleware);
9357
        }
9358
        
9359
        /**
9360
         * Add a middleware to the beginning of a middleware group.
9361
         * 
9362
         * If the middleware is already in the group, it will not be added again.
9363
         *
9364
         * @param string $group
9365
         * @param string $middleware
9366
         * @return $this 
9367
         * @static 
9368
         */ 
9369
        public static function prependMiddlewareToGroup($group, $middleware)
9370
        {
9371
            return \Illuminate\Routing\Router::prependMiddlewareToGroup($group, $middleware);
9372
        }
9373
        
9374
        /**
9375
         * Add a middleware to the end of a middleware group.
9376
         * 
9377
         * If the middleware is already in the group, it will not be added again.
9378
         *
9379
         * @param string $group
9380
         * @param string $middleware
9381
         * @return $this 
9382
         * @static 
9383
         */ 
9384
        public static function pushMiddlewareToGroup($group, $middleware)
9385
        {
9386
            return \Illuminate\Routing\Router::pushMiddlewareToGroup($group, $middleware);
9387
        }
9388
        
9389
        /**
9390
         * Add a new route parameter binder.
9391
         *
9392
         * @param string $key
9393
         * @param string|callable $binder
9394
         * @return void 
9395
         * @static 
9396
         */ 
9397
        public static function bind($key, $binder)
9398
        {
9399
            \Illuminate\Routing\Router::bind($key, $binder);
9400
        }
9401
        
9402
        /**
9403
         * Register a model binder for a wildcard.
9404
         *
9405
         * @param string $key
9406
         * @param string $class
9407
         * @param \Closure|null $callback
9408
         * @return void 
9409
         * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
9410
         * @static 
9411
         */ 
9412
        public static function model($key, $class, $callback = null)
9413
        {
9414
            \Illuminate\Routing\Router::model($key, $class, $callback);
9415
        }
9416
        
9417
        /**
9418
         * Get the binding callback for a given binding.
9419
         *
9420
         * @param string $key
9421
         * @return \Closure|null 
9422
         * @static 
9423
         */ 
9424
        public static function getBindingCallback($key)
9425
        {
9426
            return \Illuminate\Routing\Router::getBindingCallback($key);
9427
        }
9428
        
9429
        /**
9430
         * Get the global "where" patterns.
9431
         *
9432
         * @return array 
9433
         * @static 
9434
         */ 
9435
        public static function getPatterns()
9436
        {
9437
            return \Illuminate\Routing\Router::getPatterns();
9438
        }
9439
        
9440
        /**
9441
         * Set a global where pattern on all routes.
9442
         *
9443
         * @param string $key
9444
         * @param string $pattern
9445
         * @return void 
9446
         * @static 
9447
         */ 
9448
        public static function pattern($key, $pattern)
9449
        {
9450
            \Illuminate\Routing\Router::pattern($key, $pattern);
9451
        }
9452
        
9453
        /**
9454
         * Set a group of global where patterns on all routes.
9455
         *
9456
         * @param array $patterns
9457
         * @return void 
9458
         * @static 
9459
         */ 
9460
        public static function patterns($patterns)
9461
        {
9462
            \Illuminate\Routing\Router::patterns($patterns);
9463
        }
9464
        
9465
        /**
9466
         * Determine if the router currently has a group stack.
9467
         *
9468
         * @return bool 
9469
         * @static 
9470
         */ 
9471
        public static function hasGroupStack()
9472
        {
9473
            return \Illuminate\Routing\Router::hasGroupStack();
9474
        }
9475
        
9476
        /**
9477
         * Get the current group stack for the router.
9478
         *
9479
         * @return array 
9480
         * @static 
9481
         */ 
9482
        public static function getGroupStack()
9483
        {
9484
            return \Illuminate\Routing\Router::getGroupStack();
9485
        }
9486
        
9487
        /**
9488
         * Get a route parameter for the current route.
9489
         *
9490
         * @param string $key
9491
         * @param string $default
9492
         * @return mixed 
9493
         * @static 
9494
         */ 
9495
        public static function input($key, $default = null)
9496
        {
9497
            return \Illuminate\Routing\Router::input($key, $default);
9498
        }
9499
        
9500
        /**
9501
         * Get the request currently being dispatched.
9502
         *
9503
         * @return \Illuminate\Http\Request 
9504
         * @static 
9505
         */ 
9506
        public static function getCurrentRequest()
9507
        {
9508
            return \Illuminate\Routing\Router::getCurrentRequest();
9509
        }
9510
        
9511
        /**
9512
         * Get the currently dispatched route instance.
9513
         *
9514
         * @return \Illuminate\Routing\Route 
9515
         * @static 
9516
         */ 
9517
        public static function getCurrentRoute()
9518
        {
9519
            return \Illuminate\Routing\Router::getCurrentRoute();
9520
        }
9521
        
9522
        /**
9523
         * Get the currently dispatched route instance.
9524
         *
9525
         * @return \Illuminate\Routing\Route 
9526
         * @static 
9527
         */ 
9528
        public static function current()
9529
        {
9530
            return \Illuminate\Routing\Router::current();
9531
        }
9532
        
9533
        /**
9534
         * Check if a route with the given name exists.
9535
         *
9536
         * @param string $name
9537
         * @return bool 
9538
         * @static 
9539
         */ 
9540
        public static function has($name)
9541
        {
9542
            return \Illuminate\Routing\Router::has($name);
9543
        }
9544
        
9545
        /**
9546
         * Get the current route name.
9547
         *
9548
         * @return string|null 
9549
         * @static 
9550
         */ 
9551
        public static function currentRouteName()
9552
        {
9553
            return \Illuminate\Routing\Router::currentRouteName();
9554
        }
9555
        
9556
        /**
9557
         * Alias for the "currentRouteNamed" method.
9558
         *
9559
         * @param mixed $patterns
9560
         * @return bool 
9561
         * @static 
9562
         */ 
9563
        public static function is($patterns = null)
9564
        {
9565
            return \Illuminate\Routing\Router::is($patterns);
9566
        }
9567
        
9568
        /**
9569
         * Determine if the current route matches a pattern.
9570
         *
9571
         * @param mixed $patterns
9572
         * @return bool 
9573
         * @static 
9574
         */ 
9575
        public static function currentRouteNamed($patterns = null)
9576
        {
9577
            return \Illuminate\Routing\Router::currentRouteNamed($patterns);
9578
        }
9579
        
9580
        /**
9581
         * Get the current route action.
9582
         *
9583
         * @return string|null 
9584
         * @static 
9585
         */ 
9586
        public static function currentRouteAction()
9587
        {
9588
            return \Illuminate\Routing\Router::currentRouteAction();
9589
        }
9590
        
9591
        /**
9592
         * Alias for the "currentRouteUses" method.
9593
         *
9594
         * @param array $patterns
9595
         * @return bool 
9596
         * @static 
9597
         */ 
9598
        public static function uses($patterns = null)
9599
        {
9600
            return \Illuminate\Routing\Router::uses($patterns);
9601
        }
9602
        
9603
        /**
9604
         * Determine if the current route action matches a given action.
9605
         *
9606
         * @param string $action
9607
         * @return bool 
9608
         * @static 
9609
         */ 
9610
        public static function currentRouteUses($action)
9611
        {
9612
            return \Illuminate\Routing\Router::currentRouteUses($action);
9613
        }
9614
        
9615
        /**
9616
         * Register the typical authentication routes for an application.
9617
         *
9618
         * @return void 
9619
         * @static 
9620
         */ 
9621
        public static function auth()
9622
        {
9623
            \Illuminate\Routing\Router::auth();
9624
        }
9625
        
9626
        /**
9627
         * Set the unmapped global resource parameters to singular.
9628
         *
9629
         * @param bool $singular
9630
         * @return void 
9631
         * @static 
9632
         */ 
9633
        public static function singularResourceParameters($singular = true)
9634
        {
9635
            \Illuminate\Routing\Router::singularResourceParameters($singular);
9636
        }
9637
        
9638
        /**
9639
         * Set the global resource parameter mapping.
9640
         *
9641
         * @param array $parameters
9642
         * @return void 
9643
         * @static 
9644
         */ 
9645
        public static function resourceParameters($parameters = array())
9646
        {
9647
            \Illuminate\Routing\Router::resourceParameters($parameters);
9648
        }
9649
        
9650
        /**
9651
         * Get or set the verbs used in the resource URIs.
9652
         *
9653
         * @param array $verbs
9654
         * @return array|null 
9655
         * @static 
9656
         */ 
9657
        public static function resourceVerbs($verbs = array())
9658
        {
9659
            return \Illuminate\Routing\Router::resourceVerbs($verbs);
9660
        }
9661
        
9662
        /**
9663
         * Get the underlying route collection.
9664
         *
9665
         * @return \Illuminate\Routing\RouteCollection 
9666
         * @static 
9667
         */ 
9668
        public static function getRoutes()
9669
        {
9670
            return \Illuminate\Routing\Router::getRoutes();
9671
        }
9672
        
9673
        /**
9674
         * Set the route collection instance.
9675
         *
9676
         * @param \Illuminate\Routing\RouteCollection $routes
9677
         * @return void 
9678
         * @static 
9679
         */ 
9680
        public static function setRoutes($routes)
9681
        {
9682
            \Illuminate\Routing\Router::setRoutes($routes);
9683
        }
9684
        
9685
        /**
9686
         * Register a custom macro.
9687
         *
9688
         * @param string $name
9689
         * @param object|callable $macro
9690
         * @return void 
9691
         * @static 
9692
         */ 
9693
        public static function macro($name, $macro)
9694
        {
9695
            \Illuminate\Routing\Router::macro($name, $macro);
9696
        }
9697
        
9698
        /**
9699
         * Mix another object into the class.
9700
         *
9701
         * @param object $mixin
9702
         * @return void 
9703
         * @static 
9704
         */ 
9705
        public static function mixin($mixin)
9706
        {
9707
            \Illuminate\Routing\Router::mixin($mixin);
9708
        }
9709
        
9710
        /**
9711
         * Checks if macro is registered.
9712
         *
9713
         * @param string $name
9714
         * @return bool 
9715
         * @static 
9716
         */ 
9717
        public static function hasMacro($name)
9718
        {
9719
            return \Illuminate\Routing\Router::hasMacro($name);
9720
        }
9721
        
9722
        /**
9723
         * Dynamically handle calls to the class.
9724
         *
9725
         * @param string $method
9726
         * @param array $parameters
9727
         * @return mixed 
9728
         * @throws \BadMethodCallException
9729
         * @static 
9730
         */ 
9731
        public static function macroCall($method, $parameters)
9732
        {
9733
            return \Illuminate\Routing\Router::macroCall($method, $parameters);
9734
        }
9735
         
9736
    }
9737

9738
    class Schema {
9739
        
9740
        /**
9741
         * Determine if the given table exists.
9742
         *
9743
         * @param string $table
9744
         * @return bool 
9745
         * @static 
9746
         */ 
9747
        public static function hasTable($table)
9748
        {
9749
            return \Illuminate\Database\Schema\MySqlBuilder::hasTable($table);
9750
        }
9751
        
9752
        /**
9753
         * Get the column listing for a given table.
9754
         *
9755
         * @param string $table
9756
         * @return array 
9757
         * @static 
9758
         */ 
9759
        public static function getColumnListing($table)
9760
        {
9761
            return \Illuminate\Database\Schema\MySqlBuilder::getColumnListing($table);
9762
        }
9763
        
9764
        /**
9765
         * Drop all tables from the database.
9766
         *
9767
         * @return void 
9768
         * @static 
9769
         */ 
9770
        public static function dropAllTables()
9771
        {
9772
            \Illuminate\Database\Schema\MySqlBuilder::dropAllTables();
9773
        }
9774
        
9775
        /**
9776
         * Set the default string length for migrations.
9777
         *
9778
         * @param int $length
9779
         * @return void 
9780
         * @static 
9781
         */ 
9782
        public static function defaultStringLength($length)
9783
        {
9784
            //Method inherited from \Illuminate\Database\Schema\Builder            
9785
            \Illuminate\Database\Schema\MySqlBuilder::defaultStringLength($length);
9786
        }
9787
        
9788
        /**
9789
         * Determine if the given table has a given column.
9790
         *
9791
         * @param string $table
9792
         * @param string $column
9793
         * @return bool 
9794
         * @static 
9795
         */ 
9796
        public static function hasColumn($table, $column)
9797
        {
9798
            //Method inherited from \Illuminate\Database\Schema\Builder            
9799
            return \Illuminate\Database\Schema\MySqlBuilder::hasColumn($table, $column);
9800
        }
9801
        
9802
        /**
9803
         * Determine if the given table has given columns.
9804
         *
9805
         * @param string $table
9806
         * @param array $columns
9807
         * @return bool 
9808
         * @static 
9809
         */ 
9810
        public static function hasColumns($table, $columns)
9811
        {
9812
            //Method inherited from \Illuminate\Database\Schema\Builder            
9813
            return \Illuminate\Database\Schema\MySqlBuilder::hasColumns($table, $columns);
9814
        }
9815
        
9816
        /**
9817
         * Get the data type for the given column name.
9818
         *
9819
         * @param string $table
9820
         * @param string $column
9821
         * @return string 
9822
         * @static 
9823
         */ 
9824
        public static function getColumnType($table, $column)
9825
        {
9826
            //Method inherited from \Illuminate\Database\Schema\Builder            
9827
            return \Illuminate\Database\Schema\MySqlBuilder::getColumnType($table, $column);
9828
        }
9829
        
9830
        /**
9831
         * Modify a table on the schema.
9832
         *
9833
         * @param string $table
9834
         * @param \Closure $callback
9835
         * @return void 
9836
         * @static 
9837
         */ 
9838
        public static function table($table, $callback)
9839
        {
9840
            //Method inherited from \Illuminate\Database\Schema\Builder            
9841
            \Illuminate\Database\Schema\MySqlBuilder::table($table, $callback);
9842
        }
9843
        
9844
        /**
9845
         * Create a new table on the schema.
9846
         *
9847
         * @param string $table
9848
         * @param \Closure $callback
9849
         * @return void 
9850
         * @static 
9851
         */ 
9852
        public static function create($table, $callback)
9853
        {
9854
            //Method inherited from \Illuminate\Database\Schema\Builder            
9855
            \Illuminate\Database\Schema\MySqlBuilder::create($table, $callback);
9856
        }
9857
        
9858
        /**
9859
         * Drop a table from the schema.
9860
         *
9861
         * @param string $table
9862
         * @return void 
9863
         * @static 
9864
         */ 
9865
        public static function drop($table)
9866
        {
9867
            //Method inherited from \Illuminate\Database\Schema\Builder            
9868
            \Illuminate\Database\Schema\MySqlBuilder::drop($table);
9869
        }
9870
        
9871
        /**
9872
         * Drop a table from the schema if it exists.
9873
         *
9874
         * @param string $table
9875
         * @return void 
9876
         * @static 
9877
         */ 
9878
        public static function dropIfExists($table)
9879
        {
9880
            //Method inherited from \Illuminate\Database\Schema\Builder            
9881
            \Illuminate\Database\Schema\MySqlBuilder::dropIfExists($table);
9882
        }
9883
        
9884
        /**
9885
         * Rename a table on the schema.
9886
         *
9887
         * @param string $from
9888
         * @param string $to
9889
         * @return void 
9890
         * @static 
9891
         */ 
9892
        public static function rename($from, $to)
9893
        {
9894
            //Method inherited from \Illuminate\Database\Schema\Builder            
9895
            \Illuminate\Database\Schema\MySqlBuilder::rename($from, $to);
9896
        }
9897
        
9898
        /**
9899
         * Enable foreign key constraints.
9900
         *
9901
         * @return bool 
9902
         * @static 
9903
         */ 
9904
        public static function enableForeignKeyConstraints()
9905
        {
9906
            //Method inherited from \Illuminate\Database\Schema\Builder            
9907
            return \Illuminate\Database\Schema\MySqlBuilder::enableForeignKeyConstraints();
9908
        }
9909
        
9910
        /**
9911
         * Disable foreign key constraints.
9912
         *
9913
         * @return bool 
9914
         * @static 
9915
         */ 
9916
        public static function disableForeignKeyConstraints()
9917
        {
9918
            //Method inherited from \Illuminate\Database\Schema\Builder            
9919
            return \Illuminate\Database\Schema\MySqlBuilder::disableForeignKeyConstraints();
9920
        }
9921
        
9922
        /**
9923
         * Get the database connection instance.
9924
         *
9925
         * @return \Illuminate\Database\Connection 
9926
         * @static 
9927
         */ 
9928
        public static function getConnection()
9929
        {
9930
            //Method inherited from \Illuminate\Database\Schema\Builder            
9931
            return \Illuminate\Database\Schema\MySqlBuilder::getConnection();
9932
        }
9933
        
9934
        /**
9935
         * Set the database connection instance.
9936
         *
9937
         * @param \Illuminate\Database\Connection $connection
9938
         * @return $this 
9939
         * @static 
9940
         */ 
9941
        public static function setConnection($connection)
9942
        {
9943
            //Method inherited from \Illuminate\Database\Schema\Builder            
9944
            return \Illuminate\Database\Schema\MySqlBuilder::setConnection($connection);
9945
        }
9946
        
9947
        /**
9948
         * Set the Schema Blueprint resolver callback.
9949
         *
9950
         * @param \Closure $resolver
9951
         * @return void 
9952
         * @static 
9953
         */ 
9954
        public static function blueprintResolver($resolver)
9955
        {
9956
            //Method inherited from \Illuminate\Database\Schema\Builder            
9957
            \Illuminate\Database\Schema\MySqlBuilder::blueprintResolver($resolver);
9958
        }
9959
         
9960
    }
9961

9962
    class Session {
9963
        
9964
        /**
9965
         * Get the session configuration.
9966
         *
9967
         * @return array 
9968
         * @static 
9969
         */ 
9970
        public static function getSessionConfig()
9971
        {
9972
            return \Illuminate\Session\SessionManager::getSessionConfig();
9973
        }
9974
        
9975
        /**
9976
         * Get the default session driver name.
9977
         *
9978
         * @return string 
9979
         * @static 
9980
         */ 
9981
        public static function getDefaultDriver()
9982
        {
9983
            return \Illuminate\Session\SessionManager::getDefaultDriver();
9984
        }
9985
        
9986
        /**
9987
         * Set the default session driver name.
9988
         *
9989
         * @param string $name
9990
         * @return void 
9991
         * @static 
9992
         */ 
9993
        public static function setDefaultDriver($name)
9994
        {
9995
            \Illuminate\Session\SessionManager::setDefaultDriver($name);
9996
        }
9997
        
9998
        /**
9999
         * Get a driver instance.
10000
         *
10001
         * @param string $driver
10002
         * @return mixed 
10003
         * @static 
10004
         */ 
10005
        public static function driver($driver = null)
10006
        {
10007
            //Method inherited from \Illuminate\Support\Manager            
10008
            return \Illuminate\Session\SessionManager::driver($driver);
10009
        }
10010
        
10011
        /**
10012
         * Register a custom driver creator Closure.
10013
         *
10014
         * @param string $driver
10015
         * @param \Closure $callback
10016
         * @return $this 
10017
         * @static 
10018
         */ 
10019
        public static function extend($driver, $callback)
10020
        {
10021
            //Method inherited from \Illuminate\Support\Manager            
10022
            return \Illuminate\Session\SessionManager::extend($driver, $callback);
10023
        }
10024
        
10025
        /**
10026
         * Get all of the created "drivers".
10027
         *
10028
         * @return array 
10029
         * @static 
10030
         */ 
10031
        public static function getDrivers()
10032
        {
10033
            //Method inherited from \Illuminate\Support\Manager            
10034
            return \Illuminate\Session\SessionManager::getDrivers();
10035
        }
10036
        
10037
        /**
10038
         * Start the session, reading the data from a handler.
10039
         *
10040
         * @return bool 
10041
         * @static 
10042
         */ 
10043
        public static function start()
10044
        {
10045
            return \Illuminate\Session\Store::start();
10046
        }
10047
        
10048
        /**
10049
         * Save the session data to storage.
10050
         *
10051
         * @return bool 
10052
         * @static 
10053
         */ 
10054
        public static function save()
10055
        {
10056
            return \Illuminate\Session\Store::save();
10057
        }
10058
        
10059
        /**
10060
         * Age the flash data for the session.
10061
         *
10062
         * @return void 
10063
         * @static 
10064
         */ 
10065
        public static function ageFlashData()
10066
        {
10067
            \Illuminate\Session\Store::ageFlashData();
10068
        }
10069
        
10070
        /**
10071
         * Get all of the session data.
10072
         *
10073
         * @return array 
10074
         * @static 
10075
         */ 
10076
        public static function all()
10077
        {
10078
            return \Illuminate\Session\Store::all();
10079
        }
10080
        
10081
        /**
10082
         * Checks if a key exists.
10083
         *
10084
         * @param string|array $key
10085
         * @return bool 
10086
         * @static 
10087
         */ 
10088
        public static function exists($key)
10089
        {
10090
            return \Illuminate\Session\Store::exists($key);
10091
        }
10092
        
10093
        /**
10094
         * Checks if a key is present and not null.
10095
         *
10096
         * @param string|array $key
10097
         * @return bool 
10098
         * @static 
10099
         */ 
10100
        public static function has($key)
10101
        {
10102
            return \Illuminate\Session\Store::has($key);
10103
        }
10104
        
10105
        /**
10106
         * Get an item from the session.
10107
         *
10108
         * @param string $key
10109
         * @param mixed $default
10110
         * @return mixed 
10111
         * @static 
10112
         */ 
10113
        public static function get($key, $default = null)
10114
        {
10115
            return \Illuminate\Session\Store::get($key, $default);
10116
        }
10117
        
10118
        /**
10119
         * Get the value of a given key and then forget it.
10120
         *
10121
         * @param string $key
10122
         * @param string $default
10123
         * @return mixed 
10124
         * @static 
10125
         */ 
10126
        public static function pull($key, $default = null)
10127
        {
10128
            return \Illuminate\Session\Store::pull($key, $default);
10129
        }
10130
        
10131
        /**
10132
         * Determine if the session contains old input.
10133
         *
10134
         * @param string $key
10135
         * @return bool 
10136
         * @static 
10137
         */ 
10138
        public static function hasOldInput($key = null)
10139
        {
10140
            return \Illuminate\Session\Store::hasOldInput($key);
10141
        }
10142
        
10143
        /**
10144
         * Get the requested item from the flashed input array.
10145
         *
10146
         * @param string $key
10147
         * @param mixed $default
10148
         * @return mixed 
10149
         * @static 
10150
         */ 
10151
        public static function getOldInput($key = null, $default = null)
10152
        {
10153
            return \Illuminate\Session\Store::getOldInput($key, $default);
10154
        }
10155
        
10156
        /**
10157
         * Replace the given session attributes entirely.
10158
         *
10159
         * @param array $attributes
10160
         * @return void 
10161
         * @static 
10162
         */ 
10163
        public static function replace($attributes)
10164
        {
10165
            \Illuminate\Session\Store::replace($attributes);
10166
        }
10167
        
10168
        /**
10169
         * Put a key / value pair or array of key / value pairs in the session.
10170
         *
10171
         * @param string|array $key
10172
         * @param mixed $value
10173
         * @return void 
10174
         * @static 
10175
         */ 
10176
        public static function put($key, $value = null)
10177
        {
10178
            \Illuminate\Session\Store::put($key, $value);
10179
        }
10180
        
10181
        /**
10182
         * Get an item from the session, or store the default value.
10183
         *
10184
         * @param string $key
10185
         * @param \Closure $callback
10186
         * @return mixed 
10187
         * @static 
10188
         */ 
10189
        public static function remember($key, $callback)
10190
        {
10191
            return \Illuminate\Session\Store::remember($key, $callback);
10192
        }
10193
        
10194
        /**
10195
         * Push a value onto a session array.
10196
         *
10197
         * @param string $key
10198
         * @param mixed $value
10199
         * @return void 
10200
         * @static 
10201
         */ 
10202
        public static function push($key, $value)
10203
        {
10204
            \Illuminate\Session\Store::push($key, $value);
10205
        }
10206
        
10207
        /**
10208
         * Increment the value of an item in the session.
10209
         *
10210
         * @param string $key
10211
         * @param int $amount
10212
         * @return mixed 
10213
         * @static 
10214
         */ 
10215
        public static function increment($key, $amount = 1)
10216
        {
10217
            return \Illuminate\Session\Store::increment($key, $amount);
10218
        }
10219
        
10220
        /**
10221
         * Decrement the value of an item in the session.
10222
         *
10223
         * @param string $key
10224
         * @param int $amount
10225
         * @return int 
10226
         * @static 
10227
         */ 
10228
        public static function decrement($key, $amount = 1)
10229
        {
10230
            return \Illuminate\Session\Store::decrement($key, $amount);
10231
        }
10232
        
10233
        /**
10234
         * Flash a key / value pair to the session.
10235
         *
10236
         * @param string $key
10237
         * @param mixed $value
10238
         * @return void 
10239
         * @static 
10240
         */ 
10241
        public static function flash($key, $value = true)
10242
        {
10243
            \Illuminate\Session\Store::flash($key, $value);
10244
        }
10245
        
10246
        /**
10247
         * Flash a key / value pair to the session for immediate use.
10248
         *
10249
         * @param string $key
10250
         * @param mixed $value
10251
         * @return void 
10252
         * @static 
10253
         */ 
10254
        public static function now($key, $value)
10255
        {
10256
            \Illuminate\Session\Store::now($key, $value);
10257
        }
10258
        
10259
        /**
10260
         * Reflash all of the session flash data.
10261
         *
10262
         * @return void 
10263
         * @static 
10264
         */ 
10265
        public static function reflash()
10266
        {
10267
            \Illuminate\Session\Store::reflash();
10268
        }
10269
        
10270
        /**
10271
         * Reflash a subset of the current flash data.
10272
         *
10273
         * @param array|mixed $keys
10274
         * @return void 
10275
         * @static 
10276
         */ 
10277
        public static function keep($keys = null)
10278
        {
10279
            \Illuminate\Session\Store::keep($keys);
10280
        }
10281
        
10282
        /**
10283
         * Flash an input array to the session.
10284
         *
10285
         * @param array $value
10286
         * @return void 
10287
         * @static 
10288
         */ 
10289
        public static function flashInput($value)
10290
        {
10291
            \Illuminate\Session\Store::flashInput($value);
10292
        }
10293
        
10294
        /**
10295
         * Remove an item from the session, returning its value.
10296
         *
10297
         * @param string $key
10298
         * @return mixed 
10299
         * @static 
10300
         */ 
10301
        public static function remove($key)
10302
        {
10303
            return \Illuminate\Session\Store::remove($key);
10304
        }
10305
        
10306
        /**
10307
         * Remove one or many items from the session.
10308
         *
10309
         * @param string|array $keys
10310
         * @return void 
10311
         * @static 
10312
         */ 
10313
        public static function forget($keys)
10314
        {
10315
            \Illuminate\Session\Store::forget($keys);
10316
        }
10317
        
10318
        /**
10319
         * Remove all of the items from the session.
10320
         *
10321
         * @return void 
10322
         * @static 
10323
         */ 
10324
        public static function flush()
10325
        {
10326
            \Illuminate\Session\Store::flush();
10327
        }
10328
        
10329
        /**
10330
         * Flush the session data and regenerate the ID.
10331
         *
10332
         * @return bool 
10333
         * @static 
10334
         */ 
10335
        public static function invalidate()
10336
        {
10337
            return \Illuminate\Session\Store::invalidate();
10338
        }
10339
        
10340
        /**
10341
         * Generate a new session identifier.
10342
         *
10343
         * @param bool $destroy
10344
         * @return bool 
10345
         * @static 
10346
         */ 
10347
        public static function regenerate($destroy = false)
10348
        {
10349
            return \Illuminate\Session\Store::regenerate($destroy);
10350
        }
10351
        
10352
        /**
10353
         * Generate a new session ID for the session.
10354
         *
10355
         * @param bool $destroy
10356
         * @return bool 
10357
         * @static 
10358
         */ 
10359
        public static function migrate($destroy = false)
10360
        {
10361
            return \Illuminate\Session\Store::migrate($destroy);
10362
        }
10363
        
10364
        /**
10365
         * Determine if the session has been started.
10366
         *
10367
         * @return bool 
10368
         * @static 
10369
         */ 
10370
        public static function isStarted()
10371
        {
10372
            return \Illuminate\Session\Store::isStarted();
10373
        }
10374
        
10375
        /**
10376
         * Get the name of the session.
10377
         *
10378
         * @return string 
10379
         * @static 
10380
         */ 
10381
        public static function getName()
10382
        {
10383
            return \Illuminate\Session\Store::getName();
10384
        }
10385
        
10386
        /**
10387
         * Set the name of the session.
10388
         *
10389
         * @param string $name
10390
         * @return void 
10391
         * @static 
10392
         */ 
10393
        public static function setName($name)
10394
        {
10395
            \Illuminate\Session\Store::setName($name);
10396
        }
10397
        
10398
        /**
10399
         * Get the current session ID.
10400
         *
10401
         * @return string 
10402
         * @static 
10403
         */ 
10404
        public static function getId()
10405
        {
10406
            return \Illuminate\Session\Store::getId();
10407
        }
10408
        
10409
        /**
10410
         * Set the session ID.
10411
         *
10412
         * @param string $id
10413
         * @return void 
10414
         * @static 
10415
         */ 
10416
        public static function setId($id)
10417
        {
10418
            \Illuminate\Session\Store::setId($id);
10419
        }
10420
        
10421
        /**
10422
         * Determine if this is a valid session ID.
10423
         *
10424
         * @param string $id
10425
         * @return bool 
10426
         * @static 
10427
         */ 
10428
        public static function isValidId($id)
10429
        {
10430
            return \Illuminate\Session\Store::isValidId($id);
10431
        }
10432
        
10433
        /**
10434
         * Set the existence of the session on the handler if applicable.
10435
         *
10436
         * @param bool $value
10437
         * @return void 
10438
         * @static 
10439
         */ 
10440
        public static function setExists($value)
10441
        {
10442
            \Illuminate\Session\Store::setExists($value);
10443
        }
10444
        
10445
        /**
10446
         * Get the CSRF token value.
10447
         *
10448
         * @return string 
10449
         * @static 
10450
         */ 
10451
        public static function token()
10452
        {
10453
            return \Illuminate\Session\Store::token();
10454
        }
10455
        
10456
        /**
10457
         * Regenerate the CSRF token value.
10458
         *
10459
         * @return void 
10460
         * @static 
10461
         */ 
10462
        public static function regenerateToken()
10463
        {
10464
            \Illuminate\Session\Store::regenerateToken();
10465
        }
10466
        
10467
        /**
10468
         * Get the previous URL from the session.
10469
         *
10470
         * @return string|null 
10471
         * @static 
10472
         */ 
10473
        public static function previousUrl()
10474
        {
10475
            return \Illuminate\Session\Store::previousUrl();
10476
        }
10477
        
10478
        /**
10479
         * Set the "previous" URL in the session.
10480
         *
10481
         * @param string $url
10482
         * @return void 
10483
         * @static 
10484
         */ 
10485
        public static function setPreviousUrl($url)
10486
        {
10487
            \Illuminate\Session\Store::setPreviousUrl($url);
10488
        }
10489
        
10490
        /**
10491
         * Get the underlying session handler implementation.
10492
         *
10493
         * @return \SessionHandlerInterface 
10494
         * @static 
10495
         */ 
10496
        public static function getHandler()
10497
        {
10498
            return \Illuminate\Session\Store::getHandler();
10499
        }
10500
        
10501
        /**
10502
         * Determine if the session handler needs a request.
10503
         *
10504
         * @return bool 
10505
         * @static 
10506
         */ 
10507
        public static function handlerNeedsRequest()
10508
        {
10509
            return \Illuminate\Session\Store::handlerNeedsRequest();
10510
        }
10511
        
10512
        /**
10513
         * Set the request on the handler instance.
10514
         *
10515
         * @param \Illuminate\Http\Request $request
10516
         * @return void 
10517
         * @static 
10518
         */ 
10519
        public static function setRequestOnHandler($request)
10520
        {
10521
            \Illuminate\Session\Store::setRequestOnHandler($request);
10522
        }
10523
         
10524
    }
10525

10526
    class Storage {
10527
        
10528
        /**
10529
         * Get a filesystem instance.
10530
         *
10531
         * @param string $name
10532
         * @return \Illuminate\Filesystem\FilesystemAdapter 
10533
         * @static 
10534
         */ 
10535
        public static function drive($name = null)
10536
        {
10537
            return \Illuminate\Filesystem\FilesystemManager::drive($name);
10538
        }
10539
        
10540
        /**
10541
         * Get a filesystem instance.
10542
         *
10543
         * @param string $name
10544
         * @return \Illuminate\Filesystem\FilesystemAdapter 
10545
         * @static 
10546
         */ 
10547
        public static function disk($name = null)
10548
        {
10549
            return \Illuminate\Filesystem\FilesystemManager::disk($name);
10550
        }
10551
        
10552
        /**
10553
         * Get a default cloud filesystem instance.
10554
         *
10555
         * @return \Illuminate\Filesystem\FilesystemAdapter 
10556
         * @static 
10557
         */ 
10558
        public static function cloud()
10559
        {
10560
            return \Illuminate\Filesystem\FilesystemManager::cloud();
10561
        }
10562
        
10563
        /**
10564
         * Create an instance of the local driver.
10565
         *
10566
         * @param array $config
10567
         * @return \Illuminate\Filesystem\FilesystemAdapter 
10568
         * @static 
10569
         */ 
10570
        public static function createLocalDriver($config)
10571
        {
10572
            return \Illuminate\Filesystem\FilesystemManager::createLocalDriver($config);
10573
        }
10574
        
10575
        /**
10576
         * Create an instance of the ftp driver.
10577
         *
10578
         * @param array $config
10579
         * @return \Illuminate\Filesystem\FilesystemAdapter 
10580
         * @static 
10581
         */ 
10582
        public static function createFtpDriver($config)
10583
        {
10584
            return \Illuminate\Filesystem\FilesystemManager::createFtpDriver($config);
10585
        }
10586
        
10587
        /**
10588
         * Create an instance of the sftp driver.
10589
         *
10590
         * @param array $config
10591
         * @return \Illuminate\Filesystem\FilesystemAdapter 
10592
         * @static 
10593
         */ 
10594
        public static function createSftpDriver($config)
10595
        {
10596
            return \Illuminate\Filesystem\FilesystemManager::createSftpDriver($config);
10597
        }
10598
        
10599
        /**
10600
         * Create an instance of the Amazon S3 driver.
10601
         *
10602
         * @param array $config
10603
         * @return \Illuminate\Contracts\Filesystem\Cloud 
10604
         * @static 
10605
         */ 
10606
        public static function createS3Driver($config)
10607
        {
10608
            return \Illuminate\Filesystem\FilesystemManager::createS3Driver($config);
10609
        }
10610
        
10611
        /**
10612
         * Create an instance of the Rackspace driver.
10613
         *
10614
         * @param array $config
10615
         * @return \Illuminate\Contracts\Filesystem\Cloud 
10616
         * @static 
10617
         */ 
10618
        public static function createRackspaceDriver($config)
10619
        {
10620
            return \Illuminate\Filesystem\FilesystemManager::createRackspaceDriver($config);
10621
        }
10622
        
10623
        /**
10624
         * Set the given disk instance.
10625
         *
10626
         * @param string $name
10627
         * @param mixed $disk
10628
         * @return void 
10629
         * @static 
10630
         */ 
10631
        public static function set($name, $disk)
10632
        {
10633
            \Illuminate\Filesystem\FilesystemManager::set($name, $disk);
10634
        }
10635
        
10636
        /**
10637
         * Get the default driver name.
10638
         *
10639
         * @return string 
10640
         * @static 
10641
         */ 
10642
        public static function getDefaultDriver()
10643
        {
10644
            return \Illuminate\Filesystem\FilesystemManager::getDefaultDriver();
10645
        }
10646
        
10647
        /**
10648
         * Get the default cloud driver name.
10649
         *
10650
         * @return string 
10651
         * @static 
10652
         */ 
10653
        public static function getDefaultCloudDriver()
10654
        {
10655
            return \Illuminate\Filesystem\FilesystemManager::getDefaultCloudDriver();
10656
        }
10657
        
10658
        /**
10659
         * Register a custom driver creator Closure.
10660
         *
10661
         * @param string $driver
10662
         * @param \Closure $callback
10663
         * @return $this 
10664
         * @static 
10665
         */ 
10666
        public static function extend($driver, $callback)
10667
        {
10668
            return \Illuminate\Filesystem\FilesystemManager::extend($driver, $callback);
10669
        }
10670
        
10671
        /**
10672
         * Assert that the given file exists.
10673
         *
10674
         * @param string $path
10675
         * @return void 
10676
         * @static 
10677
         */ 
10678
        public static function assertExists($path)
10679
        {
10680
            \Illuminate\Filesystem\FilesystemAdapter::assertExists($path);
10681
        }
10682
        
10683
        /**
10684
         * Assert that the given file does not exist.
10685
         *
10686
         * @param string $path
10687
         * @return void 
10688
         * @static 
10689
         */ 
10690
        public static function assertMissing($path)
10691
        {
10692
            \Illuminate\Filesystem\FilesystemAdapter::assertMissing($path);
10693
        }
10694
        
10695
        /**
10696
         * Determine if a file exists.
10697
         *
10698
         * @param string $path
10699
         * @return bool 
10700
         * @static 
10701
         */ 
10702
        public static function exists($path)
10703
        {
10704
            return \Illuminate\Filesystem\FilesystemAdapter::exists($path);
10705
        }
10706
        
10707
        /**
10708
         * Get the full path for the file at the given "short" path.
10709
         *
10710
         * @param string $path
10711
         * @return string 
10712
         * @static 
10713
         */ 
10714
        public static function path($path)
10715
        {
10716
            return \Illuminate\Filesystem\FilesystemAdapter::path($path);
10717
        }
10718
        
10719
        /**
10720
         * Get the contents of a file.
10721
         *
10722
         * @param string $path
10723
         * @return string 
10724
         * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
10725
         * @static 
10726
         */ 
10727
        public static function get($path)
10728
        {
10729
            return \Illuminate\Filesystem\FilesystemAdapter::get($path);
10730
        }
10731
        
10732
        /**
10733
         * Create a streamed response for a given file.
10734
         *
10735
         * @param string $path
10736
         * @param string|null $name
10737
         * @param array|null $headers
10738
         * @param string|null $disposition
10739
         * @return \Symfony\Component\HttpFoundation\StreamedResponse 
10740
         * @static 
10741
         */ 
10742
        public static function response($path, $name = null, $headers = array(), $disposition = 'inline')
10743
        {
10744
            return \Illuminate\Filesystem\FilesystemAdapter::response($path, $name, $headers, $disposition);
10745
        }
10746
        
10747
        /**
10748
         * Create a streamed download response for a given file.
10749
         *
10750
         * @param string $path
10751
         * @param string|null $name
10752
         * @param array|null $headers
10753
         * @return \Symfony\Component\HttpFoundation\StreamedResponse 
10754
         * @static 
10755
         */ 
10756
        public static function download($path, $name = null, $headers = array())
10757
        {
10758
            return \Illuminate\Filesystem\FilesystemAdapter::download($path, $name, $headers);
10759
        }
10760
        
10761
        /**
10762
         * Write the contents of a file.
10763
         *
10764
         * @param string $path
10765
         * @param string|resource $contents
10766
         * @param mixed $options
10767
         * @return bool 
10768
         * @static 
10769
         */ 
10770
        public static function put($path, $contents, $options = array())
10771
        {
10772
            return \Illuminate\Filesystem\FilesystemAdapter::put($path, $contents, $options);
10773
        }
10774
        
10775
        /**
10776
         * Store the uploaded file on the disk.
10777
         *
10778
         * @param string $path
10779
         * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile $file
10780
         * @param array $options
10781
         * @return string|false 
10782
         * @static 
10783
         */ 
10784
        public static function putFile($path, $file, $options = array())
10785
        {
10786
            return \Illuminate\Filesystem\FilesystemAdapter::putFile($path, $file, $options);
10787
        }
10788
        
10789
        /**
10790
         * Store the uploaded file on the disk with a given name.
10791
         *
10792
         * @param string $path
10793
         * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile $file
10794
         * @param string $name
10795
         * @param array $options
10796
         * @return string|false 
10797
         * @static 
10798
         */ 
10799
        public static function putFileAs($path, $file, $name, $options = array())
10800
        {
10801
            return \Illuminate\Filesystem\FilesystemAdapter::putFileAs($path, $file, $name, $options);
10802
        }
10803
        
10804
        /**
10805
         * Get the visibility for the given path.
10806
         *
10807
         * @param string $path
10808
         * @return string 
10809
         * @static 
10810
         */ 
10811
        public static function getVisibility($path)
10812
        {
10813
            return \Illuminate\Filesystem\FilesystemAdapter::getVisibility($path);
10814
        }
10815
        
10816
        /**
10817
         * Set the visibility for the given path.
10818
         *
10819
         * @param string $path
10820
         * @param string $visibility
10821
         * @return void 
10822
         * @static 
10823
         */ 
10824
        public static function setVisibility($path, $visibility)
10825
        {
10826
            \Illuminate\Filesystem\FilesystemAdapter::setVisibility($path, $visibility);
10827
        }
10828
        
10829
        /**
10830
         * Prepend to a file.
10831
         *
10832
         * @param string $path
10833
         * @param string $data
10834
         * @param string $separator
10835
         * @return int 
10836
         * @static 
10837
         */ 
10838
        public static function prepend($path, $data, $separator = '')
10839
        {
10840
            return \Illuminate\Filesystem\FilesystemAdapter::prepend($path, $data, $separator);
10841
        }
10842
        
10843
        /**
10844
         * Append to a file.
10845
         *
10846
         * @param string $path
10847
         * @param string $data
10848
         * @param string $separator
10849
         * @return int 
10850
         * @static 
10851
         */ 
10852
        public static function append($path, $data, $separator = '')
10853
        {
10854
            return \Illuminate\Filesystem\FilesystemAdapter::append($path, $data, $separator);
10855
        }
10856
        
10857
        /**
10858
         * Delete the file at a given path.
10859
         *
10860
         * @param string|array $paths
10861
         * @return bool 
10862
         * @static 
10863
         */ 
10864
        public static function delete($paths)
10865
        {
10866
            return \Illuminate\Filesystem\FilesystemAdapter::delete($paths);
10867
        }
10868
        
10869
        /**
10870
         * Copy a file to a new location.
10871
         *
10872
         * @param string $from
10873
         * @param string $to
10874
         * @return bool 
10875
         * @static 
10876
         */ 
10877
        public static function copy($from, $to)
10878
        {
10879
            return \Illuminate\Filesystem\FilesystemAdapter::copy($from, $to);
10880
        }
10881
        
10882
        /**
10883
         * Move a file to a new location.
10884
         *
10885
         * @param string $from
10886
         * @param string $to
10887
         * @return bool 
10888
         * @static 
10889
         */ 
10890
        public static function move($from, $to)
10891
        {
10892
            return \Illuminate\Filesystem\FilesystemAdapter::move($from, $to);
10893
        }
10894
        
10895
        /**
10896
         * Get the file size of a given file.
10897
         *
10898
         * @param string $path
10899
         * @return int 
10900
         * @static 
10901
         */ 
10902
        public static function size($path)
10903
        {
10904
            return \Illuminate\Filesystem\FilesystemAdapter::size($path);
10905
        }
10906
        
10907
        /**
10908
         * Get the mime-type of a given file.
10909
         *
10910
         * @param string $path
10911
         * @return string|false 
10912
         * @static 
10913
         */ 
10914
        public static function mimeType($path)
10915
        {
10916
            return \Illuminate\Filesystem\FilesystemAdapter::mimeType($path);
10917
        }
10918
        
10919
        /**
10920
         * Get the file's last modification time.
10921
         *
10922
         * @param string $path
10923
         * @return int 
10924
         * @static 
10925
         */ 
10926
        public static function lastModified($path)
10927
        {
10928
            return \Illuminate\Filesystem\FilesystemAdapter::lastModified($path);
10929
        }
10930
        
10931
        /**
10932
         * Get the URL for the file at the given path.
10933
         *
10934
         * @param string $path
10935
         * @return string 
10936
         * @static 
10937
         */ 
10938
        public static function url($path)
10939
        {
10940
            return \Illuminate\Filesystem\FilesystemAdapter::url($path);
10941
        }
10942
        
10943
        /**
10944
         * Get a temporary URL for the file at the given path.
10945
         *
10946
         * @param string $path
10947
         * @param \DateTimeInterface $expiration
10948
         * @param array $options
10949
         * @return string 
10950
         * @static 
10951
         */ 
10952
        public static function temporaryUrl($path, $expiration, $options = array())
10953
        {
10954
            return \Illuminate\Filesystem\FilesystemAdapter::temporaryUrl($path, $expiration, $options);
10955
        }
10956
        
10957
        /**
10958
         * Get a temporary URL for the file at the given path.
10959
         *
10960
         * @param \League\Flysystem\AwsS3v3\AwsS3Adapter $adapter
10961
         * @param string $path
10962
         * @param \DateTimeInterface $expiration
10963
         * @param array $options
10964
         * @return string 
10965
         * @static 
10966
         */ 
10967
        public static function getAwsTemporaryUrl($adapter, $path, $expiration, $options)
10968
        {
10969
            return \Illuminate\Filesystem\FilesystemAdapter::getAwsTemporaryUrl($adapter, $path, $expiration, $options);
10970
        }
10971
        
10972
        /**
10973
         * Get a temporary URL for the file at the given path.
10974
         *
10975
         * @param \League\Flysystem\Rackspace\RackspaceAdapter $adapter
10976
         * @param string $path
10977
         * @param \DateTimeInterface $expiration
10978
         * @param array $options
10979
         * @return string 
10980
         * @static 
10981
         */ 
10982
        public static function getRackspaceTemporaryUrl($adapter, $path, $expiration, $options)
10983
        {
10984
            return \Illuminate\Filesystem\FilesystemAdapter::getRackspaceTemporaryUrl($adapter, $path, $expiration, $options);
10985
        }
10986
        
10987
        /**
10988
         * Get an array of all files in a directory.
10989
         *
10990
         * @param string|null $directory
10991
         * @param bool $recursive
10992
         * @return array 
10993
         * @static 
10994
         */ 
10995
        public static function files($directory = null, $recursive = false)
10996
        {
10997
            return \Illuminate\Filesystem\FilesystemAdapter::files($directory, $recursive);
10998
        }
10999
        
11000
        /**
11001
         * Get all of the files from the given directory (recursive).
11002
         *
11003
         * @param string|null $directory
11004
         * @return array 
11005
         * @static 
11006
         */ 
11007
        public static function allFiles($directory = null)
11008
        {
11009
            return \Illuminate\Filesystem\FilesystemAdapter::allFiles($directory);
11010
        }
11011
        
11012
        /**
11013
         * Get all of the directories within a given directory.
11014
         *
11015
         * @param string|null $directory
11016
         * @param bool $recursive
11017
         * @return array 
11018
         * @static 
11019
         */ 
11020
        public static function directories($directory = null, $recursive = false)
11021
        {
11022
            return \Illuminate\Filesystem\FilesystemAdapter::directories($directory, $recursive);
11023
        }
11024
        
11025
        /**
11026
         * Get all (recursive) of the directories within a given directory.
11027
         *
11028
         * @param string|null $directory
11029
         * @return array 
11030
         * @static 
11031
         */ 
11032
        public static function allDirectories($directory = null)
11033
        {
11034
            return \Illuminate\Filesystem\FilesystemAdapter::allDirectories($directory);
11035
        }
11036
        
11037
        /**
11038
         * Create a directory.
11039
         *
11040
         * @param string $path
11041
         * @return bool 
11042
         * @static 
11043
         */ 
11044
        public static function makeDirectory($path)
11045
        {
11046
            return \Illuminate\Filesystem\FilesystemAdapter::makeDirectory($path);
11047
        }
11048
        
11049
        /**
11050
         * Recursively delete a directory.
11051
         *
11052
         * @param string $directory
11053
         * @return bool 
11054
         * @static 
11055
         */ 
11056
        public static function deleteDirectory($directory)
11057
        {
11058
            return \Illuminate\Filesystem\FilesystemAdapter::deleteDirectory($directory);
11059
        }
11060
        
11061
        /**
11062
         * Flush the Flysystem cache.
11063
         *
11064
         * @return void 
11065
         * @static 
11066
         */ 
11067
        public static function flushCache()
11068
        {
11069
            \Illuminate\Filesystem\FilesystemAdapter::flushCache();
11070
        }
11071
        
11072
        /**
11073
         * Get the Flysystem driver.
11074
         *
11075
         * @return \League\Flysystem\FilesystemInterface 
11076
         * @static 
11077
         */ 
11078
        public static function getDriver()
11079
        {
11080
            return \Illuminate\Filesystem\FilesystemAdapter::getDriver();
11081
        }
11082
         
11083
    }
11084

11085
    class URL {
11086
        
11087
        /**
11088
         * Get the full URL for the current request.
11089
         *
11090
         * @return string 
11091
         * @static 
11092
         */ 
11093
        public static function full()
11094
        {
11095
            return \Illuminate\Routing\UrlGenerator::full();
11096
        }
11097
        
11098
        /**
11099
         * Get the current URL for the request.
11100
         *
11101
         * @return string 
11102
         * @static 
11103
         */ 
11104
        public static function current()
11105
        {
11106
            return \Illuminate\Routing\UrlGenerator::current();
11107
        }
11108
        
11109
        /**
11110
         * Get the URL for the previous request.
11111
         *
11112
         * @param mixed $fallback
11113
         * @return string 
11114
         * @static 
11115
         */ 
11116
        public static function previous($fallback = false)
11117
        {
11118
            return \Illuminate\Routing\UrlGenerator::previous($fallback);
11119
        }
11120
        
11121
        /**
11122
         * Generate an absolute URL to the given path.
11123
         *
11124
         * @param string $path
11125
         * @param mixed $extra
11126
         * @param bool|null $secure
11127
         * @return string 
11128
         * @static 
11129
         */ 
11130
        public static function to($path, $extra = array(), $secure = null)
11131
        {
11132
            return \Illuminate\Routing\UrlGenerator::to($path, $extra, $secure);
11133
        }
11134
        
11135
        /**
11136
         * Generate a secure, absolute URL to the given path.
11137
         *
11138
         * @param string $path
11139
         * @param array $parameters
11140
         * @return string 
11141
         * @static 
11142
         */ 
11143
        public static function secure($path, $parameters = array())
11144
        {
11145
            return \Illuminate\Routing\UrlGenerator::secure($path, $parameters);
11146
        }
11147
        
11148
        /**
11149
         * Generate the URL to an application asset.
11150
         *
11151
         * @param string $path
11152
         * @param bool|null $secure
11153
         * @return string 
11154
         * @static 
11155
         */ 
11156
        public static function asset($path, $secure = null)
11157
        {
11158
            return \Illuminate\Routing\UrlGenerator::asset($path, $secure);
11159
        }
11160
        
11161
        /**
11162
         * Generate the URL to a secure asset.
11163
         *
11164
         * @param string $path
11165
         * @return string 
11166
         * @static 
11167
         */ 
11168
        public static function secureAsset($path)
11169
        {
11170
            return \Illuminate\Routing\UrlGenerator::secureAsset($path);
11171
        }
11172
        
11173
        /**
11174
         * Generate the URL to an asset from a custom root domain such as CDN, etc.
11175
         *
11176
         * @param string $root
11177
         * @param string $path
11178
         * @param bool|null $secure
11179
         * @return string 
11180
         * @static 
11181
         */ 
11182
        public static function assetFrom($root, $path, $secure = null)
11183
        {
11184
            return \Illuminate\Routing\UrlGenerator::assetFrom($root, $path, $secure);
11185
        }
11186
        
11187
        /**
11188
         * Get the default scheme for a raw URL.
11189
         *
11190
         * @param bool|null $secure
11191
         * @return string 
11192
         * @static 
11193
         */ 
11194
        public static function formatScheme($secure)
11195
        {
11196
            return \Illuminate\Routing\UrlGenerator::formatScheme($secure);
11197
        }
11198
        
11199
        /**
11200
         * Create a signed route URL for a named route.
11201
         *
11202
         * @param string $name
11203
         * @param array $parameters
11204
         * @param \DateTimeInterface|int $expiration
11205
         * @return string 
11206
         * @static 
11207
         */ 
11208
        public static function signedRoute($name, $parameters = array(), $expiration = null)
11209
        {
11210
            return \Illuminate\Routing\UrlGenerator::signedRoute($name, $parameters, $expiration);
11211
        }
11212
        
11213
        /**
11214
         * Create a temporary signed route URL for a named route.
11215
         *
11216
         * @param string $name
11217
         * @param \DateTimeInterface|int $expiration
11218
         * @param array $parameters
11219
         * @return string 
11220
         * @static 
11221
         */ 
11222
        public static function temporarySignedRoute($name, $expiration, $parameters = array())
11223
        {
11224
            return \Illuminate\Routing\UrlGenerator::temporarySignedRoute($name, $expiration, $parameters);
11225
        }
11226
        
11227
        /**
11228
         * Determine if the given request has a valid signature.
11229
         *
11230
         * @param \Illuminate\Http\Request $request
11231
         * @return bool 
11232
         * @static 
11233
         */ 
11234
        public static function hasValidSignature($request)
11235
        {
11236
            return \Illuminate\Routing\UrlGenerator::hasValidSignature($request);
11237
        }
11238
        
11239
        /**
11240
         * Get the URL to a named route.
11241
         *
11242
         * @param string $name
11243
         * @param mixed $parameters
11244
         * @param bool $absolute
11245
         * @return string 
11246
         * @throws \InvalidArgumentException
11247
         * @static 
11248
         */ 
11249
        public static function route($name, $parameters = array(), $absolute = true)
11250
        {
11251
            return \Illuminate\Routing\UrlGenerator::route($name, $parameters, $absolute);
11252
        }
11253
        
11254
        /**
11255
         * Get the URL to a controller action.
11256
         *
11257
         * @param string $action
11258
         * @param mixed $parameters
11259
         * @param bool $absolute
11260
         * @return string 
11261
         * @throws \InvalidArgumentException
11262
         * @static 
11263
         */ 
11264
        public static function action($action, $parameters = array(), $absolute = true)
11265
        {
11266
            return \Illuminate\Routing\UrlGenerator::action($action, $parameters, $absolute);
11267
        }
11268
        
11269
        /**
11270
         * Format the array of URL parameters.
11271
         *
11272
         * @param mixed|array $parameters
11273
         * @return array 
11274
         * @static 
11275
         */ 
11276
        public static function formatParameters($parameters)
11277
        {
11278
            return \Illuminate\Routing\UrlGenerator::formatParameters($parameters);
11279
        }
11280
        
11281
        /**
11282
         * Get the base URL for the request.
11283
         *
11284
         * @param string $scheme
11285
         * @param string $root
11286
         * @return string 
11287
         * @static 
11288
         */ 
11289
        public static function formatRoot($scheme, $root = null)
11290
        {
11291
            return \Illuminate\Routing\UrlGenerator::formatRoot($scheme, $root);
11292
        }
11293
        
11294
        /**
11295
         * Format the given URL segments into a single URL.
11296
         *
11297
         * @param string $root
11298
         * @param string $path
11299
         * @return string 
11300
         * @static 
11301
         */ 
11302
        public static function format($root, $path)
11303
        {
11304
            return \Illuminate\Routing\UrlGenerator::format($root, $path);
11305
        }
11306
        
11307
        /**
11308
         * Determine if the given path is a valid URL.
11309
         *
11310
         * @param string $path
11311
         * @return bool 
11312
         * @static 
11313
         */ 
11314
        public static function isValidUrl($path)
11315
        {
11316
            return \Illuminate\Routing\UrlGenerator::isValidUrl($path);
11317
        }
11318
        
11319
        /**
11320
         * Set the default named parameters used by the URL generator.
11321
         *
11322
         * @param array $defaults
11323
         * @return void 
11324
         * @static 
11325
         */ 
11326
        public static function defaults($defaults)
11327
        {
11328
            \Illuminate\Routing\UrlGenerator::defaults($defaults);
11329
        }
11330
        
11331
        /**
11332
         * Get the default named parameters used by the URL generator.
11333
         *
11334
         * @return array 
11335
         * @static 
11336
         */ 
11337
        public static function getDefaultParameters()
11338
        {
11339
            return \Illuminate\Routing\UrlGenerator::getDefaultParameters();
11340
        }
11341
        
11342
        /**
11343
         * Force the scheme for URLs.
11344
         *
11345
         * @param string $schema
11346
         * @return void 
11347
         * @static 
11348
         */ 
11349
        public static function forceScheme($schema)
11350
        {
11351
            \Illuminate\Routing\UrlGenerator::forceScheme($schema);
11352
        }
11353
        
11354
        /**
11355
         * Set the forced root URL.
11356
         *
11357
         * @param string $root
11358
         * @return void 
11359
         * @static 
11360
         */ 
11361
        public static function forceRootUrl($root)
11362
        {
11363
            \Illuminate\Routing\UrlGenerator::forceRootUrl($root);
11364
        }
11365
        
11366
        /**
11367
         * Set a callback to be used to format the host of generated URLs.
11368
         *
11369
         * @param \Closure $callback
11370
         * @return $this 
11371
         * @static 
11372
         */ 
11373
        public static function formatHostUsing($callback)
11374
        {
11375
            return \Illuminate\Routing\UrlGenerator::formatHostUsing($callback);
11376
        }
11377
        
11378
        /**
11379
         * Set a callback to be used to format the path of generated URLs.
11380
         *
11381
         * @param \Closure $callback
11382
         * @return $this 
11383
         * @static 
11384
         */ 
11385
        public static function formatPathUsing($callback)
11386
        {
11387
            return \Illuminate\Routing\UrlGenerator::formatPathUsing($callback);
11388
        }
11389
        
11390
        /**
11391
         * Get the path formatter being used by the URL generator.
11392
         *
11393
         * @return \Closure 
11394
         * @static 
11395
         */ 
11396
        public static function pathFormatter()
11397
        {
11398
            return \Illuminate\Routing\UrlGenerator::pathFormatter();
11399
        }
11400
        
11401
        /**
11402
         * Get the request instance.
11403
         *
11404
         * @return \Illuminate\Http\Request 
11405
         * @static 
11406
         */ 
11407
        public static function getRequest()
11408
        {
11409
            return \Illuminate\Routing\UrlGenerator::getRequest();
11410
        }
11411
        
11412
        /**
11413
         * Set the current request instance.
11414
         *
11415
         * @param \Illuminate\Http\Request $request
11416
         * @return void 
11417
         * @static 
11418
         */ 
11419
        public static function setRequest($request)
11420
        {
11421
            \Illuminate\Routing\UrlGenerator::setRequest($request);
11422
        }
11423
        
11424
        /**
11425
         * Set the route collection.
11426
         *
11427
         * @param \Illuminate\Routing\RouteCollection $routes
11428
         * @return $this 
11429
         * @static 
11430
         */ 
11431
        public static function setRoutes($routes)
11432
        {
11433
            return \Illuminate\Routing\UrlGenerator::setRoutes($routes);
11434
        }
11435
        
11436
        /**
11437
         * Set the session resolver for the generator.
11438
         *
11439
         * @param callable $sessionResolver
11440
         * @return $this 
11441
         * @static 
11442
         */ 
11443
        public static function setSessionResolver($sessionResolver)
11444
        {
11445
            return \Illuminate\Routing\UrlGenerator::setSessionResolver($sessionResolver);
11446
        }
11447
        
11448
        /**
11449
         * Set the encryption key resolver.
11450
         *
11451
         * @param callable $keyResolver
11452
         * @return $this 
11453
         * @static 
11454
         */ 
11455
        public static function setKeyResolver($keyResolver)
11456
        {
11457
            return \Illuminate\Routing\UrlGenerator::setKeyResolver($keyResolver);
11458
        }
11459
        
11460
        /**
11461
         * Set the root controller namespace.
11462
         *
11463
         * @param string $rootNamespace
11464
         * @return $this 
11465
         * @static 
11466
         */ 
11467
        public static function setRootControllerNamespace($rootNamespace)
11468
        {
11469
            return \Illuminate\Routing\UrlGenerator::setRootControllerNamespace($rootNamespace);
11470
        }
11471
        
11472
        /**
11473
         * Register a custom macro.
11474
         *
11475
         * @param string $name
11476
         * @param object|callable $macro
11477
         * @return void 
11478
         * @static 
11479
         */ 
11480
        public static function macro($name, $macro)
11481
        {
11482
            \Illuminate\Routing\UrlGenerator::macro($name, $macro);
11483
        }
11484
        
11485
        /**
11486
         * Mix another object into the class.
11487
         *
11488
         * @param object $mixin
11489
         * @return void 
11490
         * @static 
11491
         */ 
11492
        public static function mixin($mixin)
11493
        {
11494
            \Illuminate\Routing\UrlGenerator::mixin($mixin);
11495
        }
11496
        
11497
        /**
11498
         * Checks if macro is registered.
11499
         *
11500
         * @param string $name
11501
         * @return bool 
11502
         * @static 
11503
         */ 
11504
        public static function hasMacro($name)
11505
        {
11506
            return \Illuminate\Routing\UrlGenerator::hasMacro($name);
11507
        }
11508
         
11509
    }
11510

11511
    class Validator {
11512
        
11513
        /**
11514
         * Create a new Validator instance.
11515
         *
11516
         * @param array $data
11517
         * @param array $rules
11518
         * @param array $messages
11519
         * @param array $customAttributes
11520
         * @return \Illuminate\Validation\Validator 
11521
         * @static 
11522
         */ 
11523
        public static function make($data, $rules, $messages = array(), $customAttributes = array())
11524
        {
11525
            return \Illuminate\Validation\Factory::make($data, $rules, $messages, $customAttributes);
11526
        }
11527
        
11528
        /**
11529
         * Validate the given data against the provided rules.
11530
         *
11531
         * @param array $data
11532
         * @param array $rules
11533
         * @param array $messages
11534
         * @param array $customAttributes
11535
         * @return void 
11536
         * @throws \Illuminate\Validation\ValidationException
11537
         * @static 
11538
         */ 
11539
        public static function validate($data, $rules, $messages = array(), $customAttributes = array())
11540
        {
11541
            \Illuminate\Validation\Factory::validate($data, $rules, $messages, $customAttributes);
11542
        }
11543
        
11544
        /**
11545
         * Register a custom validator extension.
11546
         *
11547
         * @param string $rule
11548
         * @param \Closure|string $extension
11549
         * @param string $message
11550
         * @return void 
11551
         * @static 
11552
         */ 
11553
        public static function extend($rule, $extension, $message = null)
11554
        {
11555
            \Illuminate\Validation\Factory::extend($rule, $extension, $message);
11556
        }
11557
        
11558
        /**
11559
         * Register a custom implicit validator extension.
11560
         *
11561
         * @param string $rule
11562
         * @param \Closure|string $extension
11563
         * @param string $message
11564
         * @return void 
11565
         * @static 
11566
         */ 
11567
        public static function extendImplicit($rule, $extension, $message = null)
11568
        {
11569
            \Illuminate\Validation\Factory::extendImplicit($rule, $extension, $message);
11570
        }
11571
        
11572
        /**
11573
         * Register a custom dependent validator extension.
11574
         *
11575
         * @param string $rule
11576
         * @param \Closure|string $extension
11577
         * @param string $message
11578
         * @return void 
11579
         * @static 
11580
         */ 
11581
        public static function extendDependent($rule, $extension, $message = null)
11582
        {
11583
            \Illuminate\Validation\Factory::extendDependent($rule, $extension, $message);
11584
        }
11585
        
11586
        /**
11587
         * Register a custom validator message replacer.
11588
         *
11589
         * @param string $rule
11590
         * @param \Closure|string $replacer
11591
         * @return void 
11592
         * @static 
11593
         */ 
11594
        public static function replacer($rule, $replacer)
11595
        {
11596
            \Illuminate\Validation\Factory::replacer($rule, $replacer);
11597
        }
11598
        
11599
        /**
11600
         * Set the Validator instance resolver.
11601
         *
11602
         * @param \Closure $resolver
11603
         * @return void 
11604
         * @static 
11605
         */ 
11606
        public static function resolver($resolver)
11607
        {
11608
            \Illuminate\Validation\Factory::resolver($resolver);
11609
        }
11610
        
11611
        /**
11612
         * Get the Translator implementation.
11613
         *
11614
         * @return \Illuminate\Contracts\Translation\Translator 
11615
         * @static 
11616
         */ 
11617
        public static function getTranslator()
11618
        {
11619
            return \Illuminate\Validation\Factory::getTranslator();
11620
        }
11621
        
11622
        /**
11623
         * Get the Presence Verifier implementation.
11624
         *
11625
         * @return \Illuminate\Validation\PresenceVerifierInterface 
11626
         * @static 
11627
         */ 
11628
        public static function getPresenceVerifier()
11629
        {
11630
            return \Illuminate\Validation\Factory::getPresenceVerifier();
11631
        }
11632
        
11633
        /**
11634
         * Set the Presence Verifier implementation.
11635
         *
11636
         * @param \Illuminate\Validation\PresenceVerifierInterface $presenceVerifier
11637
         * @return void 
11638
         * @static 
11639
         */ 
11640
        public static function setPresenceVerifier($presenceVerifier)
11641
        {
11642
            \Illuminate\Validation\Factory::setPresenceVerifier($presenceVerifier);
11643
        }
11644
         
11645
    }
11646

11647
    class View {
11648
        
11649
        /**
11650
         * Get the evaluated view contents for the given view.
11651
         *
11652
         * @param string $path
11653
         * @param array $data
11654
         * @param array $mergeData
11655
         * @return \Illuminate\Contracts\View\View 
11656
         * @static 
11657
         */ 
11658
        public static function file($path, $data = array(), $mergeData = array())
11659
        {
11660
            return \Illuminate\View\Factory::file($path, $data, $mergeData);
11661
        }
11662
        
11663
        /**
11664
         * Get the evaluated view contents for the given view.
11665
         *
11666
         * @param string $view
11667
         * @param array $data
11668
         * @param array $mergeData
11669
         * @return \Illuminate\Contracts\View\View 
11670
         * @static 
11671
         */ 
11672
        public static function make($view, $data = array(), $mergeData = array())
11673
        {
11674
            return \Illuminate\View\Factory::make($view, $data, $mergeData);
11675
        }
11676
        
11677
        /**
11678
         * Get the first view that actually exists from the given list.
11679
         *
11680
         * @param array $views
11681
         * @param array $data
11682
         * @param array $mergeData
11683
         * @return \Illuminate\Contracts\View\View 
11684
         * @static 
11685
         */ 
11686
        public static function first($views, $data = array(), $mergeData = array())
11687
        {
11688
            return \Illuminate\View\Factory::first($views, $data, $mergeData);
11689
        }
11690
        
11691
        /**
11692
         * Get the rendered content of the view based on a given condition.
11693
         *
11694
         * @param bool $condition
11695
         * @param string $view
11696
         * @param array $data
11697
         * @param array $mergeData
11698
         * @return string 
11699
         * @static 
11700
         */ 
11701
        public static function renderWhen($condition, $view, $data = array(), $mergeData = array())
11702
        {
11703
            return \Illuminate\View\Factory::renderWhen($condition, $view, $data, $mergeData);
11704
        }
11705
        
11706
        /**
11707
         * Get the rendered contents of a partial from a loop.
11708
         *
11709
         * @param string $view
11710
         * @param array $data
11711
         * @param string $iterator
11712
         * @param string $empty
11713
         * @return string 
11714
         * @static 
11715
         */ 
11716
        public static function renderEach($view, $data, $iterator, $empty = 'raw|')
11717
        {
11718
            return \Illuminate\View\Factory::renderEach($view, $data, $iterator, $empty);
11719
        }
11720
        
11721
        /**
11722
         * Determine if a given view exists.
11723
         *
11724
         * @param string $view
11725
         * @return bool 
11726
         * @static 
11727
         */ 
11728
        public static function exists($view)
11729
        {
11730
            return \Illuminate\View\Factory::exists($view);
11731
        }
11732
        
11733
        /**
11734
         * Get the appropriate view engine for the given path.
11735
         *
11736
         * @param string $path
11737
         * @return \Illuminate\Contracts\View\Engine 
11738
         * @throws \InvalidArgumentException
11739
         * @static 
11740
         */ 
11741
        public static function getEngineFromPath($path)
11742
        {
11743
            return \Illuminate\View\Factory::getEngineFromPath($path);
11744
        }
11745
        
11746
        /**
11747
         * Add a piece of shared data to the environment.
11748
         *
11749
         * @param array|string $key
11750
         * @param mixed $value
11751
         * @return mixed 
11752
         * @static 
11753
         */ 
11754
        public static function share($key, $value = null)
11755
        {
11756
            return \Illuminate\View\Factory::share($key, $value);
11757
        }
11758
        
11759
        /**
11760
         * Increment the rendering counter.
11761
         *
11762
         * @return void 
11763
         * @static 
11764
         */ 
11765
        public static function incrementRender()
11766
        {
11767
            \Illuminate\View\Factory::incrementRender();
11768
        }
11769
        
11770
        /**
11771
         * Decrement the rendering counter.
11772
         *
11773
         * @return void 
11774
         * @static 
11775
         */ 
11776
        public static function decrementRender()
11777
        {
11778
            \Illuminate\View\Factory::decrementRender();
11779
        }
11780
        
11781
        /**
11782
         * Check if there are no active render operations.
11783
         *
11784
         * @return bool 
11785
         * @static 
11786
         */ 
11787
        public static function doneRendering()
11788
        {
11789
            return \Illuminate\View\Factory::doneRendering();
11790
        }
11791
        
11792
        /**
11793
         * Add a location to the array of view locations.
11794
         *
11795
         * @param string $location
11796
         * @return void 
11797
         * @static 
11798
         */ 
11799
        public static function addLocation($location)
11800
        {
11801
            \Illuminate\View\Factory::addLocation($location);
11802
        }
11803
        
11804
        /**
11805
         * Add a new namespace to the loader.
11806
         *
11807
         * @param string $namespace
11808
         * @param string|array $hints
11809
         * @return $this 
11810
         * @static 
11811
         */ 
11812
        public static function addNamespace($namespace, $hints)
11813
        {
11814
            return \Illuminate\View\Factory::addNamespace($namespace, $hints);
11815
        }
11816
        
11817
        /**
11818
         * Prepend a new namespace to the loader.
11819
         *
11820
         * @param string $namespace
11821
         * @param string|array $hints
11822
         * @return $this 
11823
         * @static 
11824
         */ 
11825
        public static function prependNamespace($namespace, $hints)
11826
        {
11827
            return \Illuminate\View\Factory::prependNamespace($namespace, $hints);
11828
        }
11829
        
11830
        /**
11831
         * Replace the namespace hints for the given namespace.
11832
         *
11833
         * @param string $namespace
11834
         * @param string|array $hints
11835
         * @return $this 
11836
         * @static 
11837
         */ 
11838
        public static function replaceNamespace($namespace, $hints)
11839
        {
11840
            return \Illuminate\View\Factory::replaceNamespace($namespace, $hints);
11841
        }
11842
        
11843
        /**
11844
         * Register a valid view extension and its engine.
11845
         *
11846
         * @param string $extension
11847
         * @param string $engine
11848
         * @param \Closure $resolver
11849
         * @return void 
11850
         * @static 
11851
         */ 
11852
        public static function addExtension($extension, $engine, $resolver = null)
11853
        {
11854
            \Illuminate\View\Factory::addExtension($extension, $engine, $resolver);
11855
        }
11856
        
11857
        /**
11858
         * Flush all of the factory state like sections and stacks.
11859
         *
11860
         * @return void 
11861
         * @static 
11862
         */ 
11863
        public static function flushState()
11864
        {
11865
            \Illuminate\View\Factory::flushState();
11866
        }
11867
        
11868
        /**
11869
         * Flush all of the section contents if done rendering.
11870
         *
11871
         * @return void 
11872
         * @static 
11873
         */ 
11874
        public static function flushStateIfDoneRendering()
11875
        {
11876
            \Illuminate\View\Factory::flushStateIfDoneRendering();
11877
        }
11878
        
11879
        /**
11880
         * Get the extension to engine bindings.
11881
         *
11882
         * @return array 
11883
         * @static 
11884
         */ 
11885
        public static function getExtensions()
11886
        {
11887
            return \Illuminate\View\Factory::getExtensions();
11888
        }
11889
        
11890
        /**
11891
         * Get the engine resolver instance.
11892
         *
11893
         * @return \Illuminate\View\Engines\EngineResolver 
11894
         * @static 
11895
         */ 
11896
        public static function getEngineResolver()
11897
        {
11898
            return \Illuminate\View\Factory::getEngineResolver();
11899
        }
11900
        
11901
        /**
11902
         * Get the view finder instance.
11903
         *
11904
         * @return \Illuminate\View\ViewFinderInterface 
11905
         * @static 
11906
         */ 
11907
        public static function getFinder()
11908
        {
11909
            return \Illuminate\View\Factory::getFinder();
11910
        }
11911
        
11912
        /**
11913
         * Set the view finder instance.
11914
         *
11915
         * @param \Illuminate\View\ViewFinderInterface $finder
11916
         * @return void 
11917
         * @static 
11918
         */ 
11919
        public static function setFinder($finder)
11920
        {
11921
            \Illuminate\View\Factory::setFinder($finder);
11922
        }
11923
        
11924
        /**
11925
         * Flush the cache of views located by the finder.
11926
         *
11927
         * @return void 
11928
         * @static 
11929
         */ 
11930
        public static function flushFinderCache()
11931
        {
11932
            \Illuminate\View\Factory::flushFinderCache();
11933
        }
11934
        
11935
        /**
11936
         * Get the event dispatcher instance.
11937
         *
11938
         * @return \Illuminate\Contracts\Events\Dispatcher 
11939
         * @static 
11940
         */ 
11941
        public static function getDispatcher()
11942
        {
11943
            return \Illuminate\View\Factory::getDispatcher();
11944
        }
11945
        
11946
        /**
11947
         * Set the event dispatcher instance.
11948
         *
11949
         * @param \Illuminate\Contracts\Events\Dispatcher $events
11950
         * @return void 
11951
         * @static 
11952
         */ 
11953
        public static function setDispatcher($events)
11954
        {
11955
            \Illuminate\View\Factory::setDispatcher($events);
11956
        }
11957
        
11958
        /**
11959
         * Get the IoC container instance.
11960
         *
11961
         * @return \Illuminate\Contracts\Container\Container 
11962
         * @static 
11963
         */ 
11964
        public static function getContainer()
11965
        {
11966
            return \Illuminate\View\Factory::getContainer();
11967
        }
11968
        
11969
        /**
11970
         * Set the IoC container instance.
11971
         *
11972
         * @param \Illuminate\Contracts\Container\Container $container
11973
         * @return void 
11974
         * @static 
11975
         */ 
11976
        public static function setContainer($container)
11977
        {
11978
            \Illuminate\View\Factory::setContainer($container);
11979
        }
11980
        
11981
        /**
11982
         * Get an item from the shared data.
11983
         *
11984
         * @param string $key
11985
         * @param mixed $default
11986
         * @return mixed 
11987
         * @static 
11988
         */ 
11989
        public static function shared($key, $default = null)
11990
        {
11991
            return \Illuminate\View\Factory::shared($key, $default);
11992
        }
11993
        
11994
        /**
11995
         * Get all of the shared data for the environment.
11996
         *
11997
         * @return array 
11998
         * @static 
11999
         */ 
12000
        public static function getShared()
12001
        {
12002
            return \Illuminate\View\Factory::getShared();
12003
        }
12004
        
12005
        /**
12006
         * Start a component rendering process.
12007
         *
12008
         * @param string $name
12009
         * @param array $data
12010
         * @return void 
12011
         * @static 
12012
         */ 
12013
        public static function startComponent($name, $data = array())
12014
        {
12015
            \Illuminate\View\Factory::startComponent($name, $data);
12016
        }
12017
        
12018
        /**
12019
         * Render the current component.
12020
         *
12021
         * @return string 
12022
         * @static 
12023
         */ 
12024
        public static function renderComponent()
12025
        {
12026
            return \Illuminate\View\Factory::renderComponent();
12027
        }
12028
        
12029
        /**
12030
         * Start the slot rendering process.
12031
         *
12032
         * @param string $name
12033
         * @param string|null $content
12034
         * @return void 
12035
         * @static 
12036
         */ 
12037
        public static function slot($name, $content = null)
12038
        {
12039
            \Illuminate\View\Factory::slot($name, $content);
12040
        }
12041
        
12042
        /**
12043
         * Save the slot content for rendering.
12044
         *
12045
         * @return void 
12046
         * @static 
12047
         */ 
12048
        public static function endSlot()
12049
        {
12050
            \Illuminate\View\Factory::endSlot();
12051
        }
12052
        
12053
        /**
12054
         * Register a view creator event.
12055
         *
12056
         * @param array|string $views
12057
         * @param \Closure|string $callback
12058
         * @return array 
12059
         * @static 
12060
         */ 
12061
        public static function creator($views, $callback)
12062
        {
12063
            return \Illuminate\View\Factory::creator($views, $callback);
12064
        }
12065
        
12066
        /**
12067
         * Register multiple view composers via an array.
12068
         *
12069
         * @param array $composers
12070
         * @return array 
12071
         * @static 
12072
         */ 
12073
        public static function composers($composers)
12074
        {
12075
            return \Illuminate\View\Factory::composers($composers);
12076
        }
12077
        
12078
        /**
12079
         * Register a view composer event.
12080
         *
12081
         * @param array|string $views
12082
         * @param \Closure|string $callback
12083
         * @return array 
12084
         * @static 
12085
         */ 
12086
        public static function composer($views, $callback)
12087
        {
12088
            return \Illuminate\View\Factory::composer($views, $callback);
12089
        }
12090
        
12091
        /**
12092
         * Call the composer for a given view.
12093
         *
12094
         * @param \Illuminate\Contracts\View\View $view
12095
         * @return void 
12096
         * @static 
12097
         */ 
12098
        public static function callComposer($view)
12099
        {
12100
            \Illuminate\View\Factory::callComposer($view);
12101
        }
12102
        
12103
        /**
12104
         * Call the creator for a given view.
12105
         *
12106
         * @param \Illuminate\Contracts\View\View $view
12107
         * @return void 
12108
         * @static 
12109
         */ 
12110
        public static function callCreator($view)
12111
        {
12112
            \Illuminate\View\Factory::callCreator($view);
12113
        }
12114
        
12115
        /**
12116
         * Start injecting content into a section.
12117
         *
12118
         * @param string $section
12119
         * @param string|null $content
12120
         * @return void 
12121
         * @static 
12122
         */ 
12123
        public static function startSection($section, $content = null)
12124
        {
12125
            \Illuminate\View\Factory::startSection($section, $content);
12126
        }
12127
        
12128
        /**
12129
         * Inject inline content into a section.
12130
         *
12131
         * @param string $section
12132
         * @param string $content
12133
         * @return void 
12134
         * @static 
12135
         */ 
12136
        public static function inject($section, $content)
12137
        {
12138
            \Illuminate\View\Factory::inject($section, $content);
12139
        }
12140
        
12141
        /**
12142
         * Stop injecting content into a section and return its contents.
12143
         *
12144
         * @return string 
12145
         * @static 
12146
         */ 
12147
        public static function yieldSection()
12148
        {
12149
            return \Illuminate\View\Factory::yieldSection();
12150
        }
12151
        
12152
        /**
12153
         * Stop injecting content into a section.
12154
         *
12155
         * @param bool $overwrite
12156
         * @return string 
12157
         * @throws \InvalidArgumentException
12158
         * @static 
12159
         */ 
12160
        public static function stopSection($overwrite = false)
12161
        {
12162
            return \Illuminate\View\Factory::stopSection($overwrite);
12163
        }
12164
        
12165
        /**
12166
         * Stop injecting content into a section and append it.
12167
         *
12168
         * @return string 
12169
         * @throws \InvalidArgumentException
12170
         * @static 
12171
         */ 
12172
        public static function appendSection()
12173
        {
12174
            return \Illuminate\View\Factory::appendSection();
12175
        }
12176
        
12177
        /**
12178
         * Get the string contents of a section.
12179
         *
12180
         * @param string $section
12181
         * @param string $default
12182
         * @return string 
12183
         * @static 
12184
         */ 
12185
        public static function yieldContent($section, $default = '')
12186
        {
12187
            return \Illuminate\View\Factory::yieldContent($section, $default);
12188
        }
12189
        
12190
        /**
12191
         * Get the parent placeholder for the current request.
12192
         *
12193
         * @param string $section
12194
         * @return string 
12195
         * @static 
12196
         */ 
12197
        public static function parentPlaceholder($section = '')
12198
        {
12199
            return \Illuminate\View\Factory::parentPlaceholder($section);
12200
        }
12201
        
12202
        /**
12203
         * Check if section exists.
12204
         *
12205
         * @param string $name
12206
         * @return bool 
12207
         * @static 
12208
         */ 
12209
        public static function hasSection($name)
12210
        {
12211
            return \Illuminate\View\Factory::hasSection($name);
12212
        }
12213
        
12214
        /**
12215
         * Get the contents of a section.
12216
         *
12217
         * @param string $name
12218
         * @param string $default
12219
         * @return mixed 
12220
         * @static 
12221
         */ 
12222
        public static function getSection($name, $default = null)
12223
        {
12224
            return \Illuminate\View\Factory::getSection($name, $default);
12225
        }
12226
        
12227
        /**
12228
         * Get the entire array of sections.
12229
         *
12230
         * @return array 
12231
         * @static 
12232
         */ 
12233
        public static function getSections()
12234
        {
12235
            return \Illuminate\View\Factory::getSections();
12236
        }
12237
        
12238
        /**
12239
         * Flush all of the sections.
12240
         *
12241
         * @return void 
12242
         * @static 
12243
         */ 
12244
        public static function flushSections()
12245
        {
12246
            \Illuminate\View\Factory::flushSections();
12247
        }
12248
        
12249
        /**
12250
         * Add new loop to the stack.
12251
         *
12252
         * @param \Countable|array $data
12253
         * @return void 
12254
         * @static 
12255
         */ 
12256
        public static function addLoop($data)
12257
        {
12258
            \Illuminate\View\Factory::addLoop($data);
12259
        }
12260
        
12261
        /**
12262
         * Increment the top loop's indices.
12263
         *
12264
         * @return void 
12265
         * @static 
12266
         */ 
12267
        public static function incrementLoopIndices()
12268
        {
12269
            \Illuminate\View\Factory::incrementLoopIndices();
12270
        }
12271
        
12272
        /**
12273
         * Pop a loop from the top of the loop stack.
12274
         *
12275
         * @return void 
12276
         * @static 
12277
         */ 
12278
        public static function popLoop()
12279
        {
12280
            \Illuminate\View\Factory::popLoop();
12281
        }
12282
        
12283
        /**
12284
         * Get an instance of the last loop in the stack.
12285
         *
12286
         * @return \stdClass|null 
12287
         * @static 
12288
         */ 
12289
        public static function getLastLoop()
12290
        {
12291
            return \Illuminate\View\Factory::getLastLoop();
12292
        }
12293
        
12294
        /**
12295
         * Get the entire loop stack.
12296
         *
12297
         * @return array 
12298
         * @static 
12299
         */ 
12300
        public static function getLoopStack()
12301
        {
12302
            return \Illuminate\View\Factory::getLoopStack();
12303
        }
12304
        
12305
        /**
12306
         * Start injecting content into a push section.
12307
         *
12308
         * @param string $section
12309
         * @param string $content
12310
         * @return void 
12311
         * @static 
12312
         */ 
12313
        public static function startPush($section, $content = '')
12314
        {
12315
            \Illuminate\View\Factory::startPush($section, $content);
12316
        }
12317
        
12318
        /**
12319
         * Stop injecting content into a push section.
12320
         *
12321
         * @return string 
12322
         * @throws \InvalidArgumentException
12323
         * @static 
12324
         */ 
12325
        public static function stopPush()
12326
        {
12327
            return \Illuminate\View\Factory::stopPush();
12328
        }
12329
        
12330
        /**
12331
         * Start prepending content into a push section.
12332
         *
12333
         * @param string $section
12334
         * @param string $content
12335
         * @return void 
12336
         * @static 
12337
         */ 
12338
        public static function startPrepend($section, $content = '')
12339
        {
12340
            \Illuminate\View\Factory::startPrepend($section, $content);
12341
        }
12342
        
12343
        /**
12344
         * Stop prepending content into a push section.
12345
         *
12346
         * @return string 
12347
         * @throws \InvalidArgumentException
12348
         * @static 
12349
         */ 
12350
        public static function stopPrepend()
12351
        {
12352
            return \Illuminate\View\Factory::stopPrepend();
12353
        }
12354
        
12355
        /**
12356
         * Get the string contents of a push section.
12357
         *
12358
         * @param string $section
12359
         * @param string $default
12360
         * @return string 
12361
         * @static 
12362
         */ 
12363
        public static function yieldPushContent($section, $default = '')
12364
        {
12365
            return \Illuminate\View\Factory::yieldPushContent($section, $default);
12366
        }
12367
        
12368
        /**
12369
         * Flush all of the stacks.
12370
         *
12371
         * @return void 
12372
         * @static 
12373
         */ 
12374
        public static function flushStacks()
12375
        {
12376
            \Illuminate\View\Factory::flushStacks();
12377
        }
12378
        
12379
        /**
12380
         * Start a translation block.
12381
         *
12382
         * @param array $replacements
12383
         * @return void 
12384
         * @static 
12385
         */ 
12386
        public static function startTranslation($replacements = array())
12387
        {
12388
            \Illuminate\View\Factory::startTranslation($replacements);
12389
        }
12390
        
12391
        /**
12392
         * Render the current translation.
12393
         *
12394
         * @return string 
12395
         * @static 
12396
         */ 
12397
        public static function renderTranslation()
12398
        {
12399
            return \Illuminate\View\Factory::renderTranslation();
12400
        }
12401
         
12402
    }
12403
 
12404
}
12405

12406

12407
namespace  { 
12408

12409
    class App extends \Illuminate\Support\Facades\App {}
12410

12411
    class Artisan extends \Illuminate\Support\Facades\Artisan {}
12412

12413
    class Auth extends \Illuminate\Support\Facades\Auth {}
12414

12415
    class Blade extends \Illuminate\Support\Facades\Blade {}
12416

12417
    class Broadcast extends \Illuminate\Support\Facades\Broadcast {}
12418

12419
    class Bus extends \Illuminate\Support\Facades\Bus {}
12420

12421
    class Cache extends \Illuminate\Support\Facades\Cache {}
12422

12423
    class Config extends \Illuminate\Support\Facades\Config {}
12424

12425
    class Cookie extends \Illuminate\Support\Facades\Cookie {}
12426

12427
    class Crypt extends \Illuminate\Support\Facades\Crypt {}
12428

12429
    class DB extends \Illuminate\Support\Facades\DB {}
12430

12431
    class Eloquent extends \Illuminate\Database\Eloquent\Model {         
12432
            /**
12433
             * Create and return an un-saved model instance.
12434
             *
12435
             * @param array $attributes
12436
             * @return \Illuminate\Database\Eloquent\Model 
12437
             * @static 
12438
             */ 
12439
            public static function make($attributes = array())
12440
            {    
12441
                return \Illuminate\Database\Eloquent\Builder::make($attributes);
12442
            }
12443
         
12444
            /**
12445
             * Register a new global scope.
12446
             *
12447
             * @param string $identifier
12448
             * @param \Illuminate\Database\Eloquent\Scope|\Closure $scope
12449
             * @return $this 
12450
             * @static 
12451
             */ 
12452
            public static function withGlobalScope($identifier, $scope)
12453
            {    
12454
                return \Illuminate\Database\Eloquent\Builder::withGlobalScope($identifier, $scope);
12455
            }
12456
         
12457
            /**
12458
             * Remove a registered global scope.
12459
             *
12460
             * @param \Illuminate\Database\Eloquent\Scope|string $scope
12461
             * @return $this 
12462
             * @static 
12463
             */ 
12464
            public static function withoutGlobalScope($scope)
12465
            {    
12466
                return \Illuminate\Database\Eloquent\Builder::withoutGlobalScope($scope);
12467
            }
12468
         
12469
            /**
12470
             * Remove all or passed registered global scopes.
12471
             *
12472
             * @param array|null $scopes
12473
             * @return $this 
12474
             * @static 
12475
             */ 
12476
            public static function withoutGlobalScopes($scopes = null)
12477
            {    
12478
                return \Illuminate\Database\Eloquent\Builder::withoutGlobalScopes($scopes);
12479
            }
12480
         
12481
            /**
12482
             * Get an array of global scopes that were removed from the query.
12483
             *
12484
             * @return array 
12485
             * @static 
12486
             */ 
12487
            public static function removedScopes()
12488
            {    
12489
                return \Illuminate\Database\Eloquent\Builder::removedScopes();
12490
            }
12491
         
12492
            /**
12493
             * Add a where clause on the primary key to the query.
12494
             *
12495
             * @param mixed $id
12496
             * @return $this 
12497
             * @static 
12498
             */ 
12499
            public static function whereKey($id)
12500
            {    
12501
                return \Illuminate\Database\Eloquent\Builder::whereKey($id);
12502
            }
12503
         
12504
            /**
12505
             * Add a where clause on the primary key to the query.
12506
             *
12507
             * @param mixed $id
12508
             * @return $this 
12509
             * @static 
12510
             */ 
12511
            public static function whereKeyNot($id)
12512
            {    
12513
                return \Illuminate\Database\Eloquent\Builder::whereKeyNot($id);
12514
            }
12515
         
12516
            /**
12517
             * Add a basic where clause to the query.
12518
             *
12519
             * @param string|array|\Closure $column
12520
             * @param string $operator
12521
             * @param mixed $value
12522
             * @param string $boolean
12523
             * @return $this 
12524
             * @static 
12525
             */ 
12526
            public static function where($column, $operator = null, $value = null, $boolean = 'and')
12527
            {    
12528
                return \Illuminate\Database\Eloquent\Builder::where($column, $operator, $value, $boolean);
12529
            }
12530
         
12531
            /**
12532
             * Add an "or where" clause to the query.
12533
             *
12534
             * @param \Closure|array|string $column
12535
             * @param string $operator
12536
             * @param mixed $value
12537
             * @return \Illuminate\Database\Eloquent\Builder|static 
12538
             * @static 
12539
             */ 
12540
            public static function orWhere($column, $operator = null, $value = null)
12541
            {    
12542
                return \Illuminate\Database\Eloquent\Builder::orWhere($column, $operator, $value);
12543
            }
12544
         
12545
            /**
12546
             * Create a collection of models from plain arrays.
12547
             *
12548
             * @param array $items
12549
             * @return \Illuminate\Database\Eloquent\Collection 
12550
             * @static 
12551
             */ 
12552
            public static function hydrate($items)
12553
            {    
12554
                return \Illuminate\Database\Eloquent\Builder::hydrate($items);
12555
            }
12556
         
12557
            /**
12558
             * Create a collection of models from a raw query.
12559
             *
12560
             * @param string $query
12561
             * @param array $bindings
12562
             * @return \Illuminate\Database\Eloquent\Collection 
12563
             * @static 
12564
             */ 
12565
            public static function fromQuery($query, $bindings = array())
12566
            {    
12567
                return \Illuminate\Database\Eloquent\Builder::fromQuery($query, $bindings);
12568
            }
12569
         
12570
            /**
12571
             * Find a model by its primary key.
12572
             *
12573
             * @param mixed $id
12574
             * @param array $columns
12575
             * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static[]|static|null 
12576
             * @static 
12577
             */ 
12578
            public static function find($id, $columns = array())
12579
            {    
12580
                return \Illuminate\Database\Eloquent\Builder::find($id, $columns);
12581
            }
12582
         
12583
            /**
12584
             * Find multiple models by their primary keys.
12585
             *
12586
             * @param \Illuminate\Contracts\Support\Arrayable|array $ids
12587
             * @param array $columns
12588
             * @return \Illuminate\Database\Eloquent\Collection 
12589
             * @static 
12590
             */ 
12591
            public static function findMany($ids, $columns = array())
12592
            {    
12593
                return \Illuminate\Database\Eloquent\Builder::findMany($ids, $columns);
12594
            }
12595
         
12596
            /**
12597
             * Find a model by its primary key or throw an exception.
12598
             *
12599
             * @param mixed $id
12600
             * @param array $columns
12601
             * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection 
12602
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
12603
             * @static 
12604
             */ 
12605
            public static function findOrFail($id, $columns = array())
12606
            {    
12607
                return \Illuminate\Database\Eloquent\Builder::findOrFail($id, $columns);
12608
            }
12609
         
12610
            /**
12611
             * Find a model by its primary key or return fresh model instance.
12612
             *
12613
             * @param mixed $id
12614
             * @param array $columns
12615
             * @return \Illuminate\Database\Eloquent\Model 
12616
             * @static 
12617
             */ 
12618
            public static function findOrNew($id, $columns = array())
12619
            {    
12620
                return \Illuminate\Database\Eloquent\Builder::findOrNew($id, $columns);
12621
            }
12622
         
12623
            /**
12624
             * Get the first record matching the attributes or instantiate it.
12625
             *
12626
             * @param array $attributes
12627
             * @param array $values
12628
             * @return \Illuminate\Database\Eloquent\Model 
12629
             * @static 
12630
             */ 
12631
            public static function firstOrNew($attributes, $values = array())
12632
            {    
12633
                return \Illuminate\Database\Eloquent\Builder::firstOrNew($attributes, $values);
12634
            }
12635
         
12636
            /**
12637
             * Get the first record matching the attributes or create it.
12638
             *
12639
             * @param array $attributes
12640
             * @param array $values
12641
             * @return \Illuminate\Database\Eloquent\Model 
12642
             * @static 
12643
             */ 
12644
            public static function firstOrCreate($attributes, $values = array())
12645
            {    
12646
                return \Illuminate\Database\Eloquent\Builder::firstOrCreate($attributes, $values);
12647
            }
12648
         
12649
            /**
12650
             * Create or update a record matching the attributes, and fill it with values.
12651
             *
12652
             * @param array $attributes
12653
             * @param array $values
12654
             * @return \Illuminate\Database\Eloquent\Model 
12655
             * @static 
12656
             */ 
12657
            public static function updateOrCreate($attributes, $values = array())
12658
            {    
12659
                return \Illuminate\Database\Eloquent\Builder::updateOrCreate($attributes, $values);
12660
            }
12661
         
12662
            /**
12663
             * Execute the query and get the first result or throw an exception.
12664
             *
12665
             * @param array $columns
12666
             * @return \Illuminate\Database\Eloquent\Model|static 
12667
             * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
12668
             * @static 
12669
             */ 
12670
            public static function firstOrFail($columns = array())
12671
            {    
12672
                return \Illuminate\Database\Eloquent\Builder::firstOrFail($columns);
12673
            }
12674
         
12675
            /**
12676
             * Execute the query and get the first result or call a callback.
12677
             *
12678
             * @param \Closure|array $columns
12679
             * @param \Closure|null $callback
12680
             * @return \Illuminate\Database\Eloquent\Model|static|mixed 
12681
             * @static 
12682
             */ 
12683
            public static function firstOr($columns = array(), $callback = null)
12684
            {    
12685
                return \Illuminate\Database\Eloquent\Builder::firstOr($columns, $callback);
12686
            }
12687
         
12688
            /**
12689
             * Get a single column's value from the first result of a query.
12690
             *
12691
             * @param string $column
12692
             * @return mixed 
12693
             * @static 
12694
             */ 
12695
            public static function value($column)
12696
            {    
12697
                return \Illuminate\Database\Eloquent\Builder::value($column);
12698
            }
12699
         
12700
            /**
12701
             * Execute the query as a "select" statement.
12702
             *
12703
             * @param array $columns
12704
             * @return \Illuminate\Database\Eloquent\Collection|static[] 
12705
             * @static 
12706
             */ 
12707
            public static function get($columns = array())
12708
            {    
12709
                return \Illuminate\Database\Eloquent\Builder::get($columns);
12710
            }
12711
         
12712
            /**
12713
             * Get the hydrated models without eager loading.
12714
             *
12715
             * @param array $columns
12716
             * @return \Illuminate\Database\Eloquent\Model[] 
12717
             * @static 
12718
             */ 
12719
            public static function getModels($columns = array())
12720
            {    
12721
                return \Illuminate\Database\Eloquent\Builder::getModels($columns);
12722
            }
12723
         
12724
            /**
12725
             * Eager load the relationships for the models.
12726
             *
12727
             * @param array $models
12728
             * @return array 
12729
             * @static 
12730
             */ 
12731
            public static function eagerLoadRelations($models)
12732
            {    
12733
                return \Illuminate\Database\Eloquent\Builder::eagerLoadRelations($models);
12734
            }
12735
         
12736
            /**
12737
             * Get a generator for the given query.
12738
             *
12739
             * @return \Generator 
12740
             * @static 
12741
             */ 
12742
            public static function cursor()
12743
            {    
12744
                return \Illuminate\Database\Eloquent\Builder::cursor();
12745
            }
12746
         
12747
            /**
12748
             * Chunk the results of a query by comparing numeric IDs.
12749
             *
12750
             * @param int $count
12751
             * @param callable $callback
12752
             * @param string $column
12753
             * @param string|null $alias
12754
             * @return bool 
12755
             * @static 
12756
             */ 
12757
            public static function chunkById($count, $callback, $column = null, $alias = null)
12758
            {    
12759
                return \Illuminate\Database\Eloquent\Builder::chunkById($count, $callback, $column, $alias);
12760
            }
12761
         
12762
            /**
12763
             * Get an array with the values of a given column.
12764
             *
12765
             * @param string $column
12766
             * @param string|null $key
12767
             * @return \Illuminate\Support\Collection 
12768
             * @static 
12769
             */ 
12770
            public static function pluck($column, $key = null)
12771
            {    
12772
                return \Illuminate\Database\Eloquent\Builder::pluck($column, $key);
12773
            }
12774
         
12775
            /**
12776
             * Paginate the given query.
12777
             *
12778
             * @param int $perPage
12779
             * @param array $columns
12780
             * @param string $pageName
12781
             * @param int|null $page
12782
             * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator 
12783
             * @throws \InvalidArgumentException
12784
             * @static 
12785
             */ 
12786
            public static function paginate($perPage = null, $columns = array(), $pageName = 'page', $page = null)
12787
            {    
12788
                return \Illuminate\Database\Eloquent\Builder::paginate($perPage, $columns, $pageName, $page);
12789
            }
12790
         
12791
            /**
12792
             * Paginate the given query into a simple paginator.
12793
             *
12794
             * @param int $perPage
12795
             * @param array $columns
12796
             * @param string $pageName
12797
             * @param int|null $page
12798
             * @return \Illuminate\Contracts\Pagination\Paginator 
12799
             * @static 
12800
             */ 
12801
            public static function simplePaginate($perPage = null, $columns = array(), $pageName = 'page', $page = null)
12802
            {    
12803
                return \Illuminate\Database\Eloquent\Builder::simplePaginate($perPage, $columns, $pageName, $page);
12804
            }
12805
         
12806
            /**
12807
             * Save a new model and return the instance.
12808
             *
12809
             * @param array $attributes
12810
             * @return \Illuminate\Database\Eloquent\Model|$this 
12811
             * @static 
12812
             */ 
12813
            public static function create($attributes = array())
12814
            {    
12815
                return \Illuminate\Database\Eloquent\Builder::create($attributes);
12816
            }
12817
         
12818
            /**
12819
             * Save a new model and return the instance. Allow mass-assignment.
12820
             *
12821
             * @param array $attributes
12822
             * @return \Illuminate\Database\Eloquent\Model|$this 
12823
             * @static 
12824
             */ 
12825
            public static function forceCreate($attributes)
12826
            {    
12827
                return \Illuminate\Database\Eloquent\Builder::forceCreate($attributes);
12828
            }
12829
         
12830
            /**
12831
             * Register a replacement for the default delete function.
12832
             *
12833
             * @param \Closure $callback
12834
             * @return void 
12835
             * @static 
12836
             */ 
12837
            public static function onDelete($callback)
12838
            {    
12839
                \Illuminate\Database\Eloquent\Builder::onDelete($callback);
12840
            }
12841
         
12842
            /**
12843
             * Call the given local model scopes.
12844
             *
12845
             * @param array $scopes
12846
             * @return mixed 
12847
             * @static 
12848
             */ 
12849
            public static function scopes($scopes)
12850
            {    
12851
                return \Illuminate\Database\Eloquent\Builder::scopes($scopes);
12852
            }
12853
         
12854
            /**
12855
             * Apply the scopes to the Eloquent builder instance and return it.
12856
             *
12857
             * @return \Illuminate\Database\Eloquent\Builder|static 
12858
             * @static 
12859
             */ 
12860
            public static function applyScopes()
12861
            {    
12862
                return \Illuminate\Database\Eloquent\Builder::applyScopes();
12863
            }
12864
         
12865
            /**
12866
             * Prevent the specified relations from being eager loaded.
12867
             *
12868
             * @param mixed $relations
12869
             * @return $this 
12870
             * @static 
12871
             */ 
12872
            public static function without($relations)
12873
            {    
12874
                return \Illuminate\Database\Eloquent\Builder::without($relations);
12875
            }
12876
         
12877
            /**
12878
             * Create a new instance of the model being queried.
12879
             *
12880
             * @param array $attributes
12881
             * @return \Illuminate\Database\Eloquent\Model 
12882
             * @static 
12883
             */ 
12884
            public static function newModelInstance($attributes = array())
12885
            {    
12886
                return \Illuminate\Database\Eloquent\Builder::newModelInstance($attributes);
12887
            }
12888
         
12889
            /**
12890
             * Get the underlying query builder instance.
12891
             *
12892
             * @return \Illuminate\Database\Query\Builder 
12893
             * @static 
12894
             */ 
12895
            public static function getQuery()
12896
            {    
12897
                return \Illuminate\Database\Eloquent\Builder::getQuery();
12898
            }
12899
         
12900
            /**
12901
             * Set the underlying query builder instance.
12902
             *
12903
             * @param \Illuminate\Database\Query\Builder $query
12904
             * @return $this 
12905
             * @static 
12906
             */ 
12907
            public static function setQuery($query)
12908
            {    
12909
                return \Illuminate\Database\Eloquent\Builder::setQuery($query);
12910
            }
12911
         
12912
            /**
12913
             * Get a base query builder instance.
12914
             *
12915
             * @return \Illuminate\Database\Query\Builder 
12916
             * @static 
12917
             */ 
12918
            public static function toBase()
12919
            {    
12920
                return \Illuminate\Database\Eloquent\Builder::toBase();
12921
            }
12922
         
12923
            /**
12924
             * Get the relationships being eagerly loaded.
12925
             *
12926
             * @return array 
12927
             * @static 
12928
             */ 
12929
            public static function getEagerLoads()
12930
            {    
12931
                return \Illuminate\Database\Eloquent\Builder::getEagerLoads();
12932
            }
12933
         
12934
            /**
12935
             * Set the relationships being eagerly loaded.
12936
             *
12937
             * @param array $eagerLoad
12938
             * @return $this 
12939
             * @static 
12940
             */ 
12941
            public static function setEagerLoads($eagerLoad)
12942
            {    
12943
                return \Illuminate\Database\Eloquent\Builder::setEagerLoads($eagerLoad);
12944
            }
12945
         
12946
            /**
12947
             * Get the model instance being queried.
12948
             *
12949
             * @return \Illuminate\Database\Eloquent\Model 
12950
             * @static 
12951
             */ 
12952
            public static function getModel()
12953
            {    
12954
                return \Illuminate\Database\Eloquent\Builder::getModel();
12955
            }
12956
         
12957
            /**
12958
             * Set a model instance for the model being queried.
12959
             *
12960
             * @param \Illuminate\Database\Eloquent\Model $model
12961
             * @return $this 
12962
             * @static 
12963
             */ 
12964
            public static function setModel($model)
12965
            {    
12966
                return \Illuminate\Database\Eloquent\Builder::setModel($model);
12967
            }
12968
         
12969
            /**
12970
             * Get the given macro by name.
12971
             *
12972
             * @param string $name
12973
             * @return \Closure 
12974
             * @static 
12975
             */ 
12976
            public static function getMacro($name)
12977
            {    
12978
                return \Illuminate\Database\Eloquent\Builder::getMacro($name);
12979
            }
12980
         
12981
            /**
12982
             * Chunk the results of the query.
12983
             *
12984
             * @param int $count
12985
             * @param callable $callback
12986
             * @return bool 
12987
             * @static 
12988
             */ 
12989
            public static function chunk($count, $callback)
12990
            {    
12991
                return \Illuminate\Database\Eloquent\Builder::chunk($count, $callback);
12992
            }
12993
         
12994
            /**
12995
             * Execute a callback over each item while chunking.
12996
             *
12997
             * @param callable $callback
12998
             * @param int $count
12999
             * @return bool 
13000
             * @static 
13001
             */ 
13002
            public static function each($callback, $count = 1000)
13003
            {    
13004
                return \Illuminate\Database\Eloquent\Builder::each($callback, $count);
13005
            }
13006
         
13007
            /**
13008
             * Execute the query and get the first result.
13009
             *
13010
             * @param array $columns
13011
             * @return \Illuminate\Database\Eloquent\Model|object|static|null 
13012
             * @static 
13013
             */ 
13014
            public static function first($columns = array())
13015
            {    
13016
                return \Illuminate\Database\Eloquent\Builder::first($columns);
13017
            }
13018
         
13019
            /**
13020
             * Apply the callback's query changes if the given "value" is true.
13021
             *
13022
             * @param mixed $value
13023
             * @param callable $callback
13024
             * @param callable $default
13025
             * @return mixed 
13026
             * @static 
13027
             */ 
13028
            public static function when($value, $callback, $default = null)
13029
            {    
13030
                return \Illuminate\Database\Eloquent\Builder::when($value, $callback, $default);
13031
            }
13032
         
13033
            /**
13034
             * Pass the query to a given callback.
13035
             *
13036
             * @param \Closure $callback
13037
             * @return \Illuminate\Database\Query\Builder 
13038
             * @static 
13039
             */ 
13040
            public static function tap($callback)
13041
            {    
13042
                return \Illuminate\Database\Eloquent\Builder::tap($callback);
13043
            }
13044
         
13045
            /**
13046
             * Apply the callback's query changes if the given "value" is false.
13047
             *
13048
             * @param mixed $value
13049
             * @param callable $callback
13050
             * @param callable $default
13051
             * @return mixed 
13052
             * @static 
13053
             */ 
13054
            public static function unless($value, $callback, $default = null)
13055
            {    
13056
                return \Illuminate\Database\Eloquent\Builder::unless($value, $callback, $default);
13057
            }
13058
         
13059
            /**
13060
             * Add a relationship count / exists condition to the query.
13061
             *
13062
             * @param string $relation
13063
             * @param string $operator
13064
             * @param int $count
13065
             * @param string $boolean
13066
             * @param \Closure|null $callback
13067
             * @return \Illuminate\Database\Eloquent\Builder|static 
13068
             * @static 
13069
             */ 
13070
            public static function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
13071
            {    
13072
                return \Illuminate\Database\Eloquent\Builder::has($relation, $operator, $count, $boolean, $callback);
13073
            }
13074
         
13075
            /**
13076
             * Add a relationship count / exists condition to the query with an "or".
13077
             *
13078
             * @param string $relation
13079
             * @param string $operator
13080
             * @param int $count
13081
             * @return \Illuminate\Database\Eloquent\Builder|static 
13082
             * @static 
13083
             */ 
13084
            public static function orHas($relation, $operator = '>=', $count = 1)
13085
            {    
13086
                return \Illuminate\Database\Eloquent\Builder::orHas($relation, $operator, $count);
13087
            }
13088
         
13089
            /**
13090
             * Add a relationship count / exists condition to the query.
13091
             *
13092
             * @param string $relation
13093
             * @param string $boolean
13094
             * @param \Closure|null $callback
13095
             * @return \Illuminate\Database\Eloquent\Builder|static 
13096
             * @static 
13097
             */ 
13098
            public static function doesntHave($relation, $boolean = 'and', $callback = null)
13099
            {    
13100
                return \Illuminate\Database\Eloquent\Builder::doesntHave($relation, $boolean, $callback);
13101
            }
13102
         
13103
            /**
13104
             * Add a relationship count / exists condition to the query with an "or".
13105
             *
13106
             * @param string $relation
13107
             * @return \Illuminate\Database\Eloquent\Builder|static 
13108
             * @static 
13109
             */ 
13110
            public static function orDoesntHave($relation)
13111
            {    
13112
                return \Illuminate\Database\Eloquent\Builder::orDoesntHave($relation);
13113
            }
13114
         
13115
            /**
13116
             * Add a relationship count / exists condition to the query with where clauses.
13117
             *
13118
             * @param string $relation
13119
             * @param \Closure|null $callback
13120
             * @param string $operator
13121
             * @param int $count
13122
             * @return \Illuminate\Database\Eloquent\Builder|static 
13123
             * @static 
13124
             */ 
13125
            public static function whereHas($relation, $callback = null, $operator = '>=', $count = 1)
13126
            {    
13127
                return \Illuminate\Database\Eloquent\Builder::whereHas($relation, $callback, $operator, $count);
13128
            }
13129
         
13130
            /**
13131
             * Add a relationship count / exists condition to the query with where clauses and an "or".
13132
             *
13133
             * @param string $relation
13134
             * @param \Closure $callback
13135
             * @param string $operator
13136
             * @param int $count
13137
             * @return \Illuminate\Database\Eloquent\Builder|static 
13138
             * @static 
13139
             */ 
13140
            public static function orWhereHas($relation, $callback = null, $operator = '>=', $count = 1)
13141
            {    
13142
                return \Illuminate\Database\Eloquent\Builder::orWhereHas($relation, $callback, $operator, $count);
13143
            }
13144
         
13145
            /**
13146
             * Add a relationship count / exists condition to the query with where clauses.
13147
             *
13148
             * @param string $relation
13149
             * @param \Closure|null $callback
13150
             * @return \Illuminate\Database\Eloquent\Builder|static 
13151
             * @static 
13152
             */ 
13153
            public static function whereDoesntHave($relation, $callback = null)
13154
            {    
13155
                return \Illuminate\Database\Eloquent\Builder::whereDoesntHave($relation, $callback);
13156
            }
13157
         
13158
            /**
13159
             * Add a relationship count / exists condition to the query with where clauses and an "or".
13160
             *
13161
             * @param string $relation
13162
             * @param \Closure $callback
13163
             * @return \Illuminate\Database\Eloquent\Builder|static 
13164
             * @static 
13165
             */ 
13166
            public static function orWhereDoesntHave($relation, $callback = null)
13167
            {    
13168
                return \Illuminate\Database\Eloquent\Builder::orWhereDoesntHave($relation, $callback);
13169
            }
13170
         
13171
            /**
13172
             * Add subselect queries to count the relations.
13173
             *
13174
             * @param mixed $relations
13175
             * @return $this 
13176
             * @static 
13177
             */ 
13178
            public static function withCount($relations)
13179
            {    
13180
                return \Illuminate\Database\Eloquent\Builder::withCount($relations);
13181
            }
13182
         
13183
            /**
13184
             * Merge the where constraints from another query to the current query.
13185
             *
13186
             * @param \Illuminate\Database\Eloquent\Builder $from
13187
             * @return \Illuminate\Database\Eloquent\Builder|static 
13188
             * @static 
13189
             */ 
13190
            public static function mergeConstraintsFrom($from)
13191
            {    
13192
                return \Illuminate\Database\Eloquent\Builder::mergeConstraintsFrom($from);
13193
            }
13194
         
13195
            /**
13196
             * Set the columns to be selected.
13197
             *
13198
             * @param array|mixed $columns
13199
             * @return $this 
13200
             * @static 
13201
             */ 
13202
            public static function select($columns = array())
13203
            {    
13204
                return \Illuminate\Database\Query\Builder::select($columns);
13205
            }
13206
         
13207
            /**
13208
             * Add a subselect expression to the query.
13209
             *
13210
             * @param \Closure|\Illuminate\Database\Query\Builder|string $query
13211
             * @param string $as
13212
             * @return \Illuminate\Database\Query\Builder|static 
13213
             * @throws \InvalidArgumentException
13214
             * @static 
13215
             */ 
13216
            public static function selectSub($query, $as)
13217
            {    
13218
                return \Illuminate\Database\Query\Builder::selectSub($query, $as);
13219
            }
13220
         
13221
            /**
13222
             * Add a new "raw" select expression to the query.
13223
             *
13224
             * @param string $expression
13225
             * @param array $bindings
13226
             * @return \Illuminate\Database\Query\Builder|static 
13227
             * @static 
13228
             */ 
13229
            public static function selectRaw($expression, $bindings = array())
13230
            {    
13231
                return \Illuminate\Database\Query\Builder::selectRaw($expression, $bindings);
13232
            }
13233
         
13234
            /**
13235
             * Makes "from" fetch from a subquery.
13236
             *
13237
             * @param \Closure|\Illuminate\Database\Query\Builder|string $query
13238
             * @param string $as
13239
             * @return \Illuminate\Database\Query\Builder|static 
13240
             * @throws \InvalidArgumentException
13241
             * @static 
13242
             */ 
13243
            public static function fromSub($query, $as)
13244
            {    
13245
                return \Illuminate\Database\Query\Builder::fromSub($query, $as);
13246
            }
13247
         
13248
            /**
13249
             * Add a raw from clause to the query.
13250
             *
13251
             * @param string $expression
13252
             * @param mixed $bindings
13253
             * @return \Illuminate\Database\Query\Builder|static 
13254
             * @static 
13255
             */ 
13256
            public static function fromRaw($expression, $bindings = array())
13257
            {    
13258
                return \Illuminate\Database\Query\Builder::fromRaw($expression, $bindings);
13259
            }
13260
         
13261
            /**
13262
             * Add a new select column to the query.
13263
             *
13264
             * @param array|mixed $column
13265
             * @return $this 
13266
             * @static 
13267
             */ 
13268
            public static function addSelect($column)
13269
            {    
13270
                return \Illuminate\Database\Query\Builder::addSelect($column);
13271
            }
13272
         
13273
            /**
13274
             * Force the query to only return distinct results.
13275
             *
13276
             * @return $this 
13277
             * @static 
13278
             */ 
13279
            public static function distinct()
13280
            {    
13281
                return \Illuminate\Database\Query\Builder::distinct();
13282
            }
13283
         
13284
            /**
13285
             * Set the table which the query is targeting.
13286
             *
13287
             * @param string $table
13288
             * @return $this 
13289
             * @static 
13290
             */ 
13291
            public static function from($table)
13292
            {    
13293
                return \Illuminate\Database\Query\Builder::from($table);
13294
            }
13295
         
13296
            /**
13297
             * Add a join clause to the query.
13298
             *
13299
             * @param string $table
13300
             * @param string $first
13301
             * @param string|null $operator
13302
             * @param string|null $second
13303
             * @param string $type
13304
             * @param bool $where
13305
             * @return $this 
13306
             * @static 
13307
             */ 
13308
            public static function join($table, $first, $operator = null, $second = null, $type = 'inner', $where = false)
13309
            {    
13310
                return \Illuminate\Database\Query\Builder::join($table, $first, $operator, $second, $type, $where);
13311
            }
13312
         
13313
            /**
13314
             * Add a "join where" clause to the query.
13315
             *
13316
             * @param string $table
13317
             * @param string $first
13318
             * @param string $operator
13319
             * @param string $second
13320
             * @param string $type
13321
             * @return \Illuminate\Database\Query\Builder|static 
13322
             * @static 
13323
             */ 
13324
            public static function joinWhere($table, $first, $operator, $second, $type = 'inner')
13325
            {    
13326
                return \Illuminate\Database\Query\Builder::joinWhere($table, $first, $operator, $second, $type);
13327
            }
13328
         
13329
            /**
13330
             * Add a left join to the query.
13331
             *
13332
             * @param string $table
13333
             * @param string $first
13334
             * @param string|null $operator
13335
             * @param string|null $second
13336
             * @return \Illuminate\Database\Query\Builder|static 
13337
             * @static 
13338
             */ 
13339
            public static function leftJoin($table, $first, $operator = null, $second = null)
13340
            {    
13341
                return \Illuminate\Database\Query\Builder::leftJoin($table, $first, $operator, $second);
13342
            }
13343
         
13344
            /**
13345
             * Add a "join where" clause to the query.
13346
             *
13347
             * @param string $table
13348
             * @param string $first
13349
             * @param string $operator
13350
             * @param string $second
13351
             * @return \Illuminate\Database\Query\Builder|static 
13352
             * @static 
13353
             */ 
13354
            public static function leftJoinWhere($table, $first, $operator, $second)
13355
            {    
13356
                return \Illuminate\Database\Query\Builder::leftJoinWhere($table, $first, $operator, $second);
13357
            }
13358
         
13359
            /**
13360
             * Add a right join to the query.
13361
             *
13362
             * @param string $table
13363
             * @param string $first
13364
             * @param string|null $operator
13365
             * @param string|null $second
13366
             * @return \Illuminate\Database\Query\Builder|static 
13367
             * @static 
13368
             */ 
13369
            public static function rightJoin($table, $first, $operator = null, $second = null)
13370
            {    
13371
                return \Illuminate\Database\Query\Builder::rightJoin($table, $first, $operator, $second);
13372
            }
13373
         
13374
            /**
13375
             * Add a "right join where" clause to the query.
13376
             *
13377
             * @param string $table
13378
             * @param string $first
13379
             * @param string $operator
13380
             * @param string $second
13381
             * @return \Illuminate\Database\Query\Builder|static 
13382
             * @static 
13383
             */ 
13384
            public static function rightJoinWhere($table, $first, $operator, $second)
13385
            {    
13386
                return \Illuminate\Database\Query\Builder::rightJoinWhere($table, $first, $operator, $second);
13387
            }
13388
         
13389
            /**
13390
             * Add a "cross join" clause to the query.
13391
             *
13392
             * @param string $table
13393
             * @param string|null $first
13394
             * @param string|null $operator
13395
             * @param string|null $second
13396
             * @return \Illuminate\Database\Query\Builder|static 
13397
             * @static 
13398
             */ 
13399
            public static function crossJoin($table, $first = null, $operator = null, $second = null)
13400
            {    
13401
                return \Illuminate\Database\Query\Builder::crossJoin($table, $first, $operator, $second);
13402
            }
13403
         
13404
            /**
13405
             * Merge an array of where clauses and bindings.
13406
             *
13407
             * @param array $wheres
13408
             * @param array $bindings
13409
             * @return void 
13410
             * @static 
13411
             */ 
13412
            public static function mergeWheres($wheres, $bindings)
13413
            {    
13414
                \Illuminate\Database\Query\Builder::mergeWheres($wheres, $bindings);
13415
            }
13416
         
13417
            /**
13418
             * Prepare the value and operator for a where clause.
13419
             *
13420
             * @param string $value
13421
             * @param string $operator
13422
             * @param bool $useDefault
13423
             * @return array 
13424
             * @throws \InvalidArgumentException
13425
             * @static 
13426
             */ 
13427
            public static function prepareValueAndOperator($value, $operator, $useDefault = false)
13428
            {    
13429
                return \Illuminate\Database\Query\Builder::prepareValueAndOperator($value, $operator, $useDefault);
13430
            }
13431
         
13432
            /**
13433
             * Add a "where" clause comparing two columns to the query.
13434
             *
13435
             * @param string|array $first
13436
             * @param string|null $operator
13437
             * @param string|null $second
13438
             * @param string|null $boolean
13439
             * @return \Illuminate\Database\Query\Builder|static 
13440
             * @static 
13441
             */ 
13442
            public static function whereColumn($first, $operator = null, $second = null, $boolean = 'and')
13443
            {    
13444
                return \Illuminate\Database\Query\Builder::whereColumn($first, $operator, $second, $boolean);
13445
            }
13446
         
13447
            /**
13448
             * Add an "or where" clause comparing two columns to the query.
13449
             *
13450
             * @param string|array $first
13451
             * @param string|null $operator
13452
             * @param string|null $second
13453
             * @return \Illuminate\Database\Query\Builder|static 
13454
             * @static 
13455
             */ 
13456
            public static function orWhereColumn($first, $operator = null, $second = null)
13457
            {    
13458
                return \Illuminate\Database\Query\Builder::orWhereColumn($first, $operator, $second);
13459
            }
13460
         
13461
            /**
13462
             * Add a raw where clause to the query.
13463
             *
13464
             * @param string $sql
13465
             * @param mixed $bindings
13466
             * @param string $boolean
13467
             * @return $this 
13468
             * @static 
13469
             */ 
13470
            public static function whereRaw($sql, $bindings = array(), $boolean = 'and')
13471
            {    
13472
                return \Illuminate\Database\Query\Builder::whereRaw($sql, $bindings, $boolean);
13473
            }
13474
         
13475
            /**
13476
             * Add a raw or where clause to the query.
13477
             *
13478
             * @param string $sql
13479
             * @param mixed $bindings
13480
             * @return \Illuminate\Database\Query\Builder|static 
13481
             * @static 
13482
             */ 
13483
            public static function orWhereRaw($sql, $bindings = array())
13484
            {    
13485
                return \Illuminate\Database\Query\Builder::orWhereRaw($sql, $bindings);
13486
            }
13487
         
13488
            /**
13489
             * Add a "where in" clause to the query.
13490
             *
13491
             * @param string $column
13492
             * @param mixed $values
13493
             * @param string $boolean
13494
             * @param bool $not
13495
             * @return $this 
13496
             * @static 
13497
             */ 
13498
            public static function whereIn($column, $values, $boolean = 'and', $not = false)
13499
            {    
13500
                return \Illuminate\Database\Query\Builder::whereIn($column, $values, $boolean, $not);
13501
            }
13502
         
13503
            /**
13504
             * Add an "or where in" clause to the query.
13505
             *
13506
             * @param string $column
13507
             * @param mixed $values
13508
             * @return \Illuminate\Database\Query\Builder|static 
13509
             * @static 
13510
             */ 
13511
            public static function orWhereIn($column, $values)
13512
            {    
13513
                return \Illuminate\Database\Query\Builder::orWhereIn($column, $values);
13514
            }
13515
         
13516
            /**
13517
             * Add a "where not in" clause to the query.
13518
             *
13519
             * @param string $column
13520
             * @param mixed $values
13521
             * @param string $boolean
13522
             * @return \Illuminate\Database\Query\Builder|static 
13523
             * @static 
13524
             */ 
13525
            public static function whereNotIn($column, $values, $boolean = 'and')
13526
            {    
13527
                return \Illuminate\Database\Query\Builder::whereNotIn($column, $values, $boolean);
13528
            }
13529
         
13530
            /**
13531
             * Add an "or where not in" clause to the query.
13532
             *
13533
             * @param string $column
13534
             * @param mixed $values
13535
             * @return \Illuminate\Database\Query\Builder|static 
13536
             * @static 
13537
             */ 
13538
            public static function orWhereNotIn($column, $values)
13539
            {    
13540
                return \Illuminate\Database\Query\Builder::orWhereNotIn($column, $values);
13541
            }
13542
         
13543
            /**
13544
             * Add a "where null" clause to the query.
13545
             *
13546
             * @param string $column
13547
             * @param string $boolean
13548
             * @param bool $not
13549
             * @return $this 
13550
             * @static 
13551
             */ 
13552
            public static function whereNull($column, $boolean = 'and', $not = false)
13553
            {    
13554
                return \Illuminate\Database\Query\Builder::whereNull($column, $boolean, $not);
13555
            }
13556
         
13557
            /**
13558
             * Add an "or where null" clause to the query.
13559
             *
13560
             * @param string $column
13561
             * @return \Illuminate\Database\Query\Builder|static 
13562
             * @static 
13563
             */ 
13564
            public static function orWhereNull($column)
13565
            {    
13566
                return \Illuminate\Database\Query\Builder::orWhereNull($column);
13567
            }
13568
         
13569
            /**
13570
             * Add a "where not null" clause to the query.
13571
             *
13572
             * @param string $column
13573
             * @param string $boolean
13574
             * @return \Illuminate\Database\Query\Builder|static 
13575
             * @static 
13576
             */ 
13577
            public static function whereNotNull($column, $boolean = 'and')
13578
            {    
13579
                return \Illuminate\Database\Query\Builder::whereNotNull($column, $boolean);
13580
            }
13581
         
13582
            /**
13583
             * Add a where between statement to the query.
13584
             *
13585
             * @param string $column
13586
             * @param array $values
13587
             * @param string $boolean
13588
             * @param bool $not
13589
             * @return $this 
13590
             * @static 
13591
             */ 
13592
            public static function whereBetween($column, $values, $boolean = 'and', $not = false)
13593
            {    
13594
                return \Illuminate\Database\Query\Builder::whereBetween($column, $values, $boolean, $not);
13595
            }
13596
         
13597
            /**
13598
             * Add an or where between statement to the query.
13599
             *
13600
             * @param string $column
13601
             * @param array $values
13602
             * @return \Illuminate\Database\Query\Builder|static 
13603
             * @static 
13604
             */ 
13605
            public static function orWhereBetween($column, $values)
13606
            {    
13607
                return \Illuminate\Database\Query\Builder::orWhereBetween($column, $values);
13608
            }
13609
         
13610
            /**
13611
             * Add a where not between statement to the query.
13612
             *
13613
             * @param string $column
13614
             * @param array $values
13615
             * @param string $boolean
13616
             * @return \Illuminate\Database\Query\Builder|static 
13617
             * @static 
13618
             */ 
13619
            public static function whereNotBetween($column, $values, $boolean = 'and')
13620
            {    
13621
                return \Illuminate\Database\Query\Builder::whereNotBetween($column, $values, $boolean);
13622
            }
13623
         
13624
            /**
13625
             * Add an or where not between statement to the query.
13626
             *
13627
             * @param string $column
13628
             * @param array $values
13629
             * @return \Illuminate\Database\Query\Builder|static 
13630
             * @static 
13631
             */ 
13632
            public static function orWhereNotBetween($column, $values)
13633
            {    
13634
                return \Illuminate\Database\Query\Builder::orWhereNotBetween($column, $values);
13635
            }
13636
         
13637
            /**
13638
             * Add an "or where not null" clause to the query.
13639
             *
13640
             * @param string $column
13641
             * @return \Illuminate\Database\Query\Builder|static 
13642
             * @static 
13643
             */ 
13644
            public static function orWhereNotNull($column)
13645
            {    
13646
                return \Illuminate\Database\Query\Builder::orWhereNotNull($column);
13647
            }
13648
         
13649
            /**
13650
             * Add a "where date" statement to the query.
13651
             *
13652
             * @param string $column
13653
             * @param string $operator
13654
             * @param mixed $value
13655
             * @param string $boolean
13656
             * @return \Illuminate\Database\Query\Builder|static 
13657
             * @static 
13658
             */ 
13659
            public static function whereDate($column, $operator, $value = null, $boolean = 'and')
13660
            {    
13661
                return \Illuminate\Database\Query\Builder::whereDate($column, $operator, $value, $boolean);
13662
            }
13663
         
13664
            /**
13665
             * Add an "or where date" statement to the query.
13666
             *
13667
             * @param string $column
13668
             * @param string $operator
13669
             * @param string $value
13670
             * @return \Illuminate\Database\Query\Builder|static 
13671
             * @static 
13672
             */ 
13673
            public static function orWhereDate($column, $operator, $value)
13674
            {    
13675
                return \Illuminate\Database\Query\Builder::orWhereDate($column, $operator, $value);
13676
            }
13677
         
13678
            /**
13679
             * Add a "where time" statement to the query.
13680
             *
13681
             * @param string $column
13682
             * @param string $operator
13683
             * @param mixed $value
13684
             * @param string $boolean
13685
             * @return \Illuminate\Database\Query\Builder|static 
13686
             * @static 
13687
             */ 
13688
            public static function whereTime($column, $operator, $value = null, $boolean = 'and')
13689
            {    
13690
                return \Illuminate\Database\Query\Builder::whereTime($column, $operator, $value, $boolean);
13691
            }
13692
         
13693
            /**
13694
             * Add an "or where time" statement to the query.
13695
             *
13696
             * @param string $column
13697
             * @param string $operator
13698
             * @param mixed $value
13699
             * @return \Illuminate\Database\Query\Builder|static 
13700
             * @static 
13701
             */ 
13702
            public static function orWhereTime($column, $operator, $value = null)
13703
            {    
13704
                return \Illuminate\Database\Query\Builder::orWhereTime($column, $operator, $value);
13705
            }
13706
         
13707
            /**
13708
             * Add a "where day" statement to the query.
13709
             *
13710
             * @param string $column
13711
             * @param string $operator
13712
             * @param mixed $value
13713
             * @param string $boolean
13714
             * @return \Illuminate\Database\Query\Builder|static 
13715
             * @static 
13716
             */ 
13717
            public static function whereDay($column, $operator, $value = null, $boolean = 'and')
13718
            {    
13719
                return \Illuminate\Database\Query\Builder::whereDay($column, $operator, $value, $boolean);
13720
            }
13721
         
13722
            /**
13723
             * Add an "or where day" statement to the query.
13724
             *
13725
             * @param string $column
13726
             * @param string $operator
13727
             * @param mixed $value
13728
             * @return \Illuminate\Database\Query\Builder|static 
13729
             * @static 
13730
             */ 
13731
            public static function orWhereDay($column, $operator, $value = null)
13732
            {    
13733
                return \Illuminate\Database\Query\Builder::orWhereDay($column, $operator, $value);
13734
            }
13735
         
13736
            /**
13737
             * Add a "where month" statement to the query.
13738
             *
13739
             * @param string $column
13740
             * @param string $operator
13741
             * @param mixed $value
13742
             * @param string $boolean
13743
             * @return \Illuminate\Database\Query\Builder|static 
13744
             * @static 
13745
             */ 
13746
            public static function whereMonth($column, $operator, $value = null, $boolean = 'and')
13747
            {    
13748
                return \Illuminate\Database\Query\Builder::whereMonth($column, $operator, $value, $boolean);
13749
            }
13750
         
13751
            /**
13752
             * Add an "or where month" statement to the query.
13753
             *
13754
             * @param string $column
13755
             * @param string $operator
13756
             * @param mixed $value
13757
             * @return \Illuminate\Database\Query\Builder|static 
13758
             * @static 
13759
             */ 
13760
            public static function orWhereMonth($column, $operator, $value = null)
13761
            {    
13762
                return \Illuminate\Database\Query\Builder::orWhereMonth($column, $operator, $value);
13763
            }
13764
         
13765
            /**
13766
             * Add a "where year" statement to the query.
13767
             *
13768
             * @param string $column
13769
             * @param string $operator
13770
             * @param mixed $value
13771
             * @param string $boolean
13772
             * @return \Illuminate\Database\Query\Builder|static 
13773
             * @static 
13774
             */ 
13775
            public static function whereYear($column, $operator, $value = null, $boolean = 'and')
13776
            {    
13777
                return \Illuminate\Database\Query\Builder::whereYear($column, $operator, $value, $boolean);
13778
            }
13779
         
13780
            /**
13781
             * Add an "or where year" statement to the query.
13782
             *
13783
             * @param string $column
13784
             * @param string $operator
13785
             * @param mixed $value
13786
             * @return \Illuminate\Database\Query\Builder|static 
13787
             * @static 
13788
             */ 
13789
            public static function orWhereYear($column, $operator, $value = null)
13790
            {    
13791
                return \Illuminate\Database\Query\Builder::orWhereYear($column, $operator, $value);
13792
            }
13793
         
13794
            /**
13795
             * Add a nested where statement to the query.
13796
             *
13797
             * @param \Closure $callback
13798
             * @param string $boolean
13799
             * @return \Illuminate\Database\Query\Builder|static 
13800
             * @static 
13801
             */ 
13802
            public static function whereNested($callback, $boolean = 'and')
13803
            {    
13804
                return \Illuminate\Database\Query\Builder::whereNested($callback, $boolean);
13805
            }
13806
         
13807
            /**
13808
             * Create a new query instance for nested where condition.
13809
             *
13810
             * @return \Illuminate\Database\Query\Builder 
13811
             * @static 
13812
             */ 
13813
            public static function forNestedWhere()
13814
            {    
13815
                return \Illuminate\Database\Query\Builder::forNestedWhere();
13816
            }
13817
         
13818
            /**
13819
             * Add another query builder as a nested where to the query builder.
13820
             *
13821
             * @param \Illuminate\Database\Query\Builder|static $query
13822
             * @param string $boolean
13823
             * @return $this 
13824
             * @static 
13825
             */ 
13826
            public static function addNestedWhereQuery($query, $boolean = 'and')
13827
            {    
13828
                return \Illuminate\Database\Query\Builder::addNestedWhereQuery($query, $boolean);
13829
            }
13830
         
13831
            /**
13832
             * Add an exists clause to the query.
13833
             *
13834
             * @param \Closure $callback
13835
             * @param string $boolean
13836
             * @param bool $not
13837
             * @return $this 
13838
             * @static 
13839
             */ 
13840
            public static function whereExists($callback, $boolean = 'and', $not = false)
13841
            {    
13842
                return \Illuminate\Database\Query\Builder::whereExists($callback, $boolean, $not);
13843
            }
13844
         
13845
            /**
13846
             * Add an or exists clause to the query.
13847
             *
13848
             * @param \Closure $callback
13849
             * @param bool $not
13850
             * @return \Illuminate\Database\Query\Builder|static 
13851
             * @static 
13852
             */ 
13853
            public static function orWhereExists($callback, $not = false)
13854
            {    
13855
                return \Illuminate\Database\Query\Builder::orWhereExists($callback, $not);
13856
            }
13857
         
13858
            /**
13859
             * Add a where not exists clause to the query.
13860
             *
13861
             * @param \Closure $callback
13862
             * @param string $boolean
13863
             * @return \Illuminate\Database\Query\Builder|static 
13864
             * @static 
13865
             */ 
13866
            public static function whereNotExists($callback, $boolean = 'and')
13867
            {    
13868
                return \Illuminate\Database\Query\Builder::whereNotExists($callback, $boolean);
13869
            }
13870
         
13871
            /**
13872
             * Add a where not exists clause to the query.
13873
             *
13874
             * @param \Closure $callback
13875
             * @return \Illuminate\Database\Query\Builder|static 
13876
             * @static 
13877
             */ 
13878
            public static function orWhereNotExists($callback)
13879
            {    
13880
                return \Illuminate\Database\Query\Builder::orWhereNotExists($callback);
13881
            }
13882
         
13883
            /**
13884
             * Add an exists clause to the query.
13885
             *
13886
             * @param \Illuminate\Database\Query\Builder $query
13887
             * @param string $boolean
13888
             * @param bool $not
13889
             * @return $this 
13890
             * @static 
13891
             */ 
13892
            public static function addWhereExistsQuery($query, $boolean = 'and', $not = false)
13893
            {    
13894
                return \Illuminate\Database\Query\Builder::addWhereExistsQuery($query, $boolean, $not);
13895
            }
13896
         
13897
            /**
13898
             * Adds a where condition using row values.
13899
             *
13900
             * @param array $columns
13901
             * @param string $operator
13902
             * @param array $values
13903
             * @param string $boolean
13904
             * @return $this 
13905
             * @static 
13906
             */ 
13907
            public static function whereRowValues($columns, $operator, $values, $boolean = 'and')
13908
            {    
13909
                return \Illuminate\Database\Query\Builder::whereRowValues($columns, $operator, $values, $boolean);
13910
            }
13911
         
13912
            /**
13913
             * Adds a or where condition using row values.
13914
             *
13915
             * @param array $columns
13916
             * @param string $operator
13917
             * @param array $values
13918
             * @return $this 
13919
             * @static 
13920
             */ 
13921
            public static function orWhereRowValues($columns, $operator, $values)
13922
            {    
13923
                return \Illuminate\Database\Query\Builder::orWhereRowValues($columns, $operator, $values);
13924
            }
13925
         
13926
            /**
13927
             * Handles dynamic "where" clauses to the query.
13928
             *
13929
             * @param string $method
13930
             * @param string $parameters
13931
             * @return $this 
13932
             * @static 
13933
             */ 
13934
            public static function dynamicWhere($method, $parameters)
13935
            {    
13936
                return \Illuminate\Database\Query\Builder::dynamicWhere($method, $parameters);
13937
            }
13938
         
13939
            /**
13940
             * Add a "group by" clause to the query.
13941
             *
13942
             * @param array $groups
13943
             * @return $this 
13944
             * @static 
13945
             */ 
13946
            public static function groupBy($groups = null)
13947
            {    
13948
                return \Illuminate\Database\Query\Builder::groupBy($groups);
13949
            }
13950
         
13951
            /**
13952
             * Add a "having" clause to the query.
13953
             *
13954
             * @param string $column
13955
             * @param string|null $operator
13956
             * @param string|null $value
13957
             * @param string $boolean
13958
             * @return $this 
13959
             * @static 
13960
             */ 
13961
            public static function having($column, $operator = null, $value = null, $boolean = 'and')
13962
            {    
13963
                return \Illuminate\Database\Query\Builder::having($column, $operator, $value, $boolean);
13964
            }
13965
         
13966
            /**
13967
             * Add a "or having" clause to the query.
13968
             *
13969
             * @param string $column
13970
             * @param string|null $operator
13971
             * @param string|null $value
13972
             * @return \Illuminate\Database\Query\Builder|static 
13973
             * @static 
13974
             */ 
13975
            public static function orHaving($column, $operator = null, $value = null)
13976
            {    
13977
                return \Illuminate\Database\Query\Builder::orHaving($column, $operator, $value);
13978
            }
13979
         
13980
            /**
13981
             * Add a raw having clause to the query.
13982
             *
13983
             * @param string $sql
13984
             * @param array $bindings
13985
             * @param string $boolean
13986
             * @return $this 
13987
             * @static 
13988
             */ 
13989
            public static function havingRaw($sql, $bindings = array(), $boolean = 'and')
13990
            {    
13991
                return \Illuminate\Database\Query\Builder::havingRaw($sql, $bindings, $boolean);
13992
            }
13993
         
13994
            /**
13995
             * Add a raw or having clause to the query.
13996
             *
13997
             * @param string $sql
13998
             * @param array $bindings
13999
             * @return \Illuminate\Database\Query\Builder|static 
14000
             * @static 
14001
             */ 
14002
            public static function orHavingRaw($sql, $bindings = array())
14003
            {    
14004
                return \Illuminate\Database\Query\Builder::orHavingRaw($sql, $bindings);
14005
            }
14006
         
14007
            /**
14008
             * Add an "order by" clause to the query.
14009
             *
14010
             * @param string $column
14011
             * @param string $direction
14012
             * @return $this 
14013
             * @static 
14014
             */ 
14015
            public static function orderBy($column, $direction = 'asc')
14016
            {    
14017
                return \Illuminate\Database\Query\Builder::orderBy($column, $direction);
14018
            }
14019
         
14020
            /**
14021
             * Add a descending "order by" clause to the query.
14022
             *
14023
             * @param string $column
14024
             * @return $this 
14025
             * @static 
14026
             */ 
14027
            public static function orderByDesc($column)
14028
            {    
14029
                return \Illuminate\Database\Query\Builder::orderByDesc($column);
14030
            }
14031
         
14032
            /**
14033
             * Add an "order by" clause for a timestamp to the query.
14034
             *
14035
             * @param string $column
14036
             * @return \Illuminate\Database\Query\Builder|static 
14037
             * @static 
14038
             */ 
14039
            public static function latest($column = 'created_at')
14040
            {    
14041
                return \Illuminate\Database\Query\Builder::latest($column);
14042
            }
14043
         
14044
            /**
14045
             * Add an "order by" clause for a timestamp to the query.
14046
             *
14047
             * @param string $column
14048
             * @return \Illuminate\Database\Query\Builder|static 
14049
             * @static 
14050
             */ 
14051
            public static function oldest($column = 'created_at')
14052
            {    
14053
                return \Illuminate\Database\Query\Builder::oldest($column);
14054
            }
14055
         
14056
            /**
14057
             * Put the query's results in random order.
14058
             *
14059
             * @param string $seed
14060
             * @return $this 
14061
             * @static 
14062
             */ 
14063
            public static function inRandomOrder($seed = '')
14064
            {    
14065
                return \Illuminate\Database\Query\Builder::inRandomOrder($seed);
14066
            }
14067
         
14068
            /**
14069
             * Add a raw "order by" clause to the query.
14070
             *
14071
             * @param string $sql
14072
             * @param array $bindings
14073
             * @return $this 
14074
             * @static 
14075
             */ 
14076
            public static function orderByRaw($sql, $bindings = array())
14077
            {    
14078
                return \Illuminate\Database\Query\Builder::orderByRaw($sql, $bindings);
14079
            }
14080
         
14081
            /**
14082
             * Alias to set the "offset" value of the query.
14083
             *
14084
             * @param int $value
14085
             * @return \Illuminate\Database\Query\Builder|static 
14086
             * @static 
14087
             */ 
14088
            public static function skip($value)
14089
            {    
14090
                return \Illuminate\Database\Query\Builder::skip($value);
14091
            }
14092
         
14093
            /**
14094
             * Set the "offset" value of the query.
14095
             *
14096
             * @param int $value
14097
             * @return $this 
14098
             * @static 
14099
             */ 
14100
            public static function offset($value)
14101
            {    
14102
                return \Illuminate\Database\Query\Builder::offset($value);
14103
            }
14104
         
14105
            /**
14106
             * Alias to set the "limit" value of the query.
14107
             *
14108
             * @param int $value
14109
             * @return \Illuminate\Database\Query\Builder|static 
14110
             * @static 
14111
             */ 
14112
            public static function take($value)
14113
            {    
14114
                return \Illuminate\Database\Query\Builder::take($value);
14115
            }
14116
         
14117
            /**
14118
             * Set the "limit" value of the query.
14119
             *
14120
             * @param int $value
14121
             * @return $this 
14122
             * @static 
14123
             */ 
14124
            public static function limit($value)
14125
            {    
14126
                return \Illuminate\Database\Query\Builder::limit($value);
14127
            }
14128
         
14129
            /**
14130
             * Set the limit and offset for a given page.
14131
             *
14132
             * @param int $page
14133
             * @param int $perPage
14134
             * @return \Illuminate\Database\Query\Builder|static 
14135
             * @static 
14136
             */ 
14137
            public static function forPage($page, $perPage = 15)
14138
            {    
14139
                return \Illuminate\Database\Query\Builder::forPage($page, $perPage);
14140
            }
14141
         
14142
            /**
14143
             * Constrain the query to the next "page" of results after a given ID.
14144
             *
14145
             * @param int $perPage
14146
             * @param int $lastId
14147
             * @param string $column
14148
             * @return \Illuminate\Database\Query\Builder|static 
14149
             * @static 
14150
             */ 
14151
            public static function forPageAfterId($perPage = 15, $lastId = 0, $column = 'id')
14152
            {    
14153
                return \Illuminate\Database\Query\Builder::forPageAfterId($perPage, $lastId, $column);
14154
            }
14155
         
14156
            /**
14157
             * Add a union statement to the query.
14158
             *
14159
             * @param \Illuminate\Database\Query\Builder|\Closure $query
14160
             * @param bool $all
14161
             * @return \Illuminate\Database\Query\Builder|static 
14162
             * @static 
14163
             */ 
14164
            public static function union($query, $all = false)
14165
            {    
14166
                return \Illuminate\Database\Query\Builder::union($query, $all);
14167
            }
14168
         
14169
            /**
14170
             * Add a union all statement to the query.
14171
             *
14172
             * @param \Illuminate\Database\Query\Builder|\Closure $query
14173
             * @return \Illuminate\Database\Query\Builder|static 
14174
             * @static 
14175
             */ 
14176
            public static function unionAll($query)
14177
            {    
14178
                return \Illuminate\Database\Query\Builder::unionAll($query);
14179
            }
14180
         
14181
            /**
14182
             * Lock the selected rows in the table.
14183
             *
14184
             * @param string|bool $value
14185
             * @return $this 
14186
             * @static 
14187
             */ 
14188
            public static function lock($value = true)
14189
            {    
14190
                return \Illuminate\Database\Query\Builder::lock($value);
14191
            }
14192
         
14193
            /**
14194
             * Lock the selected rows in the table for updating.
14195
             *
14196
             * @return \Illuminate\Database\Query\Builder 
14197
             * @static 
14198
             */ 
14199
            public static function lockForUpdate()
14200
            {    
14201
                return \Illuminate\Database\Query\Builder::lockForUpdate();
14202
            }
14203
         
14204
            /**
14205
             * Share lock the selected rows in the table.
14206
             *
14207
             * @return \Illuminate\Database\Query\Builder 
14208
             * @static 
14209
             */ 
14210
            public static function sharedLock()
14211
            {    
14212
                return \Illuminate\Database\Query\Builder::sharedLock();
14213
            }
14214
         
14215
            /**
14216
             * Get the SQL representation of the query.
14217
             *
14218
             * @return string 
14219
             * @static 
14220
             */ 
14221
            public static function toSql()
14222
            {    
14223
                return \Illuminate\Database\Query\Builder::toSql();
14224
            }
14225
         
14226
            /**
14227
             * Get the count of the total records for the paginator.
14228
             *
14229
             * @param array $columns
14230
             * @return int 
14231
             * @static 
14232
             */ 
14233
            public static function getCountForPagination($columns = array())
14234
            {    
14235
                return \Illuminate\Database\Query\Builder::getCountForPagination($columns);
14236
            }
14237
         
14238
            /**
14239
             * Concatenate values of a given column as a string.
14240
             *
14241
             * @param string $column
14242
             * @param string $glue
14243
             * @return string 
14244
             * @static 
14245
             */ 
14246
            public static function implode($column, $glue = '')
14247
            {    
14248
                return \Illuminate\Database\Query\Builder::implode($column, $glue);
14249
            }
14250
         
14251
            /**
14252
             * Determine if any rows exist for the current query.
14253
             *
14254
             * @return bool 
14255
             * @static 
14256
             */ 
14257
            public static function exists()
14258
            {    
14259
                return \Illuminate\Database\Query\Builder::exists();
14260
            }
14261
         
14262
            /**
14263
             * Determine if no rows exist for the current query.
14264
             *
14265
             * @return bool 
14266
             * @static 
14267
             */ 
14268
            public static function doesntExist()
14269
            {    
14270
                return \Illuminate\Database\Query\Builder::doesntExist();
14271
            }
14272
         
14273
            /**
14274
             * Retrieve the "count" result of the query.
14275
             *
14276
             * @param string $columns
14277
             * @return int 
14278
             * @static 
14279
             */ 
14280
            public static function count($columns = '*')
14281
            {    
14282
                return \Illuminate\Database\Query\Builder::count($columns);
14283
            }
14284
         
14285
            /**
14286
             * Retrieve the minimum value of a given column.
14287
             *
14288
             * @param string $column
14289
             * @return mixed 
14290
             * @static 
14291
             */ 
14292
            public static function min($column)
14293
            {    
14294
                return \Illuminate\Database\Query\Builder::min($column);
14295
            }
14296
         
14297
            /**
14298
             * Retrieve the maximum value of a given column.
14299
             *
14300
             * @param string $column
14301
             * @return mixed 
14302
             * @static 
14303
             */ 
14304
            public static function max($column)
14305
            {    
14306
                return \Illuminate\Database\Query\Builder::max($column);
14307
            }
14308
         
14309
            /**
14310
             * Retrieve the sum of the values of a given column.
14311
             *
14312
             * @param string $column
14313
             * @return mixed 
14314
             * @static 
14315
             */ 
14316
            public static function sum($column)
14317
            {    
14318
                return \Illuminate\Database\Query\Builder::sum($column);
14319
            }
14320
         
14321
            /**
14322
             * Retrieve the average of the values of a given column.
14323
             *
14324
             * @param string $column
14325
             * @return mixed 
14326
             * @static 
14327
             */ 
14328
            public static function avg($column)
14329
            {    
14330
                return \Illuminate\Database\Query\Builder::avg($column);
14331
            }
14332
         
14333
            /**
14334
             * Alias for the "avg" method.
14335
             *
14336
             * @param string $column
14337
             * @return mixed 
14338
             * @static 
14339
             */ 
14340
            public static function average($column)
14341
            {    
14342
                return \Illuminate\Database\Query\Builder::average($column);
14343
            }
14344
         
14345
            /**
14346
             * Execute an aggregate function on the database.
14347
             *
14348
             * @param string $function
14349
             * @param array $columns
14350
             * @return mixed 
14351
             * @static 
14352
             */ 
14353
            public static function aggregate($function, $columns = array())
14354
            {    
14355
                return \Illuminate\Database\Query\Builder::aggregate($function, $columns);
14356
            }
14357
         
14358
            /**
14359
             * Execute a numeric aggregate function on the database.
14360
             *
14361
             * @param string $function
14362
             * @param array $columns
14363
             * @return float|int 
14364
             * @static 
14365
             */ 
14366
            public static function numericAggregate($function, $columns = array())
14367
            {    
14368
                return \Illuminate\Database\Query\Builder::numericAggregate($function, $columns);
14369
            }
14370
         
14371
            /**
14372
             * Insert a new record into the database.
14373
             *
14374
             * @param array $values
14375
             * @return bool 
14376
             * @static 
14377
             */ 
14378
            public static function insert($values)
14379
            {    
14380
                return \Illuminate\Database\Query\Builder::insert($values);
14381
            }
14382
         
14383
            /**
14384
             * Insert a new record and get the value of the primary key.
14385
             *
14386
             * @param array $values
14387
             * @param string|null $sequence
14388
             * @return int 
14389
             * @static 
14390
             */ 
14391
            public static function insertGetId($values, $sequence = null)
14392
            {    
14393
                return \Illuminate\Database\Query\Builder::insertGetId($values, $sequence);
14394
            }
14395
         
14396
            /**
14397
             * Insert or update a record matching the attributes, and fill it with values.
14398
             *
14399
             * @param array $attributes
14400
             * @param array $values
14401
             * @return bool 
14402
             * @static 
14403
             */ 
14404
            public static function updateOrInsert($attributes, $values = array())
14405
            {    
14406
                return \Illuminate\Database\Query\Builder::updateOrInsert($attributes, $values);
14407
            }
14408
         
14409
            /**
14410
             * Run a truncate statement on the table.
14411
             *
14412
             * @return void 
14413
             * @static 
14414
             */ 
14415
            public static function truncate()
14416
            {    
14417
                \Illuminate\Database\Query\Builder::truncate();
14418
            }
14419
         
14420
            /**
14421
             * Create a raw database expression.
14422
             *
14423
             * @param mixed $value
14424
             * @return \Illuminate\Database\Query\Expression 
14425
             * @static 
14426
             */ 
14427
            public static function raw($value)
14428
            {    
14429
                return \Illuminate\Database\Query\Builder::raw($value);
14430
            }
14431
         
14432
            /**
14433
             * Get the current query value bindings in a flattened array.
14434
             *
14435
             * @return array 
14436
             * @static 
14437
             */ 
14438
            public static function getBindings()
14439
            {    
14440
                return \Illuminate\Database\Query\Builder::getBindings();
14441
            }
14442
         
14443
            /**
14444
             * Get the raw array of bindings.
14445
             *
14446
             * @return array 
14447
             * @static 
14448
             */ 
14449
            public static function getRawBindings()
14450
            {    
14451
                return \Illuminate\Database\Query\Builder::getRawBindings();
14452
            }
14453
         
14454
            /**
14455
             * Set the bindings on the query builder.
14456
             *
14457
             * @param array $bindings
14458
             * @param string $type
14459
             * @return $this 
14460
             * @throws \InvalidArgumentException
14461
             * @static 
14462
             */ 
14463
            public static function setBindings($bindings, $type = 'where')
14464
            {    
14465
                return \Illuminate\Database\Query\Builder::setBindings($bindings, $type);
14466
            }
14467
         
14468
            /**
14469
             * Add a binding to the query.
14470
             *
14471
             * @param mixed $value
14472
             * @param string $type
14473
             * @return $this 
14474
             * @throws \InvalidArgumentException
14475
             * @static 
14476
             */ 
14477
            public static function addBinding($value, $type = 'where')
14478
            {    
14479
                return \Illuminate\Database\Query\Builder::addBinding($value, $type);
14480
            }
14481
         
14482
            /**
14483
             * Merge an array of bindings into our bindings.
14484
             *
14485
             * @param \Illuminate\Database\Query\Builder $query
14486
             * @return $this 
14487
             * @static 
14488
             */ 
14489
            public static function mergeBindings($query)
14490
            {    
14491
                return \Illuminate\Database\Query\Builder::mergeBindings($query);
14492
            }
14493
         
14494
            /**
14495
             * Get the database query processor instance.
14496
             *
14497
             * @return \Illuminate\Database\Query\Processors\Processor 
14498
             * @static 
14499
             */ 
14500
            public static function getProcessor()
14501
            {    
14502
                return \Illuminate\Database\Query\Builder::getProcessor();
14503
            }
14504
         
14505
            /**
14506
             * Get the query grammar instance.
14507
             *
14508
             * @return \Illuminate\Database\Query\Grammars\Grammar 
14509
             * @static 
14510
             */ 
14511
            public static function getGrammar()
14512
            {    
14513
                return \Illuminate\Database\Query\Builder::getGrammar();
14514
            }
14515
         
14516
            /**
14517
             * Use the write pdo for query.
14518
             *
14519
             * @return $this 
14520
             * @static 
14521
             */ 
14522
            public static function useWritePdo()
14523
            {    
14524
                return \Illuminate\Database\Query\Builder::useWritePdo();
14525
            }
14526
         
14527
            /**
14528
             * Clone the query without the given properties.
14529
             *
14530
             * @param array $properties
14531
             * @return static 
14532
             * @static 
14533
             */ 
14534
            public static function cloneWithout($properties)
14535
            {    
14536
                return \Illuminate\Database\Query\Builder::cloneWithout($properties);
14537
            }
14538
         
14539
            /**
14540
             * Clone the query without the given bindings.
14541
             *
14542
             * @param array $except
14543
             * @return static 
14544
             * @static 
14545
             */ 
14546
            public static function cloneWithoutBindings($except)
14547
            {    
14548
                return \Illuminate\Database\Query\Builder::cloneWithoutBindings($except);
14549
            }
14550
         
14551
            /**
14552
             * Register a custom macro.
14553
             *
14554
             * @param string $name
14555
             * @param object|callable $macro
14556
             * @return void 
14557
             * @static 
14558
             */ 
14559
            public static function macro($name, $macro)
14560
            {    
14561
                \Illuminate\Database\Query\Builder::macro($name, $macro);
14562
            }
14563
         
14564
            /**
14565
             * Mix another object into the class.
14566
             *
14567
             * @param object $mixin
14568
             * @return void 
14569
             * @static 
14570
             */ 
14571
            public static function mixin($mixin)
14572
            {    
14573
                \Illuminate\Database\Query\Builder::mixin($mixin);
14574
            }
14575
         
14576
            /**
14577
             * Checks if macro is registered.
14578
             *
14579
             * @param string $name
14580
             * @return bool 
14581
             * @static 
14582
             */ 
14583
            public static function hasMacro($name)
14584
            {    
14585
                return \Illuminate\Database\Query\Builder::hasMacro($name);
14586
            }
14587
         
14588
            /**
14589
             * Dynamically handle calls to the class.
14590
             *
14591
             * @param string $method
14592
             * @param array $parameters
14593
             * @return mixed 
14594
             * @throws \BadMethodCallException
14595
             * @static 
14596
             */ 
14597
            public static function macroCall($method, $parameters)
14598
            {    
14599
                return \Illuminate\Database\Query\Builder::macroCall($method, $parameters);
14600
            }
14601
        }
14602

14603
    class Event extends \Illuminate\Support\Facades\Event {}
14604

14605
    class File extends \Illuminate\Support\Facades\File {}
14606

14607
    class Gate extends \Illuminate\Support\Facades\Gate {}
14608

14609
    class Hash extends \Illuminate\Support\Facades\Hash {}
14610

14611
    class Lang extends \Illuminate\Support\Facades\Lang {}
14612

14613
    class Log extends \Illuminate\Support\Facades\Log {}
14614

14615
    class Mail extends \Illuminate\Support\Facades\Mail {}
14616

14617
    class Notification extends \Illuminate\Support\Facades\Notification {}
14618

14619
    class Password extends \Illuminate\Support\Facades\Password {}
14620

14621
    class Queue extends \Illuminate\Support\Facades\Queue {}
14622

14623
    class Redirect extends \Illuminate\Support\Facades\Redirect {}
14624

14625
    class Request extends \Illuminate\Support\Facades\Request {}
14626

14627
    class Response extends \Illuminate\Support\Facades\Response {}
14628

14629
    class Route extends \Illuminate\Support\Facades\Route {}
14630

14631
    class Schema extends \Illuminate\Support\Facades\Schema {}
14632

14633
    class Session extends \Illuminate\Support\Facades\Session {}
14634

14635
    class Storage extends \Illuminate\Support\Facades\Storage {}
14636

14637
    class URL extends \Illuminate\Support\Facades\URL {}
14638

14639
    class Validator extends \Illuminate\Support\Facades\Validator {}
14640

14641
    class View extends \Illuminate\Support\Facades\View {}
14642
 
14643
}
14644

14645

14646

14647