/_ide_helper.php

Large files files are truncated, but you can click here to view the full file

<?php
/**
 * An helper file for Laravel 4, to provide autocomplete information to your IDE
 * Generated with https://github.com/barryvdh/laravel-ide-helper
 * Updated for Laravel 4.2.1 (2014-06-01)
 *
 * @author Barry vd. Heuvel <barryvdh@gmail.com>
 */

namespace {
	exit('Only to be used as an helper for your IDE');

	class App extends \Illuminate\Support\Facades\App{
		/**
		 * Create a new Illuminate application instance.
		 *
		 * @param \Illuminate\Http\Request
		 * @return void
		 * @static 
		 */
		 public static function __construct($request = null){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::__construct($request);
		 }

		/**
		 * Bind the installation paths to the application.
		 *
		 * @param array  $paths
		 * @return void
		 * @static 
		 */
		 public static function bindInstallPaths($paths){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::bindInstallPaths($paths);
		 }

		/**
		 * Get the application bootstrap file.
		 *
		 * @return string
		 * @static 
		 */
		 public static function getBootstrapFile(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::getBootstrapFile();
		 }

		/**
		 * Start the exception handling for the request.
		 *
		 * @return void
		 * @static 
		 */
		 public static function startExceptionHandling(){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::startExceptionHandling();
		 }

		/**
		 * Get or check the current application environment.
		 *
		 * @param dynamic
		 * @return string
		 * @static 
		 */
		 public static function environment(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::environment();
		 }

		/**
		 * Determine if application is in local environment.
		 *
		 * @return bool
		 * @static 
		 */
		 public static function isLocal(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::isLocal();
		 }

		/**
		 * Detect the application's current environment.
		 *
		 * @param array|string  $envs
		 * @return string
		 * @static 
		 */
		 public static function detectEnvironment($envs){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::detectEnvironment($envs);
		 }

		/**
		 * Determine if we are running in the console.
		 *
		 * @return bool
		 * @static 
		 */
		 public static function runningInConsole(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::runningInConsole();
		 }

		/**
		 * Determine if we are running unit tests.
		 *
		 * @return bool
		 * @static 
		 */
		 public static function runningUnitTests(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::runningUnitTests();
		 }

		/**
		 * Force register a service provider with the application.
		 *
		 * @param \Illuminate\Support\ServiceProvider|string  $provider
		 * @param array  $options
		 * @return \Illuminate\Support\ServiceProvider
		 * @static 
		 */
		 public static function forceRegister($provider, $options = array()){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::forceRegister($provider, $options);
		 }

		/**
		 * Register a service provider with the application.
		 *
		 * @param \Illuminate\Support\ServiceProvider|string  $provider
		 * @param array  $options
		 * @param bool   $force
		 * @return \Illuminate\Support\ServiceProvider
		 * @static 
		 */
		 public static function register($provider, $options = array(), $force = false){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::register($provider, $options, $force);
		 }

		/**
		 * Get the registered service provider instance if it exists.
		 *
		 * @param \Illuminate\Support\ServiceProvider|string  $provider
		 * @return \Illuminate\Support\ServiceProvider|null
		 * @static 
		 */
		 public static function getRegistered($provider){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::getRegistered($provider);
		 }

		/**
		 * Resolve a service provider instance from the class name.
		 *
		 * @param string  $provider
		 * @return \Illuminate\Support\ServiceProvider
		 * @static 
		 */
		 public static function resolveProviderClass($provider){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::resolveProviderClass($provider);
		 }

		/**
		 * Load and boot all of the remaining deferred providers.
		 *
		 * @return void
		 * @static 
		 */
		 public static function loadDeferredProviders(){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::loadDeferredProviders();
		 }

		/**
		 * Register a deferred provider and service.
		 *
		 * @param string  $provider
		 * @param string  $service
		 * @return void
		 * @static 
		 */
		 public static function registerDeferredProvider($provider, $service = null){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::registerDeferredProvider($provider, $service);
		 }

		/**
		 * Resolve the given type from the container.
		 * 
		 * (Overriding Container::make)
		 *
		 * @param string  $abstract
		 * @param array   $parameters
		 * @return mixed
		 * @static 
		 */
		 public static function make($abstract, $parameters = array()){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::make($abstract, $parameters);
		 }

		/**
		 * Register a "before" application filter.
		 *
		 * @param Closure|string  $callback
		 * @return void
		 * @static 
		 */
		 public static function before($callback){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::before($callback);
		 }

		/**
		 * Register an "after" application filter.
		 *
		 * @param Closure|string  $callback
		 * @return void
		 * @static 
		 */
		 public static function after($callback){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::after($callback);
		 }

		/**
		 * Register a "finish" application filter.
		 *
		 * @param Closure|string  $callback
		 * @return void
		 * @static 
		 */
		 public static function finish($callback){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::finish($callback);
		 }

		/**
		 * Register a "shutdown" callback.
		 *
		 * @param callable  $callback
		 * @return void
		 * @static 
		 */
		 public static function shutdown($callback = null){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::shutdown($callback);
		 }

		/**
		 * Register a function for determining when to use array sessions.
		 *
		 * @param \Closure  $callback
		 * @return void
		 * @static 
		 */
		 public static function useArraySessions($callback){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::useArraySessions($callback);
		 }

		/**
		 * Determine if the application has booted.
		 *
		 * @return bool
		 * @static 
		 */
		 public static function isBooted(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::isBooted();
		 }

		/**
		 * Boot the application's service providers.
		 *
		 * @return void
		 * @static 
		 */
		 public static function boot(){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::boot();
		 }

		/**
		 * Register a new boot listener.
		 *
		 * @param mixed  $callback
		 * @return void
		 * @static 
		 */
		 public static function booting($callback){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::booting($callback);
		 }

		/**
		 * Register a new "booted" listener.
		 *
		 * @param mixed  $callback
		 * @return void
		 * @static 
		 */
		 public static function booted($callback){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::booted($callback);
		 }

		/**
		 * Run the application and send the response.
		 *
		 * @param \Symfony\Component\HttpFoundation\Request  $request
		 * @return void
		 * @static 
		 */
		 public static function run($request = null){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::run($request);
		 }

		/**
		 * Add a HttpKernel middleware onto the stack.
		 *
		 * @param string  $class
		 * @param array  $parameters
		 * @return \Illuminate\Foundation\Application
		 * @static 
		 */
		 public static function middleware($class, $parameters = array()){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::middleware($class, $parameters);
		 }

		/**
		 * Remove a custom middleware from the application.
		 *
		 * @param string  $class
		 * @return void
		 * @static 
		 */
		 public static function forgetMiddleware($class){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::forgetMiddleware($class);
		 }

		/**
		 * Handle the given request and get the response.
		 * 
		 * Provides compatibility with BrowserKit functional testing.
		 *
		 * @implements HttpKernelInterface::handle
		 * @param \Symfony\Component\HttpFoundation\Request  $request
		 * @param int   $type
		 * @param bool  $catch
		 * @return \Symfony\Component\HttpFoundation\Response
		 * @static 
		 */
		 public static function handle($request, $type = 1, $catch = true){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::handle($request, $type, $catch);
		 }

		/**
		 * Handle the given request and get the response.
		 *
		 * @param \Illuminate\Http\Request  $request
		 * @return \Symfony\Component\HttpFoundation\Response
		 * @static 
		 */
		 public static function dispatch($request){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::dispatch($request);
		 }

		/**
		 * Terminate the request and send the response to the browser.
		 *
		 * @param \Symfony\Component\HttpFoundation\Request  $request
		 * @param \Symfony\Component\HttpFoundation\Response  $response
		 * @return void
		 * @static 
		 */
		 public static function terminate($request, $response){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::terminate($request, $response);
		 }

		/**
		 * Call the "finish" callbacks assigned to the application.
		 *
		 * @param \Symfony\Component\HttpFoundation\Request  $request
		 * @param \Symfony\Component\HttpFoundation\Response  $response
		 * @return void
		 * @static 
		 */
		 public static function callFinishCallbacks($request, $response){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::callFinishCallbacks($request, $response);
		 }

		/**
		 * Prepare the request by injecting any services.
		 *
		 * @param \Illuminate\Http\Request  $request
		 * @return \Illuminate\Http\Request
		 * @static 
		 */
		 public static function prepareRequest($request){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::prepareRequest($request);
		 }

		/**
		 * Prepare the given value as a Response object.
		 *
		 * @param mixed  $value
		 * @return \Symfony\Component\HttpFoundation\Response
		 * @static 
		 */
		 public static function prepareResponse($value){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::prepareResponse($value);
		 }

		/**
		 * Determine if the application is ready for responses.
		 *
		 * @return bool
		 * @static 
		 */
		 public static function readyForResponses(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::readyForResponses();
		 }

		/**
		 * Determine if the application is currently down for maintenance.
		 *
		 * @return bool
		 * @static 
		 */
		 public static function isDownForMaintenance(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::isDownForMaintenance();
		 }

		/**
		 * Register a maintenance mode event listener.
		 *
		 * @param \Closure  $callback
		 * @return void
		 * @static 
		 */
		 public static function down($callback){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::down($callback);
		 }

		/**
		 * Throw an HttpException with the given data.
		 *
		 * @param int     $code
		 * @param string  $message
		 * @param array   $headers
		 * @return void
		 * @throws \Symfony\Component\HttpKernel\Exception\HttpException
		 * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
		 * @static 
		 */
		 public static function abort($code, $message = '', $headers = array()){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::abort($code, $message, $headers);
		 }

		/**
		 * Register a 404 error handler.
		 *
		 * @param Closure  $callback
		 * @return void
		 * @static 
		 */
		 public static function missing($callback){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::missing($callback);
		 }

		/**
		 * Register an application error handler.
		 *
		 * @param \Closure  $callback
		 * @return void
		 * @static 
		 */
		 public static function error($callback){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::error($callback);
		 }

		/**
		 * Register an error handler at the bottom of the stack.
		 *
		 * @param \Closure  $callback
		 * @return void
		 * @static 
		 */
		 public static function pushError($callback){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::pushError($callback);
		 }

		/**
		 * Register an error handler for fatal errors.
		 *
		 * @param Closure  $callback
		 * @return void
		 * @static 
		 */
		 public static function fatal($callback){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::fatal($callback);
		 }

		/**
		 * Get the configuration loader instance.
		 *
		 * @return \Illuminate\Config\LoaderInterface
		 * @static 
		 */
		 public static function getConfigLoader(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::getConfigLoader();
		 }

		/**
		 * Get the environment variables loader instance.
		 *
		 * @return \Illuminate\Config\EnvironmentVariablesLoaderInterface
		 * @static 
		 */
		 public static function getEnvironmentVariablesLoader(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::getEnvironmentVariablesLoader();
		 }

		/**
		 * Get the service provider repository instance.
		 *
		 * @return \Illuminate\Foundation\ProviderRepository
		 * @static 
		 */
		 public static function getProviderRepository(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::getProviderRepository();
		 }

		/**
		 * Get the service providers that have been loaded.
		 *
		 * @return array
		 * @static 
		 */
		 public static function getLoadedProviders(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::getLoadedProviders();
		 }

		/**
		 * Set the application's deferred services.
		 *
		 * @param array  $services
		 * @return void
		 * @static 
		 */
		 public static function setDeferredServices($services){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::setDeferredServices($services);
		 }

		/**
		 * Determine if the given service is a deferred service.
		 *
		 * @param string  $service
		 * @return bool
		 * @static 
		 */
		 public static function isDeferredService($service){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::isDeferredService($service);
		 }

		/**
		 * Get or set the request class for the application.
		 *
		 * @param string  $class
		 * @return string
		 * @static 
		 */
		 public static function requestClass($class = null){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::requestClass($class);
		 }

		/**
		 * Set the application request for the console environment.
		 *
		 * @return void
		 * @static 
		 */
		 public static function setRequestForConsoleEnvironment(){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::setRequestForConsoleEnvironment();
		 }

		/**
		 * Call a method on the default request class.
		 *
		 * @param string  $method
		 * @param array  $parameters
		 * @return mixed
		 * @static 
		 */
		 public static function onRequest($method, $parameters = array()){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::onRequest($method, $parameters);
		 }

		/**
		 * Get the current application locale.
		 *
		 * @return string
		 * @static 
		 */
		 public static function getLocale(){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::getLocale();
		 }

		/**
		 * Set the current application locale.
		 *
		 * @param string  $locale
		 * @return void
		 * @static 
		 */
		 public static function setLocale($locale){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::setLocale($locale);
		 }

		/**
		 * Register the core class aliases in the container.
		 *
		 * @return void
		 * @static 
		 */
		 public static function registerCoreContainerAliases(){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::registerCoreContainerAliases();
		 }

		/**
		 * Dynamically access application services.
		 *
		 * @param string  $key
		 * @return mixed
		 * @static 
		 */
		 public static function __get($key){
			//Method inherited from \Illuminate\Foundation\Application
			return \Illuminate\Foundation\Application::__get($key);
		 }

		/**
		 * Dynamically set application services.
		 *
		 * @param string  $key
		 * @param mixed   $value
		 * @return void
		 * @static 
		 */
		 public static function __set($key, $value){
			//Method inherited from \Illuminate\Foundation\Application
			 \Illuminate\Foundation\Application::__set($key, $value);
		 }

		/**
		 * Determine if the given abstract type has been bound.
		 *
		 * @param string  $abstract
		 * @return bool
		 * @static 
		 */
		 public static function bound($abstract){
			//Method inherited from \Illuminate\Container\Container
			return \Illuminate\Foundation\Application::bound($abstract);
		 }

		/**
		 * Determine if a given string is an alias.
		 *
		 * @param string  $name
		 * @return bool
		 * @static 
		 */
		 public static function isAlias($name){
			//Method inherited from \Illuminate\Container\Container
			return \Illuminate\Foundation\Application::isAlias($name);
		 }

		/**
		 * Register a binding with the container.
		 *
		 * @param string               $abstract
		 * @param Closure|string|null  $concrete
		 * @param bool                 $shared
		 * @return void
		 * @static 
		 */
		 public static function bind($abstract, $concrete = null, $shared = false){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::bind($abstract, $concrete, $shared);
		 }

		/**
		 * Register a binding if it hasn't already been registered.
		 *
		 * @param string               $abstract
		 * @param Closure|string|null  $concrete
		 * @param bool                 $shared
		 * @return bool
		 * @static 
		 */
		 public static function bindIf($abstract, $concrete = null, $shared = false){
			//Method inherited from \Illuminate\Container\Container
			return \Illuminate\Foundation\Application::bindIf($abstract, $concrete, $shared);
		 }

		/**
		 * Register a shared binding in the container.
		 *
		 * @param string               $abstract
		 * @param Closure|string|null  $concrete
		 * @return void
		 * @static 
		 */
		 public static function singleton($abstract, $concrete = null){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::singleton($abstract, $concrete);
		 }

		/**
		 * Wrap a Closure such that it is shared.
		 *
		 * @param Closure  $closure
		 * @return Closure
		 * @static 
		 */
		 public static function share($closure){
			//Method inherited from \Illuminate\Container\Container
			return \Illuminate\Foundation\Application::share($closure);
		 }

		/**
		 * Bind a shared Closure into the container.
		 *
		 * @param string  $abstract
		 * @param \Closure  $closure
		 * @return void
		 * @static 
		 */
		 public static function bindShared($abstract, $closure){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::bindShared($abstract, $closure);
		 }

		/**
		 * "Extend" an abstract type in the container.
		 *
		 * @param string   $abstract
		 * @param Closure  $closure
		 * @return void
		 * @throws \InvalidArgumentException
		 * @static 
		 */
		 public static function extend($abstract, $closure){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::extend($abstract, $closure);
		 }

		/**
		 * Register an existing instance as shared in the container.
		 *
		 * @param string  $abstract
		 * @param mixed   $instance
		 * @return void
		 * @static 
		 */
		 public static function instance($abstract, $instance){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::instance($abstract, $instance);
		 }

		/**
		 * Alias a type to a shorter name.
		 *
		 * @param string  $abstract
		 * @param string  $alias
		 * @return void
		 * @static 
		 */
		 public static function alias($abstract, $alias){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::alias($abstract, $alias);
		 }

		/**
		 * Bind a new callback to an abstract's rebind event.
		 *
		 * @param string  $abstract
		 * @param \Closure  $callback
		 * @return mixed
		 * @static 
		 */
		 public static function rebinding($abstract, $callback){
			//Method inherited from \Illuminate\Container\Container
			return \Illuminate\Foundation\Application::rebinding($abstract, $callback);
		 }

		/**
		 * Refresh an instance on the given target and method.
		 *
		 * @param string  $abstract
		 * @param mixed  $target
		 * @param string  $method
		 * @return mixed
		 * @static 
		 */
		 public static function refresh($abstract, $target, $method){
			//Method inherited from \Illuminate\Container\Container
			return \Illuminate\Foundation\Application::refresh($abstract, $target, $method);
		 }

		/**
		 * Instantiate a concrete instance of the given type.
		 *
		 * @param string  $concrete
		 * @param array   $parameters
		 * @return mixed
		 * @throws BindingResolutionException
		 * @static 
		 */
		 public static function build($concrete, $parameters = array()){
			//Method inherited from \Illuminate\Container\Container
			return \Illuminate\Foundation\Application::build($concrete, $parameters);
		 }

		/**
		 * Register a new resolving callback.
		 *
		 * @param string  $abstract
		 * @param \Closure  $callback
		 * @return void
		 * @static 
		 */
		 public static function resolving($abstract, $callback){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::resolving($abstract, $callback);
		 }

		/**
		 * Register a new resolving callback for all types.
		 *
		 * @param \Closure  $callback
		 * @return void
		 * @static 
		 */
		 public static function resolvingAny($callback){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::resolvingAny($callback);
		 }

		/**
		 * Determine if a given type is shared.
		 *
		 * @param string  $abstract
		 * @return bool
		 * @static 
		 */
		 public static function isShared($abstract){
			//Method inherited from \Illuminate\Container\Container
			return \Illuminate\Foundation\Application::isShared($abstract);
		 }

		/**
		 * Get the container's bindings.
		 *
		 * @return array
		 * @static 
		 */
		 public static function getBindings(){
			//Method inherited from \Illuminate\Container\Container
			return \Illuminate\Foundation\Application::getBindings();
		 }

		/**
		 * Remove a resolved instance from the instance cache.
		 *
		 * @param string  $abstract
		 * @return void
		 * @static 
		 */
		 public static function forgetInstance($abstract){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::forgetInstance($abstract);
		 }

		/**
		 * Clear all of the instances from the container.
		 *
		 * @return void
		 * @static 
		 */
		 public static function forgetInstances(){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::forgetInstances();
		 }

		/**
		 * Determine if a given offset exists.
		 *
		 * @param string  $key
		 * @return bool
		 * @static 
		 */
		 public static function offsetExists($key){
			//Method inherited from \Illuminate\Container\Container
			return \Illuminate\Foundation\Application::offsetExists($key);
		 }

		/**
		 * Get the value at a given offset.
		 *
		 * @param string  $key
		 * @return mixed
		 * @static 
		 */
		 public static function offsetGet($key){
			//Method inherited from \Illuminate\Container\Container
			return \Illuminate\Foundation\Application::offsetGet($key);
		 }

		/**
		 * Set the value at a given offset.
		 *
		 * @param string  $key
		 * @param mixed   $value
		 * @return void
		 * @static 
		 */
		 public static function offsetSet($key, $value){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::offsetSet($key, $value);
		 }

		/**
		 * Unset the value at a given offset.
		 *
		 * @param string  $key
		 * @return void
		 * @static 
		 */
		 public static function offsetUnset($key){
			//Method inherited from \Illuminate\Container\Container
			 \Illuminate\Foundation\Application::offsetUnset($key);
		 }

	}
	class Artisan extends \Illuminate\Support\Facades\Artisan{
		/**
		 * Create and boot a new Console application.
		 *
		 * @param \Illuminate\Foundation\Application  $app
		 * @return \Illuminate\Console\Application
		 * @static 
		 */
		 public static function start($app){
			//Method inherited from \Illuminate\Console\Application
			return \Illuminate\Console\Application::start($app);
		 }

		/**
		 * Create a new Console application.
		 *
		 * @param \Illuminate\Foundation\Application  $app
		 * @return \Illuminate\Console\Application
		 * @static 
		 */
		 public static function make($app){
			//Method inherited from \Illuminate\Console\Application
			return \Illuminate\Console\Application::make($app);
		 }

		/**
		 * Boot the Console application.
		 *
		 * @return \Illuminate\Console\Application
		 * @static 
		 */
		 public static function boot(){
			//Method inherited from \Illuminate\Console\Application
			return \Illuminate\Console\Application::boot();
		 }

		/**
		 * Run an Artisan console command by name.
		 *
		 * @param string  $command
		 * @param array   $parameters
		 * @param \Symfony\Component\Console\Output\OutputInterface  $output
		 * @return void
		 * @static 
		 */
		 public static function call($command, $parameters = array(), $output = null){
			//Method inherited from \Illuminate\Console\Application
			 \Illuminate\Console\Application::call($command, $parameters, $output);
		 }

		/**
		 * Add a command to the console.
		 *
		 * @param \Symfony\Component\Console\Command\Command  $command
		 * @return \Symfony\Component\Console\Command\Command
		 * @static 
		 */
		 public static function add($command){
			//Method inherited from \Illuminate\Console\Application
			return \Illuminate\Console\Application::add($command);
		 }

		/**
		 * Add a command, resolving through the application.
		 *
		 * @param string  $command
		 * @return \Symfony\Component\Console\Command\Command
		 * @static 
		 */
		 public static function resolve($command){
			//Method inherited from \Illuminate\Console\Application
			return \Illuminate\Console\Application::resolve($command);
		 }

		/**
		 * Resolve an array of commands through the application.
		 *
		 * @param array|dynamic  $commands
		 * @return void
		 * @static 
		 */
		 public static function resolveCommands($commands){
			//Method inherited from \Illuminate\Console\Application
			 \Illuminate\Console\Application::resolveCommands($commands);
		 }

		/**
		 * Render the given exception.
		 *
		 * @param \Exception  $e
		 * @param \Symfony\Component\Console\Output\OutputInterface  $output
		 * @return void
		 * @static 
		 */
		 public static function renderException($e, $output){
			//Method inherited from \Illuminate\Console\Application
			 \Illuminate\Console\Application::renderException($e, $output);
		 }

		/**
		 * Set the exception handler instance.
		 *
		 * @param \Illuminate\Exception\Handler  $handler
		 * @return \Illuminate\Console\Application
		 * @static 
		 */
		 public static function setExceptionHandler($handler){
			//Method inherited from \Illuminate\Console\Application
			return \Illuminate\Console\Application::setExceptionHandler($handler);
		 }

		/**
		 * Set the Laravel application instance.
		 *
		 * @param \Illuminate\Foundation\Application  $laravel
		 * @return \Illuminate\Console\Application
		 * @static 
		 */
		 public static function setLaravel($laravel){
			//Method inherited from \Illuminate\Console\Application
			return \Illuminate\Console\Application::setLaravel($laravel);
		 }

		/**
		 * Set whether the Console app should auto-exit when done.
		 *
		 * @param bool  $boolean
		 * @return \Illuminate\Console\Application
		 * @static 
		 */
		 public static function setAutoExit($boolean){
			//Method inherited from \Illuminate\Console\Application
			return \Illuminate\Console\Application::setAutoExit($boolean);
		 }

		/**
		 * Constructor.
		 *
		 * @param string $name    The name of the application
		 * @param string $version The version of the application
		 * @api 
		 * @static 
		 */
		 public static function __construct($name = 'UNKNOWN', $version = 'UNKNOWN'){
			//Method inherited from \Symfony\Component\Console\Application
			 \Illuminate\Console\Application::__construct($name, $version);
		 }

		/**
		 * 
		 *
		 * @static 
		 */
		 public static function setDispatcher($dispatcher){
			//Method inherited from \Symfony\Component\Console\Application
			 \Illuminate\Console\Application::setDispatcher($dispatcher);
		 }

		/**
		 * Runs the current application.
		 *
		 * @param InputInterface  $input  An Input instance
		 * @param OutputInterface $output An Output instance
		 * @return int 0 if everything went fine, or an error code
		 * @throws \Exception When doRun returns Exception
		 * @api 
		 * @static 
		 */
		 public static function run($input = null, $output = null){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::run($input, $output);
		 }

		/**
		 * Runs the current application.
		 *
		 * @param InputInterface  $input  An Input instance
		 * @param OutputInterface $output An Output instance
		 * @return int 0 if everything went fine, or an error code
		 * @static 
		 */
		 public static function doRun($input, $output){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::doRun($input, $output);
		 }

		/**
		 * Set a helper set to be used with the command.
		 *
		 * @param HelperSet $helperSet The helper set
		 * @api 
		 * @static 
		 */
		 public static function setHelperSet($helperSet){
			//Method inherited from \Symfony\Component\Console\Application
			 \Illuminate\Console\Application::setHelperSet($helperSet);
		 }

		/**
		 * Get the helper set associated with the command.
		 *
		 * @return HelperSet The HelperSet instance associated with this command
		 * @api 
		 * @static 
		 */
		 public static function getHelperSet(){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::getHelperSet();
		 }

		/**
		 * Set an input definition set to be used with this application
		 *
		 * @param InputDefinition $definition The input definition
		 * @api 
		 * @static 
		 */
		 public static function setDefinition($definition){
			//Method inherited from \Symfony\Component\Console\Application
			 \Illuminate\Console\Application::setDefinition($definition);
		 }

		/**
		 * Gets the InputDefinition related to this Application.
		 *
		 * @return InputDefinition The InputDefinition instance
		 * @static 
		 */
		 public static function getDefinition(){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::getDefinition();
		 }

		/**
		 * Gets the help message.
		 *
		 * @return string A help message.
		 * @static 
		 */
		 public static function getHelp(){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::getHelp();
		 }

		/**
		 * Sets whether to catch exceptions or not during commands execution.
		 *
		 * @param bool $boolean Whether to catch exceptions or not during commands execution
		 * @api 
		 * @static 
		 */
		 public static function setCatchExceptions($boolean){
			//Method inherited from \Symfony\Component\Console\Application
			 \Illuminate\Console\Application::setCatchExceptions($boolean);
		 }

		/**
		 * Gets the name of the application.
		 *
		 * @return string The application name
		 * @api 
		 * @static 
		 */
		 public static function getName(){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::getName();
		 }

		/**
		 * Sets the application name.
		 *
		 * @param string $name The application name
		 * @api 
		 * @static 
		 */
		 public static function setName($name){
			//Method inherited from \Symfony\Component\Console\Application
			 \Illuminate\Console\Application::setName($name);
		 }

		/**
		 * Gets the application version.
		 *
		 * @return string The application version
		 * @api 
		 * @static 
		 */
		 public static function getVersion(){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::getVersion();
		 }

		/**
		 * Sets the application version.
		 *
		 * @param string $version The application version
		 * @api 
		 * @static 
		 */
		 public static function setVersion($version){
			//Method inherited from \Symfony\Component\Console\Application
			 \Illuminate\Console\Application::setVersion($version);
		 }

		/**
		 * Returns the long version of the application.
		 *
		 * @return string The long application version
		 * @api 
		 * @static 
		 */
		 public static function getLongVersion(){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::getLongVersion();
		 }

		/**
		 * Registers a new command.
		 *
		 * @param string $name The command name
		 * @return Command The newly created command
		 * @api 
		 * @static 
		 */
		 public static function register($name){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::register($name);
		 }

		/**
		 * Adds an array of command objects.
		 *
		 * @param Command[] $commands An array of commands
		 * @api 
		 * @static 
		 */
		 public static function addCommands($commands){
			//Method inherited from \Symfony\Component\Console\Application
			 \Illuminate\Console\Application::addCommands($commands);
		 }

		/**
		 * Returns a registered command by name or alias.
		 *
		 * @param string $name The command name or alias
		 * @return Command A Command object
		 * @throws \InvalidArgumentException When command name given does not exist
		 * @api 
		 * @static 
		 */
		 public static function get($name){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::get($name);
		 }

		/**
		 * Returns true if the command exists, false otherwise.
		 *
		 * @param string $name The command name or alias
		 * @return bool true if the command exists, false otherwise
		 * @api 
		 * @static 
		 */
		 public static function has($name){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::has($name);
		 }

		/**
		 * Returns an array of all unique namespaces used by currently registered commands.
		 * 
		 * It does not returns the global namespace which always exists.
		 *
		 * @return array An array of namespaces
		 * @static 
		 */
		 public static function getNamespaces(){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::getNamespaces();
		 }

		/**
		 * Finds a registered namespace by a name or an abbreviation.
		 *
		 * @param string $namespace A namespace or abbreviation to search for
		 * @return string A registered namespace
		 * @throws \InvalidArgumentException When namespace is incorrect or ambiguous
		 * @static 
		 */
		 public static function findNamespace($namespace){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::findNamespace($namespace);
		 }

		/**
		 * Finds a command by name or alias.
		 * 
		 * Contrary to get, this command tries to find the best
		 * match if you give it an abbreviation of a name or alias.
		 *
		 * @param string $name A command name or a command alias
		 * @return Command A Command instance
		 * @throws \InvalidArgumentException When command name is incorrect or ambiguous
		 * @api 
		 * @static 
		 */
		 public static function find($name){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::find($name);
		 }

		/**
		 * Gets the commands (registered in the given namespace if provided).
		 * 
		 * The array keys are the full names and the values the command instances.
		 *
		 * @param string $namespace A namespace name
		 * @return Command[] An array of Command instances
		 * @api 
		 * @static 
		 */
		 public static function all($namespace = null){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::all($namespace);
		 }

		/**
		 * Returns an array of possible abbreviations given a set of names.
		 *
		 * @param array $names An array of names
		 * @return array An array of abbreviations
		 * @static 
		 */
		 public static function getAbbreviations($names){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::getAbbreviations($names);
		 }

		/**
		 * Returns a text representation of the Application.
		 *
		 * @param string $namespace An optional namespace name
		 * @param bool   $raw       Whether to return raw command list
		 * @return string A string representing the Application
		 * @deprecated Deprecated since version 2.3, to be removed in 3.0.
		 * @static 
		 */
		 public static function asText($namespace = null, $raw = false){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::asText($namespace, $raw);
		 }

		/**
		 * Returns an XML representation of the Application.
		 *
		 * @param string $namespace An optional namespace name
		 * @param bool   $asDom     Whether to return a DOM or an XML string
		 * @return string|\DOMDocument An XML string representing the Application
		 * @deprecated Deprecated since version 2.3, to be removed in 3.0.
		 * @static 
		 */
		 public static function asXml($namespace = null, $asDom = false){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::asXml($namespace, $asDom);
		 }

		/**
		 * Tries to figure out the terminal dimensions based on the current environment
		 *
		 * @return array Array containing width and height
		 * @static 
		 */
		 public static function getTerminalDimensions(){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::getTerminalDimensions();
		 }

		/**
		 * Sets terminal dimensions.
		 * 
		 * Can be useful to force terminal dimensions for functional tests.
		 *
		 * @param int     $width  The width
		 * @param int     $height The height
		 * @return Application The current application
		 * @static 
		 */
		 public static function setTerminalDimensions($width, $height){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::setTerminalDimensions($width, $height);
		 }

		/**
		 * Returns the namespace part of the command name.
		 * 
		 * This method is not part of public API and should not be used directly.
		 *
		 * @param string $name  The full name of the command
		 * @param string $limit The maximum number of parts of the namespace
		 * @return string The namespace of the command
		 * @static 
		 */
		 public static function extractNamespace($name, $limit = null){
			//Method inherited from \Symfony\Component\Console\Application
			return \Illuminate\Console\Application::extractNamespace($name, $limit);
		 }

		/**
		 * Sets the default Command name.
		 *
		 * @param string $commandName The Command name
		 * @static 
		 */
		 public static function setDefaultCommand($commandName){
			//Method inherited from \Symfony\Component\Console\Application
			 \Illuminate\Console\Application::setDefaultCommand($commandName);
		 }

		/**
		 * Dynamically pass all missing methods to console Artisan.
		 *
		 * @param string  $method
		 * @param array   $parameters
		 * @return mixed
		 * @static 
		 */
		 public static function __call($method, $parameters){
			//Method inherited from \Illuminate\Foundation\Artisan
			return \Illuminate\Foundation\Artisan::__call($method, $parameters);
		 }

	}
	class Auth extends \Illuminate\Support\Facades\Auth{
		/**
		 * Create an instance of the database driver.
		 *
		 * @return \Illuminate\Auth\Guard
		 * @static 
		 */
		 public static function createDatabaseDriver(){
			//Method inherited from \Illuminate\Auth\AuthManager
			return \Illuminate\Auth\AuthManager::createDatabaseDriver();
		 }

		/**
		 * Create an instance of the Eloquent driver.
		 *
		 * @return \Illuminate\Auth\Guard
		 * @static 
		 */
		 public static function createEloquentDriver(){
			//Method inherited from \Illuminate\Auth\AuthManager
			return \Illuminate\Auth\AuthManager::createEloquentDriver();
		 }

		/**
		 * Get the default authentication driver name.
		 *
		 * @return string
		 * @static 
		 */
		 public static function getDefaultDriver(){
			//Method inherited from \Illuminate\Auth\AuthManager
			return \Illuminate\Auth\AuthManager::getDefaultDriver();
		 }

		/**
		 * Set the default authentication driver name.
		 *
		 * @param string  $name
		 * @return void
		 * @static 
		 */
		 public static function setDefaultDriver($name){
			//Method inherited from \Illuminate\Auth\AuthManager
			 \Illuminate\Auth\AuthManager::setDefaultDriver($name);
		 }

		/**
		 * Create a new manager instance.
		 *
		 * @param \Illuminate\Foundation\Application  $app
		 * @return void
		 * @static 
		 */
		 public static function __construct($app){
			//Method inherited from \Illuminate\Support\Manager
			 \Illuminate\Auth\AuthManager::__construct($app);
		 }

		/**
		 * Get a driver instance.
		 *
		 * @param string  $driver
		 * @return mixed
		 * @static 
		 */
		 public static function driver($driver = null){
			//Method inherited from \Illuminate\Support\Manager
			return \Illuminate\Auth\AuthManager::driver($driver);
		 }

		/**
		 * Register a custom driver creator Closure.
		 *
		 * @param string   $driver
		 * @param Closure  $callback
		 * @return \Illuminate\Support\Manager|static
		 * @static 
		 */
		 public static function extend($driver, $callback){
			//Method inherited from \Illuminate\Support\Manager
			return \Illuminate\Auth\AuthManager::extend($driver, $callback);
		 }

		/**
		 * Get all of the created "drivers".
		 *
		 * @return array
		 * @static 
		 */
		 public static function getDrivers(){
			//Method inherited from \Illuminate\Support\Manager
			return \Illuminate\Auth\AuthManager::getDrivers();
		 }

		/**
		 * Dynamically call the default driver instance.
		 *
		 * @param string  $method
		 * @param array   $parameters
		 * @return mixed
		 * @static 
		 */
		 public static function __call($method, $parameters){
			//Method inherited from \Illuminate\Support\Manager
			return \Illuminate\Auth\AuthManager::__call($method, $parameters);
		 }

		/**
		 * Determine if the current user is authenticated.
		 *
		 * @return bool
		 * @static 
		 */
		 public static function check(){
			//Method inherited from \Illuminate\Auth\Guard
			return \Illuminate\Auth\Guard::check();
		 }

		/**
		 * Determine if the current user is a guest.
		 *
		 * @return bool
		 * @static 
		 */
		 public static function guest(){
			//Method inherited from \Illuminate\Auth\Guard
			return \Illuminate\Auth\Guard::guest();
		 }

		/**
		 * Get the currently authenticated user.
		 *
		 * @return \Illuminate\Auth\UserInterface|null
		 * @static 
		 */
		 public static function user(){
			//Method inherited from \Illuminate\Auth\Guard
			return \Illuminate\Auth\Guard::user();
		 }

		/**
		 * Get the ID for the currently authenticated user.
		 *
		 * @return int|null
		 * @static 
		 */
		 public static function id(){
			//Method inherited from \Illuminate\Auth\Guard
			return \Illuminate\Auth\Guard::id();
		 }

		/**
		 * Log a user into the application without sessions or cookies.
		 *
		 * @param array  $credentials
		 * @return bool
		 * @static 
		 */
		 public static function once($credentials = array()){
			//Method inherited from \Illuminate\Auth\Guard
			return \Illuminate\Auth\Guard::once($credentials);
		 }

		/**
		 * Validate a user's credentials.
		 *
		 * @param array  $credentials
		 * @return bool
		 * @static 
		 */
		 public static function validate($credentials = array()){
			//Method inherited from \Illuminate\Auth\Guard
			return \Illuminate\Auth\Guard::validate($credentials);
		 }

		/**
		 * Attempt to authenticate using HTTP Basic Auth.
		 *
		 * @param string  $field
		 * @param \Symfony\Component\HttpFoundation\Request  $request
		 * @return \Symfony\Component\HttpFoundation\Response|null
		 * @static 
		 */
		 public static function basic($field = 'email', $request = null){
			//Method inherited from \Illuminate\Auth\Guard
			return \Illuminate\Auth\Guard::basic($field, $request);
		 }

		/**
		 * Perform a stateless HTTP Basic login attempt.
		 *
		 * @param string  $field
		 * @param \Symfony\Component\HttpFoundation\Request  $request
		 * @return \Symfony\Component\HttpFoundation\Response|null
		 * @static 
		 */
		 public static function onceBasic($field = 'email', $request = null){
			//Method inherited from \Illuminate\Auth\Guard
			return \Illuminate\Auth\Guard::onceBasic($field, $request);
		 }

		/**
		 * Attempt to authenticate a user using the given credentials.
		 *
		 * @param array  $credentials
		 * @param bool   $remember
		 * @param bool   $login
		 * @return bool
		 * @static 
		 */
		 public static function attempt($credentials = array(), $remember = false, $login = true){
			//Method inherited from \Illuminate\Auth\Guard
			return \Illuminate\Auth\Guard::attempt($credentials, $remember, $login);
		 }

		/**
		 * Register an authentication attempt event listener.
		 *
		 * @param mixed  $callback
		 * @return void
		 * @static 
		 */
		 public static function attempting($callback){
			//Method inherited from \Illuminate\Auth\Guard
			 \Illuminate\Auth\Guard::attempting($callback);
		 }

		/**
		 * Log a user into the application.
		 *
		 * @param \Illuminate\Auth\UserInterface  $user
		 * @param bool  $remember
		 * @return void
		 * @static 
		 */
		 public static function login($user, $remember = false){
			//Method inherited from \Illuminate\Auth\Guard
			 \Illuminate\Auth\Guard::login($user, $remember);
		 }

		/**
		 * Log the given user ID into the application.
		 *
		 * @param mixed  $id
		 * @param bool   $remember
		 * @return \Illuminate\Auth\UserInterface
		 * @static 
		 */
		 public static function loginUsingId($id, $remember = false){
			//Method inherited from \Illuminate\Auth\Guard
			return \Illuminate\Auth\Guard::loginUsingId($id, $remember);
		 }

		/**
		 * Log the given user ID into the application without sessions or cookies.
		 *
		 * @param mixed  $id
		 * @return bool
		 * @static 
		 */
		 public static function onceUsingId($id){
			//Method inherited from \Illuminate\Auth\Guard
			return \Illuminate\Auth\Guard::onceUsingId($id);
		 }

		/**
		 * Log the user out of the application.
		 *
		 * @return void
		 * @static 
		 */
		 public static function logout(){
			//Method inherited from \Illuminate\Auth\Guard
			 \Illuminate\Auth\Guard::logout();
		 }

		/**
		 * Get the cookie creator instance used by the guard.
		 *
		 * @return \Illuminate\Cookie\CookieJar
		 * @thro…

Large files files are truncated, but you can click here to view the full file