Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Lumen IDE Helper
<?php
/**
* A helper file for Laravel 5, to provide autocomplete information to your IDE
* Generated for Laravel Lumen (5.1.1) (Laravel Components 5.1.*) on 2015-08-18.
*
* @author Barry vd. Heuvel <barryvdh@gmail.com>
* @see https://github.com/barryvdh/laravel-ide-helper
*/
namespace {
exit("This file should not be included, only analyzed by your IDE");
class App extends \Illuminate\Support\Facades\App{
/**
* Get the version number of the application.
*
* @return string
* @static
*/
public static function version(){
return \Laravel\Lumen\Application::version();
}
/**
* Get or check the current application environment.
*
* @param mixed
* @return string
* @static
*/
public static function environment(){
return \Laravel\Lumen\Application::environment();
}
/**
* Determine if the application is currently down for maintenance.
*
* @return bool
* @static
*/
public static function isDownForMaintenance(){
return \Laravel\Lumen\Application::isDownForMaintenance();
}
/**
* Register all of the configured providers.
*
* @return void
* @static
*/
public static function registerConfiguredProviders(){
\Laravel\Lumen\Application::registerConfiguredProviders();
}
/**
* Get the path to the cached "compiled.php" file.
*
* @return string
* @static
*/
public static function getCachedCompilePath(){
return \Laravel\Lumen\Application::getCachedCompilePath();
}
/**
* Get the path to the cached services.json file.
*
* @return string
* @static
*/
public static function getCachedServicesPath(){
return \Laravel\Lumen\Application::getCachedServicesPath();
}
/**
* 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){
return \Laravel\Lumen\Application::register($provider, $options, $force);
}
/**
* Register a deferred provider and service.
*
* @param string $provider
* @param string $service
* @return void
* @static
*/
public static function registerDeferredProvider($provider, $service = null){
\Laravel\Lumen\Application::registerDeferredProvider($provider, $service);
}
/**
* Boot the application's service providers.
*
* @return void
* @static
*/
public static function boot(){
\Laravel\Lumen\Application::boot();
}
/**
* Register a new boot listener.
*
* @param mixed $callback
* @return void
* @static
*/
public static function booting($callback){
\Laravel\Lumen\Application::booting($callback);
}
/**
* Register a new "booted" listener.
*
* @param mixed $callback
* @return void
* @static
*/
public static function booted($callback){
\Laravel\Lumen\Application::booted($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
* @static
*/
public static function abort($code, $message = '', $headers = array()){
\Laravel\Lumen\Application::abort($code, $message, $headers);
}
/**
* Resolve the given type from the container.
*
* @param string $abstract
* @param array $parameters
* @return mixed
* @static
*/
public static function make($abstract, $parameters = array()){
return \Laravel\Lumen\Application::make($abstract, $parameters);
}
/**
* Load a configuration file into the application.
*
* @return void
* @static
*/
public static function configure($name){
\Laravel\Lumen\Application::configure($name);
}
/**
* Register the facades for the application.
*
* @return void
* @static
*/
public static function withFacades(){
\Laravel\Lumen\Application::withFacades();
}
/**
* Load the Eloquent library for the application.
*
* @return void
* @static
*/
public static function withEloquent(){
\Laravel\Lumen\Application::withEloquent();
}
/**
* Register a set of routes with a set of shared attributes.
*
* @param array $attributes
* @param \Closure $callback
* @return void
* @static
*/
public static function group($attributes, $callback){
\Laravel\Lumen\Application::group($attributes, $callback);
}
/**
* Register a route with the application.
*
* @param string $uri
* @param mixed $action
* @return $this
* @static
*/
public static function get($uri, $action){
return \Laravel\Lumen\Application::get($uri, $action);
}
/**
* Register a route with the application.
*
* @param string $uri
* @param mixed $action
* @return $this
* @static
*/
public static function post($uri, $action){
return \Laravel\Lumen\Application::post($uri, $action);
}
/**
* Register a route with the application.
*
* @param string $uri
* @param mixed $action
* @return $this
* @static
*/
public static function put($uri, $action){
return \Laravel\Lumen\Application::put($uri, $action);
}
/**
* Register a route with the application.
*
* @param string $uri
* @param mixed $action
* @return $this
* @static
*/
public static function patch($uri, $action){
return \Laravel\Lumen\Application::patch($uri, $action);
}
/**
* Register a route with the application.
*
* @param string $uri
* @param mixed $action
* @return $this
* @static
*/
public static function delete($uri, $action){
return \Laravel\Lumen\Application::delete($uri, $action);
}
/**
* Register a route with the application.
*
* @param string $uri
* @param mixed $action
* @return $this
* @static
*/
public static function options($uri, $action){
return \Laravel\Lumen\Application::options($uri, $action);
}
/**
* Add a route to the collection.
*
* @param string $method
* @param string $uri
* @param mixed $action
* @static
*/
public static function addRoute($method, $uri, $action){
return \Laravel\Lumen\Application::addRoute($method, $uri, $action);
}
/**
* Add new middleware to the application.
*
* @param array $middleware
* @return $this
* @static
*/
public static function middleware($middleware){
return \Laravel\Lumen\Application::middleware($middleware);
}
/**
* Define the route middleware for the application.
*
* @param array $middleware
* @return $this
* @static
*/
public static function routeMiddleware($middleware){
return \Laravel\Lumen\Application::routeMiddleware($middleware);
}
/**
* {@inheritdoc}
*
* @static
*/
public static function handle($request, $type = 1, $catch = true){
return \Laravel\Lumen\Application::handle($request, $type, $catch);
}
/**
* Run the application and send the response.
*
* @param \Laravel\Lumen\SymfonyRequest|null $request
* @return void
* @static
*/
public static function run($request = null){
\Laravel\Lumen\Application::run($request);
}
/**
* Dispatch the incoming request.
*
* @param \Laravel\Lumen\SymfonyRequest|null $request
* @return \Laravel\Lumen\Response
* @static
*/
public static function dispatch($request = null){
return \Laravel\Lumen\Application::dispatch($request);
}
/**
* Set the FastRoute dispatcher instance.
*
* @param \FastRoute\Dispatcher $dispatcher
* @return void
* @static
*/
public static function setDispatcher($dispatcher){
\Laravel\Lumen\Application::setDispatcher($dispatcher);
}
/**
* Prepare the response for sending.
*
* @param mixed $response
* @return \Laravel\Lumen\Response
* @static
*/
public static function prepareResponse($response){
return \Laravel\Lumen\Application::prepareResponse($response);
}
/**
* Get the current HTTP path info.
*
* @return string
* @static
*/
public static function getPathInfo(){
return \Laravel\Lumen\Application::getPathInfo();
}
/**
* Get the base path for the application.
*
* @param string $path
* @return string
* @static
*/
public static function basePath($path = null){
return \Laravel\Lumen\Application::basePath($path);
}
/**
* Get the storage path for the application.
*
* @param string $path
* @return string
* @static
*/
public static function storagePath($path = null){
return \Laravel\Lumen\Application::storagePath($path);
}
/**
* Set a custom storage path for the application.
*
* @param string $path
* @return $this
* @static
*/
public static function useStoragePath($path){
return \Laravel\Lumen\Application::useStoragePath($path);
}
/**
* Get the database path for the application.
*
* @return string
* @static
*/
public static function databasePath(){
return \Laravel\Lumen\Application::databasePath();
}
/**
* Set a custom configuration path for the application.
*
* @param string $path
* @return $this
* @static
*/
public static function useConfigPath($path){
return \Laravel\Lumen\Application::useConfigPath($path);
}
/**
* Get the resource path for the application.
*
* @param string $path
* @return string
* @static
*/
public static function resourcePath($path = null){
return \Laravel\Lumen\Application::resourcePath($path);
}
/**
* Set a custom resource path for the application.
*
* @param string $path
* @return $this
* @static
*/
public static function useResourcePath($path){
return \Laravel\Lumen\Application::useResourcePath($path);
}
/**
* Determine if the application is running in the console.
*
* @return string
* @static
*/
public static function runningInConsole(){
return \Laravel\Lumen\Application::runningInConsole();
}
/**
* Prepare the application to execute a console command.
*
* @return void
* @static
*/
public static function prepareForConsoleCommand(){
\Laravel\Lumen\Application::prepareForConsoleCommand();
}
/**
* Get the raw routes for the application.
*
* @return array
* @static
*/
public static function getRoutes(){
return \Laravel\Lumen\Application::getRoutes();
}
/**
* Set the cached routes.
*
* @param array $routes
* @return void
* @static
*/
public static function setRoutes($routes){
\Laravel\Lumen\Application::setRoutes($routes);
}
/**
* Get the HTML from the Lumen welcome screen.
*
* @return string
* @static
*/
public static function welcome(){
return \Laravel\Lumen\Application::welcome();
}
/**
* Define a contextual binding.
*
* @param string $concrete
* @return \Illuminate\Contracts\Container\ContextualBindingBuilder
* @static
*/
public static function when($concrete){
//Method inherited from \Illuminate\Container\Container
return \Laravel\Lumen\Application::when($concrete);
}
/**
* 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 \Laravel\Lumen\Application::bound($abstract);
}
/**
* Determine if the given abstract type has been resolved.
*
* @param string $abstract
* @return bool
* @static
*/
public static function resolved($abstract){
//Method inherited from \Illuminate\Container\Container
return \Laravel\Lumen\Application::resolved($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 \Laravel\Lumen\Application::isAlias($name);
}
/**
* Register a binding with the container.
*
* @param string|array $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
\Laravel\Lumen\Application::bind($abstract, $concrete, $shared);
}
/**
* Add a contextual binding to the container.
*
* @param string $concrete
* @param string $abstract
* @param \Closure|string $implementation
* @static
*/
public static function addContextualBinding($concrete, $abstract, $implementation){
//Method inherited from \Illuminate\Container\Container
return \Laravel\Lumen\Application::addContextualBinding($concrete, $abstract, $implementation);
}
/**
* Register a binding if it hasn't already been registered.
*
* @param string $abstract
* @param \Closure|string|null $concrete
* @param bool $shared
* @return void
* @static
*/
public static function bindIf($abstract, $concrete = null, $shared = false){
//Method inherited from \Illuminate\Container\Container
\Laravel\Lumen\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
\Laravel\Lumen\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 \Laravel\Lumen\Application::share($closure);
}
/**
* Bind a shared Closure into the container.
*
* @param string $abstract
* @param \Closure $closure
* @return void
* @deprecated since version 5.1. Use singleton instead.
* @static
*/
public static function bindShared($abstract, $closure){
//Method inherited from \Illuminate\Container\Container
\Laravel\Lumen\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
\Laravel\Lumen\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
\Laravel\Lumen\Application::instance($abstract, $instance);
}
/**
* Assign a set of tags to a given binding.
*
* @param array|string $abstracts
* @param array|mixed $tags
* @return void
* @static
*/
public static function tag($abstracts, $tags){
//Method inherited from \Illuminate\Container\Container
\Laravel\Lumen\Application::tag($abstracts, $tags);
}
/**
* Resolve all of the bindings for a given tag.
*
* @param string $tag
* @return array
* @static
*/
public static function tagged($tag){
//Method inherited from \Illuminate\Container\Container
return \Laravel\Lumen\Application::tagged($tag);
}
/**
* Alias a type to a different name.
*
* @param string $abstract
* @param string $alias
* @return void
* @static
*/
public static function alias($abstract, $alias){
//Method inherited from \Illuminate\Container\Container
\Laravel\Lumen\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 \Laravel\Lumen\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 \Laravel\Lumen\Application::refresh($abstract, $target, $method);
}
/**
* Wrap the given closure such that its dependencies will be injected when executed.
*
* @param \Closure $callback
* @param array $parameters
* @return \Closure
* @static
*/
public static function wrap($callback, $parameters = array()){
//Method inherited from \Illuminate\Container\Container
return \Laravel\Lumen\Application::wrap($callback, $parameters);
}
/**
* Call the given Closure / class@method and inject its dependencies.
*
* @param callable|string $callback
* @param array $parameters
* @param string|null $defaultMethod
* @return mixed
* @static
*/
public static function call($callback, $parameters = array(), $defaultMethod = null){
//Method inherited from \Illuminate\Container\Container
return \Laravel\Lumen\Application::call($callback, $parameters, $defaultMethod);
}
/**
* Instantiate a concrete instance of the given type.
*
* @param string $concrete
* @param array $parameters
* @return mixed
* @throws \Illuminate\Contracts\Container\BindingResolutionException
* @static
*/
public static function build($concrete, $parameters = array()){
//Method inherited from \Illuminate\Container\Container
return \Laravel\Lumen\Application::build($concrete, $parameters);
}
/**
* Register a new resolving callback.
*
* @param string $abstract
* @param \Closure|null $callback
* @return void
* @static
*/
public static function resolving($abstract, $callback = null){
//Method inherited from \Illuminate\Container\Container
\Laravel\Lumen\Application::resolving($abstract, $callback);
}
/**
* Register a new after resolving callback for all types.
*
* @param string $abstract
* @param \Closure|null $callback
* @return void
* @static
*/
public static function afterResolving($abstract, $callback = null){
//Method inherited from \Illuminate\Container\Container
\Laravel\Lumen\Application::afterResolving($abstract, $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 \Laravel\Lumen\Application::isShared($abstract);
}
/**
* Get the container's bindings.
*
* @return array
* @static
*/
public static function getBindings(){
//Method inherited from \Illuminate\Container\Container
return \Laravel\Lumen\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
\Laravel\Lumen\Application::forgetInstance($abstract);
}
/**
* Clear all of the instances from the container.
*
* @return void
* @static
*/
public static function forgetInstances(){
//Method inherited from \Illuminate\Container\Container
\Laravel\Lumen\Application::forgetInstances();
}
/**
* Flush the container of all bindings and resolved instances.
*
* @return void
* @static
*/
public static function flush(){
//Method inherited from \Illuminate\Container\Container
\Laravel\Lumen\Application::flush();
}
/**
* Set the globally available instance of the container.
*
* @return static
* @static
*/
public static function getInstance(){
//Method inherited from \Illuminate\Container\Container
return \Laravel\Lumen\Application::getInstance();
}
/**
* Set the shared instance of the container.
*
* @param \Illuminate\Contracts\Container\Container $container
* @return void
* @static
*/
public static function setInstance($container){
//Method inherited from \Illuminate\Container\Container
\Laravel\Lumen\Application::setInstance($container);
}
/**
* Determine if a given offset exists.
*
* @param string $key
* @return bool
* @static
*/
public static function offsetExists($key){
//Method inherited from \Illuminate\Container\Container
return \Laravel\Lumen\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 \Laravel\Lumen\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
\Laravel\Lumen\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
\Laravel\Lumen\Application::offsetUnset($key);
}
}
class Auth extends \Illuminate\Support\Facades\Auth{
/**
* Create an instance of the database driver.
*
* @return \Illuminate\Auth\Guard
* @static
*/
public static function createDatabaseDriver(){
return \Illuminate\Auth\AuthManager::createDatabaseDriver();
}
/**
* Create an instance of the Eloquent driver.
*
* @return \Illuminate\Auth\Guard
* @static
*/
public static function createEloquentDriver(){
return \Illuminate\Auth\AuthManager::createEloquentDriver();
}
/**
* Get the default authentication driver name.
*
* @return string
* @static
*/
public static function getDefaultDriver(){
return \Illuminate\Auth\AuthManager::getDefaultDriver();
}
/**
* Set the default authentication driver name.
*
* @param string $name
* @return void
* @static
*/
public static function setDefaultDriver($name){
\Illuminate\Auth\AuthManager::setDefaultDriver($name);
}
/**
* 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 $this
* @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();
}
/**
* Determine if the current user is authenticated.
*
* @return bool
* @static
*/
public static function check(){
return \Illuminate\Auth\Guard::check();
}
/**
* Determine if the current user is a guest.
*
* @return bool
* @static
*/
public static function guest(){
return \Illuminate\Auth\Guard::guest();
}
/**
* Get the currently authenticated user.
*
* @return \App\User|null
* @static
*/
public static function user(){
return \Illuminate\Auth\Guard::user();
}
/**
* Get the ID for the currently authenticated user.
*
* @return int|null
* @static
*/
public static function id(){
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()){
return \Illuminate\Auth\Guard::once($credentials);
}
/**
* Validate a user's credentials.
*
* @param array $credentials
* @return bool
* @static
*/
public static function validate($credentials = array()){
return \Illuminate\Auth\Guard::validate($credentials);
}
/**
* Attempt to authenticate using HTTP Basic Auth.
*
* @param string $field
* @return \Symfony\Component\HttpFoundation\Response|null
* @static
*/
public static function basic($field = 'email'){
return \Illuminate\Auth\Guard::basic($field);
}
/**
* Perform a stateless HTTP Basic login attempt.
*
* @param string $field
* @return \Symfony\Component\HttpFoundation\Response|null
* @static
*/
public static function onceBasic($field = 'email'){
return \Illuminate\Auth\Guard::onceBasic($field);
}
/**
* 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){
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){
\Illuminate\Auth\Guard::attempting($callback);
}
/**
* Log a user into the application.
*
* @param \Illuminate\Contracts\Auth\Authenticatable $user
* @param bool $remember
* @return void
* @static
*/
public static function login($user, $remember = false){
\Illuminate\Auth\Guard::login($user, $remember);
}
/**
* Log the given user ID into the application.
*
* @param mixed $id
* @param bool $remember
* @return \App\User
* @static
*/
public static function loginUsingId($id, $remember = false){
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){
return \Illuminate\Auth\Guard::onceUsingId($id);
}
/**
* Log the user out of the application.
*
* @return void
* @static
*/
public static function logout(){
\Illuminate\Auth\Guard::logout();
}
/**
* Get the cookie creator instance used by the guard.
*
* @return \Illuminate\Contracts\Cookie\QueueingFactory
* @throws \RuntimeException
* @static
*/
public static function getCookieJar(){
return \Illuminate\Auth\Guard::getCookieJar();
}
/**
* Set the cookie creator instance used by the guard.
*
* @param \Illuminate\Contracts\Cookie\QueueingFactory $cookie
* @return void
* @static
*/
public static function setCookieJar($cookie){
\Illuminate\Auth\Guard::setCookieJar($cookie);
}
/**
* Get the event dispatcher instance.
*
* @return \Illuminate\Contracts\Events\Dispatcher
* @static
*/
public static function getDispatcher(){
return \Illuminate\Auth\Guard::getDispatcher();
}
/**
* Set the event dispatcher instance.
*
* @param \Illuminate\Contracts\Events\Dispatcher $events
* @return void
* @static
*/
public static function setDispatcher($events){
\Illuminate\Auth\Guard::setDispatcher($events);
}
/**
* Get the session store used by the guard.
*
* @return \Illuminate\Session\Store
* @static
*/
public static function getSession(){
return \Illuminate\Auth\Guard::getSession();
}
/**
* Get the user provider used by the guard.
*
* @return \Illuminate\Contracts\Auth\UserProvider
* @static
*/
public static function getProvider(){
return \Illuminate\Auth\Guard::getProvider();
}
/**
* Set the user provider used by the guard.
*
* @param \Illuminate\Contracts\Auth\UserProvider $provider
* @return void
* @static
*/
public static function setProvider($provider){
\Illuminate\Auth\Guard::setProvider($provider);
}
/**
* Return the currently cached user.
*
* @return \App\User|null
* @static
*/
public static function getUser(){
return \Illuminate\Auth\Guard::getUser();
}
/**
* Set the current user.
*
* @param \Illuminate\Contracts\Auth\Authenticatable $user
* @return void
* @static
*/
public static function setUser($user){
\Illuminate\Auth\Guard::setUser($user);
}
/**
* Get the current request instance.
*
* @return \Symfony\Component\HttpFoundation\Request
* @static
*/
public static function getRequest(){
return \Illuminate\Auth\Guard::getRequest();
}
/**
* Set the current request instance.
*
* @param \Symfony\Component\HttpFoundation\Request $request
* @return $this
* @static
*/
public static function setRequest($request){
return \Illuminate\Auth\Guard::setRequest($request);
}
/**
* Get the last user we attempted to authenticate.
*
* @return \App\User
* @static
*/
public static function getLastAttempted(){
return \Illuminate\Auth\Guard::getLastAttempted();
}
/**
* Get a unique identifier for the auth session value.
*
* @return string
* @static
*/
public static function getName(){
return \Illuminate\Auth\Guard::getName();
}
/**
* Get the name of the cookie used to store the "recaller".
*
* @return string
* @static
*/
public static function getRecallerName(){
return \Illuminate\Auth\Guard::getRecallerName();
}
/**
* Determine if the user was authenticated via "remember me" cookie.
*
* @return bool
* @static
*/
public static function viaRemember(){
return \Illuminate\Auth\Guard::viaRemember();
}
}
class Bus extends \Illuminate\Support\Facades\Bus{
/**
* Marshal a command and dispatch it to its appropriate handler.
*
* @param mixed $command
* @param array $array
* @return mixed
* @static
*/
public static function dispatchFromArray($command, $array){
return \Illuminate\Bus\Dispatcher::dispatchFromArray($command, $array);
}
/**
* Marshal a command and dispatch it to its appropriate handler.
*
* @param mixed $command
* @param \ArrayAccess $source
* @param array $extras
* @return mixed
* @static
*/
public static function dispatchFrom($command, $source, $extras = array()){
return \Illuminate\Bus\Dispatcher::dispatchFrom($command, $source, $extras);
}
/**
* Dispatch a command to its appropriate handler.
*
* @param mixed $command
* @param \Closure|null $afterResolving
* @return mixed
* @static
*/
public static function dispatch($command, $afterResolving = null){
return \Illuminate\Bus\Dispatcher::dispatch($command, $afterResolving);
}
/**
* Dispatch a command to its appropriate handler in the current process.
*
* @param mixed $command
* @param \Closure|null $afterResolving
* @return mixed
* @static
*/
public static function dispatchNow($command, $afterResolving = null){
return \Illuminate\Bus\Dispatcher::dispatchNow($command, $afterResolving);
}
/**
* Dispatch a command to its appropriate handler behind a queue.
*
* @param mixed $command
* @return mixed
* @throws \RuntimeException
* @static
*/
public static function dispatchToQueue($command){
return \Illuminate\Bus\Dispatcher::dispatchToQueue($command);
}
/**
* Get the handler instance for the given command.
*
* @param mixed $command
* @return mixed
* @static
*/
public static function resolveHandler($command){
return \Illuminate\Bus\Dispatcher::resolveHandler($command);
}
/**
* Get the handler class for the given command.
*
* @param mixed $command
* @return string
* @static
*/
public static function getHandlerClass($command){
return \Illuminate\Bus\Dispatcher::getHandlerClass($command);
}
/**
* Get the handler method for the given command.
*
* @param mixed $command
* @return string
* @static
*/
public static function getHandlerMethod($command){
return \Illuminate\Bus\Dispatcher::getHandlerMethod($command);
}
/**
* Register command-to-handler mappings.
*
* @param array $commands
* @return void
* @static
*/
public static function maps($commands){
\Illuminate\Bus\Dispatcher::maps($commands);
}
/**
* Register a fallback mapper callback.
*
* @param \Closure $mapper
* @return void
* @static
*/
public static function mapUsing($mapper){
\Illuminate\Bus\Dispatcher::mapUsing($mapper);
}
/**
* Map the command to a handler within a given root namespace.
*
* @param mixed $command
* @param string $commandNamespace
* @param string $handlerNamespace
* @return string
* @static
*/
public static function simpleMapping($command, $commandNamespace, $handlerNamespace){
return \Illuminate\Bus\Dispatcher::simpleMapping($command, $commandNamespace, $handlerNamespace);
}
/**
* Set the pipes through which commands should be piped before dispatching.
*
* @param array $pipes
* @return $this
* @static
*/
public static function pipeThrough($pipes){
return \Illuminate\Bus\Dispatcher::pipeThrough($pipes);
}
}
class DB extends \Illuminate\Support\Facades\DB{
/**
* Get a database connection instance.
*
* @param string $name
* @return \Illuminate\Database\Connection
* @static
*/
public static function connection($name = null){
return \Illuminate\Database\DatabaseManager::connection($name);
}
/**
* Disconnect from the given database and remove from local cache.
*
* @param string $name
* @return void
* @static
*/
public static function purge($name = null){
\Illuminate\Database\DatabaseManager::purge($name);
}
/**
* Disconnect from the given database.
*
* @param string $name
* @return void
* @static
*/
public static function disconnect($name = null){
\Illuminate\Database\DatabaseManager::disconnect($name);
}
/**
* Reconnect to the given database.
*
* @param string $name
* @return \Illuminate\Database\Connection
* @static
*/
public static function reconnect($name = null){
return \Illuminate\Database\DatabaseManager::reconnect($name);
}
/**
* Get the default connection name.
*
* @return string
* @static
*/
public static function getDefaultConnection(){
return \Illuminate\Database\DatabaseManager::getDefaultConnection();
}
/**
* Set the default connection name.
*
* @param string $name
* @return void
* @static
*/
public static function setDefaultConnection($name){
\Illuminate\Database\DatabaseManager::setDefaultConnection($name);
}
/**
* Register an extension connection resolver.
*
* @param string $name
* @param callable $resolver
* @return void
* @static
*/
public static function extend($name, $resolver){
\Illuminate\Database\DatabaseManager::extend($name, $resolver);
}
/**
* Return all of the created connections.
*
* @return array
* @static
*/
public static function getConnections(){
return \Illuminate\Database\DatabaseManager::getConnections();
}
/**
* Get a schema builder instance for the connection.
*
* @return \Illuminate\Database\Schema\MySqlBuilder
* @static
*/
public static function getSchemaBuilder(){
return \Illuminate\Database\MySqlConnection::getSchemaBuilder();
}
/**
* Set the query grammar to the default implementation.
*
* @return void
* @static
*/
public static function useDefaultQueryGrammar(){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::useDefaultQueryGrammar();
}
/**
* Set the schema grammar to the default implementation.
*
* @return void
* @static
*/
public static function useDefaultSchemaGrammar(){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::useDefaultSchemaGrammar();
}
/**
* Set the query post processor to the default implementation.
*
* @return void
* @static
*/
public static function useDefaultPostProcessor(){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::useDefaultPostProcessor();
}
/**
* Begin a fluent query against a database table.
*
* @param string $table
* @return \Illuminate\Database\Query\Builder
* @static
*/
public static function table($table){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::table($table);
}
/**
* Get a new raw query expression.
*
* @param mixed $value
* @return \Illuminate\Database\Query\Expression
* @static
*/
public static function raw($value){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::raw($value);
}
/**
* Run a select statement and return a single result.
*
* @param string $query
* @param array $bindings
* @return mixed
* @static
*/
public static function selectOne($query, $bindings = array()){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::selectOne($query, $bindings);
}
/**
* Run a select statement against the database.
*
* @param string $query
* @param array $bindings
* @return array
* @static
*/
public static function selectFromWriteConnection($query, $bindings = array()){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::selectFromWriteConnection($query, $bindings);
}
/**
* Run a select statement against the database.
*
* @param string $query
* @param array $bindings
* @param bool $useReadPdo
* @return array
* @static
*/
public static function select($query, $bindings = array(), $useReadPdo = true){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::select($query, $bindings, $useReadPdo);
}
/**
* Run an insert statement against the database.
*
* @param string $query
* @param array $bindings
* @return bool
* @static
*/
public static function insert($query, $bindings = array()){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::insert($query, $bindings);
}
/**
* Run an update statement against the database.
*
* @param string $query
* @param array $bindings
* @return int
* @static
*/
public static function update($query, $bindings = array()){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::update($query, $bindings);
}
/**
* Run a delete statement against the database.
*
* @param string $query
* @param array $bindings
* @return int
* @static
*/
public static function delete($query, $bindings = array()){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::delete($query, $bindings);
}
/**
* Execute an SQL statement and return the boolean result.
*
* @param string $query
* @param array $bindings
* @return bool
* @static
*/
public static function statement($query, $bindings = array()){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::statement($query, $bindings);
}
/**
* Run an SQL statement and get the number of rows affected.
*
* @param string $query
* @param array $bindings
* @return int
* @static
*/
public static function affectingStatement($query, $bindings = array()){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::affectingStatement($query, $bindings);
}
/**
* Run a raw, unprepared query against the PDO connection.
*
* @param string $query
* @return bool
* @static
*/
public static function unprepared($query){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::unprepared($query);
}
/**
* Prepare the query bindings for execution.
*
* @param array $bindings
* @return array
* @static
*/
public static function prepareBindings($bindings){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::prepareBindings($bindings);
}
/**
* Execute a Closure within a transaction.
*
* @param \Closure $callback
* @return mixed
* @throws \Throwable
* @static
*/
public static function transaction($callback){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::transaction($callback);
}
/**
* Start a new database transaction.
*
* @return void
* @static
*/
public static function beginTransaction(){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::beginTransaction();
}
/**
* Commit the active database transaction.
*
* @return void
* @static
*/
public static function commit(){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::commit();
}
/**
* Rollback the active database transaction.
*
* @return void
* @static
*/
public static function rollBack(){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::rollBack();
}
/**
* Get the number of active transactions.
*
* @return int
* @static
*/
public static function transactionLevel(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::transactionLevel();
}
/**
* Execute the given callback in "dry run" mode.
*
* @param \Closure $callback
* @return array
* @static
*/
public static function pretend($callback){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::pretend($callback);
}
/**
* Log a query in the connection's query log.
*
* @param string $query
* @param array $bindings
* @param float|null $time
* @return void
* @static
*/
public static function logQuery($query, $bindings, $time = null){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::logQuery($query, $bindings, $time);
}
/**
* Register a database query listener with the connection.
*
* @param \Closure $callback
* @return void
* @static
*/
public static function listen($callback){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::listen($callback);
}
/**
* Get a Doctrine Schema Column instance.
*
* @param string $table
* @param string $column
* @return \Doctrine\DBAL\Schema\Column
* @static
*/
public static function getDoctrineColumn($table, $column){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getDoctrineColumn($table, $column);
}
/**
* Get the Doctrine DBAL schema manager for the connection.
*
* @return \Doctrine\DBAL\Schema\AbstractSchemaManager
* @static
*/
public static function getDoctrineSchemaManager(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getDoctrineSchemaManager();
}
/**
* Get the Doctrine DBAL database connection instance.
*
* @return \Doctrine\DBAL\Connection
* @static
*/
public static function getDoctrineConnection(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getDoctrineConnection();
}
/**
* Get the current PDO connection.
*
* @return \PDO
* @static
*/
public static function getPdo(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getPdo();
}
/**
* Get the current PDO connection used for reading.
*
* @return \PDO
* @static
*/
public static function getReadPdo(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getReadPdo();
}
/**
* Set the PDO connection.
*
* @param \PDO|null $pdo
* @return $this
* @static
*/
public static function setPdo($pdo){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::setPdo($pdo);
}
/**
* Set the PDO connection used for reading.
*
* @param \PDO|null $pdo
* @return $this
* @static
*/
public static function setReadPdo($pdo){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::setReadPdo($pdo);
}
/**
* Set the reconnect instance on the connection.
*
* @param callable $reconnector
* @return $this
* @static
*/
public static function setReconnector($reconnector){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::setReconnector($reconnector);
}
/**
* Get the database connection name.
*
* @return string|null
* @static
*/
public static function getName(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getName();
}
/**
* Get an option from the configuration options.
*
* @param string $option
* @return mixed
* @static
*/
public static function getConfig($option){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getConfig($option);
}
/**
* Get the PDO driver name.
*
* @return string
* @static
*/
public static function getDriverName(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getDriverName();
}
/**
* Get the query grammar used by the connection.
*
* @return \Illuminate\Database\Query\Grammars\Grammar
* @static
*/
public static function getQueryGrammar(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getQueryGrammar();
}
/**
* Set the query grammar used by the connection.
*
* @param \Illuminate\Database\Query\Grammars\Grammar $grammar
* @return void
* @static
*/
public static function setQueryGrammar($grammar){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::setQueryGrammar($grammar);
}
/**
* Get the schema grammar used by the connection.
*
* @return \Illuminate\Database\Schema\Grammars\Grammar
* @static
*/
public static function getSchemaGrammar(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getSchemaGrammar();
}
/**
* Set the schema grammar used by the connection.
*
* @param \Illuminate\Database\Schema\Grammars\Grammar $grammar
* @return void
* @static
*/
public static function setSchemaGrammar($grammar){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::setSchemaGrammar($grammar);
}
/**
* Get the query post processor used by the connection.
*
* @return \Illuminate\Database\Query\Processors\Processor
* @static
*/
public static function getPostProcessor(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getPostProcessor();
}
/**
* Set the query post processor used by the connection.
*
* @param \Illuminate\Database\Query\Processors\Processor $processor
* @return void
* @static
*/
public static function setPostProcessor($processor){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::setPostProcessor($processor);
}
/**
* Get the event dispatcher used by the connection.
*
* @return \Illuminate\Contracts\Events\Dispatcher
* @static
*/
public static function getEventDispatcher(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getEventDispatcher();
}
/**
* Set the event dispatcher instance on the connection.
*
* @param \Illuminate\Contracts\Events\Dispatcher $events
* @return void
* @static
*/
public static function setEventDispatcher($events){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::setEventDispatcher($events);
}
/**
* Determine if the connection in a "dry run".
*
* @return bool
* @static
*/
public static function pretending(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::pretending();
}
/**
* Get the default fetch mode for the connection.
*
* @return int
* @static
*/
public static function getFetchMode(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getFetchMode();
}
/**
* Set the default fetch mode for the connection.
*
* @param int $fetchMode
* @return int
* @static
*/
public static function setFetchMode($fetchMode){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::setFetchMode($fetchMode);
}
/**
* Get the connection query log.
*
* @return array
* @static
*/
public static function getQueryLog(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getQueryLog();
}
/**
* Clear the query log.
*
* @return void
* @static
*/
public static function flushQueryLog(){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::flushQueryLog();
}
/**
* Enable the query log on the connection.
*
* @return void
* @static
*/
public static function enableQueryLog(){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::enableQueryLog();
}
/**
* Disable the query log on the connection.
*
* @return void
* @static
*/
public static function disableQueryLog(){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::disableQueryLog();
}
/**
* Determine whether we're logging queries.
*
* @return bool
* @static
*/
public static function logging(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::logging();
}
/**
* Get the name of the connected database.
*
* @return string
* @static
*/
public static function getDatabaseName(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getDatabaseName();
}
/**
* Set the name of the connected database.
*
* @param string $database
* @return string
* @static
*/
public static function setDatabaseName($database){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::setDatabaseName($database);
}
/**
* Get the table prefix for the connection.
*
* @return string
* @static
*/
public static function getTablePrefix(){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::getTablePrefix();
}
/**
* Set the table prefix in use by the connection.
*
* @param string $prefix
* @return void
* @static
*/
public static function setTablePrefix($prefix){
//Method inherited from \Illuminate\Database\Connection
\Illuminate\Database\MySqlConnection::setTablePrefix($prefix);
}
/**
* Set the table prefix and return the grammar.
*
* @param \Illuminate\Database\Grammar $grammar
* @return \Illuminate\Database\Grammar
* @static
*/
public static function withTablePrefix($grammar){
//Method inherited from \Illuminate\Database\Connection
return \Illuminate\Database\MySqlConnection::withTablePrefix($grammar);
}
}
class Cache extends \Illuminate\Support\Facades\Cache{
/**
* Get a cache store instance by name.
*
* @param string|null $name
* @return mixed
* @static
*/
public static function store($name = null){
return \Illuminate\Cache\CacheManager::store($name);
}
/**
* Get a cache driver instance.
*
* @param string $driver
* @return mixed
* @static
*/
public static function driver($driver = null){
return \Illuminate\Cache\CacheManager::driver($driver);
}
/**
* Create a new cache repository with the given implementation.
*
* @param \Illuminate\Contracts\Cache\Store $store
* @return \Illuminate\Cache\Repository
* @static
*/
public static function repository($store){
return \Illuminate\Cache\CacheManager::repository($store);
}
/**
* Get the default cache driver name.
*
* @return string
* @static
*/
public static function getDefaultDriver(){
return \Illuminate\Cache\CacheManager::getDefaultDriver();
}
/**
* Set the default cache driver name.
*
* @param string $name
* @return void
* @static
*/
public static function setDefaultDriver($name){
\Illuminate\Cache\CacheManager::setDefaultDriver($name);
}
/**
* Register a custom driver creator Closure.
*
* @param string $driver
* @param \Closure $callback
* @return $this
* @static
*/
public static function extend($driver, $callback){
return \Illuminate\Cache\CacheManager::extend($driver, $callback);
}
/**
* Set the event dispatcher instance.
*
* @param \Illuminate\Contracts\Events\Dispatcher $events
* @return void
* @static
*/
public static function setEventDispatcher($events){
\Illuminate\Cache\Repository::setEventDispatcher($events);
}
/**
* Determine if an item exists in the cache.
*
* @param string $key
* @return bool
* @static
*/
public static function has($key){
return \Illuminate\Cache\Repository::has($key);
}
/**
* Retrieve an item from the cache by key.
*
* @param string $key
* @param mixed $default
* @return mixed
* @static
*/
public static function get($key, $default = null){
return \Illuminate\Cache\Repository::get($key, $default);
}
/**
* Retrieve an item from the cache and delete it.
*
* @param string $key
* @param mixed $default
* @return mixed
* @static
*/
public static function pull($key, $default = null){
return \Illuminate\Cache\Repository::pull($key, $default);
}
/**
* Store an item in the cache.
*
* @param string $key
* @param mixed $value
* @param \DateTime|int $minutes
* @return void
* @static
*/
public static function put($key, $value, $minutes){
\Illuminate\Cache\Repository::put($key, $value, $minutes);
}
/**
* Store an item in the cache if the key does not exist.
*
* @param string $key
* @param mixed $value
* @param \DateTime|int $minutes
* @return bool
* @static
*/
public static function add($key, $value, $minutes){
return \Illuminate\Cache\Repository::add($key, $value, $minutes);
}
/**
* Store an item in the cache indefinitely.
*
* @param string $key
* @param mixed $value
* @return void
* @static
*/
public static function forever($key, $value){
\Illuminate\Cache\Repository::forever($key, $value);
}
/**
* Get an item from the cache, or store the default value.
*
* @param string $key
* @param \DateTime|int $minutes
* @param \Closure $callback
* @return mixed
* @static
*/
public static function remember($key, $minutes, $callback){
return \Illuminate\Cache\Repository::remember($key, $minutes, $callback);
}
/**
* Get an item from the cache, or store the default value forever.
*
* @param string $key
* @param \Closure $callback
* @return mixed
* @static
*/
public static function sear($key, $callback){
return \Illuminate\Cache\Repository::sear($key, $callback);
}
/**
* Get an item from the cache, or store the default value forever.
*
* @param string $key
* @param \Closure $callback
* @return mixed
* @static
*/
public static function rememberForever($key, $callback){
return \Illuminate\Cache\Repository::rememberForever($key, $callback);
}
/**
* Remove an item from the cache.
*
* @param string $key
* @return bool
* @static
*/
public static function forget($key){
return \Illuminate\Cache\Repository::forget($key);
}
/**
* Get the default cache time.
*
* @return int
* @static
*/
public static function getDefaultCacheTime(){
return \Illuminate\Cache\Repository::getDefaultCacheTime();
}
/**
* Set the default cache time in minutes.
*
* @param int $minutes
* @return void
* @static
*/
public static function setDefaultCacheTime($minutes){
\Illuminate\Cache\Repository::setDefaultCacheTime($minutes);
}
/**
* Get the cache store implementation.
*
* @return \Illuminate\Contracts\Cache\Store
* @static
*/
public static function getStore(){
return \Illuminate\Cache\Repository::getStore();
}
/**
* Determine if a cached value exists.
*
* @param string $key
* @return bool
* @static
*/
public static function offsetExists($key){
return \Illuminate\Cache\Repository::offsetExists($key);
}
/**
* Retrieve an item from the cache by key.
*
* @param string $key
* @return mixed
* @static
*/
public static function offsetGet($key){
return \Illuminate\Cache\Repository::offsetGet($key);
}
/**
* Store an item in the cache for the default time.
*
* @param string $key
* @param mixed $value
* @return void
* @static
*/
public static function offsetSet($key, $value){
\Illuminate\Cache\Repository::offsetSet($key, $value);
}
/**
* Remove an item from the cache.
*
* @param string $key
* @return void
* @static
*/
public static function offsetUnset($key){
\Illuminate\Cache\Repository::offsetUnset($key);
}
/**
* Register a custom macro.
*
* @param string $name
* @param callable $macro
* @return void
* @static
*/
public static function macro($name, $macro){
\Illuminate\Cache\Repository::macro($name, $macro);
}
/**
* Checks if macro is registered.
*
* @param string $name
* @return bool
* @static
*/
public static function hasMacro($name){
return \Illuminate\Cache\Repository::hasMacro($name);
}
/**
* Dynamically handle calls to the class.
*
* @param string $method
* @param array $parameters
* @return mixed
* @throws \BadMethodCallException
* @static
*/
public static function macroCall($method, $parameters){
return \Illuminate\Cache\Repository::macroCall($method, $parameters);
}
/**
* Increment the value of an item in the cache.
*
* @param string $key
* @param mixed $value
* @return int
* @static
*/
public static function increment($key, $value = 1){
return \Illuminate\Cache\FileStore::increment($key, $value);
}
/**
* Decrement the value of an item in the cache.
*
* @param string $key
* @param mixed $value
* @return int
* @static
*/
public static function decrement($key, $value = 1){
return \Illuminate\Cache\FileStore::decrement($key, $value);
}
/**
* Remove all items from the cache.
*
* @return void
* @static
*/
public static function flush(){
\Illuminate\Cache\FileStore::flush();
}
/**
* Get the Filesystem instance.
*
* @return \Illuminate\Filesystem\Filesystem
* @static
*/
public static function getFilesystem(){
return \Illuminate\Cache\FileStore::getFilesystem();
}
/**
* Get the working directory of the cache.
*
* @return string
* @static
*/
public static function getDirectory(){
return \Illuminate\Cache\FileStore::getDirectory();
}
/**
* Get the cache key prefix.
*
* @return string
* @static
*/
public static function getPrefix(){
return \Illuminate\Cache\FileStore::getPrefix();
}
}
class Cookie extends \Illuminate\Support\Facades\Cookie{
/**
* Create a new cookie instance.
*
* @param string $name
* @param string $value
* @param int $minutes
* @param string $path
* @param string $domain
* @param bool $secure
* @param bool $httpOnly
* @return \Symfony\Component\HttpFoundation\Cookie
* @static
*/
public static function make($name, $value, $minutes = 0, $path = null, $domain = null, $secure = false, $httpOnly = true){
return \Illuminate\Cookie\CookieJar::make($name, $value, $minutes, $path, $domain, $secure, $httpOnly);
}
/**
* Create a cookie that lasts "forever" (five years).
*
* @param string $name
* @param string $value
* @param string $path
* @param string $domain
* @param bool $secure
* @param bool $httpOnly
* @return \Symfony\Component\HttpFoundation\Cookie
* @static
*/
public static function forever($name, $value, $path = null, $domain = null, $secure = false, $httpOnly = true){
return \Illuminate\Cookie\CookieJar::forever($name, $value, $path, $domain, $secure, $httpOnly);
}
/**
* Expire the given cookie.
*
* @param string $name
* @param string $path
* @param string $domain
* @return \Symfony\Component\HttpFoundation\Cookie
* @static
*/
public static function forget($name, $path = null, $domain = null){
return \Illuminate\Cookie\CookieJar::forget($name, $path, $domain);
}
/**
* Determine if a cookie has been queued.
*
* @param string $key
* @return bool
* @static
*/
public static function hasQueued($key){
return \Illuminate\Cookie\CookieJar::hasQueued($key);
}
/**
* Get a queued cookie instance.
*
* @param string $key
* @param mixed $default
* @return \Symfony\Component\HttpFoundation\Cookie
* @static
*/
public static function queued($key, $default = null){
return \Illuminate\Cookie\CookieJar::queued($key, $default);
}
/**
* Queue a cookie to send with the next response.
*
* @param mixed
* @return void
* @static
*/
public static function queue(){
\Illuminate\Cookie\CookieJar::queue();
}
/**
* Remove a cookie from the queue.
*
* @param string $name
* @static
*/
public static function unqueue($name){
return \Illuminate\Cookie\CookieJar::unqueue($name);
}
/**
* Set the default path and domain for the jar.
*
* @param string $path
* @param string $domain
* @return $this
* @static
*/
public static function setDefaultPathAndDomain($path, $domain){
return \Illuminate\Cookie\CookieJar::setDefaultPathAndDomain($path, $domain);
}
/**
* Get the cookies which have been queued for the next request.
*
* @return array
* @static
*/
public static function getQueuedCookies(){
return \Illuminate\Cookie\CookieJar::getQueuedCookies();
}
}
class Crypt extends \Illuminate\Support\Facades\Crypt{
/**
* Determine if the given key and cipher combination is valid.
*
* @param string $key
* @param string $cipher
* @return bool
* @static
*/
public static function supported($key, $cipher){
return \Illuminate\Encryption\Encrypter::supported($key, $cipher);
}
/**
* Encrypt the given value.
*
* @param string $value
* @return string
* @static
*/
public static function encrypt($value){
return \Illuminate\Encryption\Encrypter::encrypt($value);
}
/**
* Decrypt the given value.
*
* @param string $payload
* @return string
* @static
*/
public static function decrypt($payload){
return \Illuminate\Encryption\Encrypter::decrypt($payload);
}
}
class Event extends \Illuminate\Support\Facades\Event{
/**
* Register an event listener with the dispatcher.
*
* @param string|array $events
* @param mixed $listener
* @param int $priority
* @return void
* @static
*/
public static function listen($events, $listener, $priority = 0){
\Illuminate\Events\Dispatcher::listen($events, $listener, $priority);
}
/**
* Determine if a given event has listeners.
*
* @param string $eventName
* @return bool
* @static
*/
public static function hasListeners($eventName){
return \Illuminate\Events\Dispatcher::hasListeners($eventName);
}
/**
* Register an event and payload to be fired later.
*
* @param string $event
* @param array $payload
* @return void
* @static
*/
public static function push($event, $payload = array()){
\Illuminate\Events\Dispatcher::push($event, $payload);
}
/**
* Register an event subscriber with the dispatcher.
*
* @param object|string $subscriber
* @return void
* @static
*/
public static function subscribe($subscriber){
\Illuminate\Events\Dispatcher::subscribe($subscriber);
}
/**
* Fire an event until the first non-null response is returned.
*
* @param string|object $event
* @param array $payload
* @return mixed
* @static
*/
public static function until($event, $payload = array()){
return \Illuminate\Events\Dispatcher::until($event, $payload);
}
/**
* Flush a set of pushed events.
*
* @param string $event
* @return void
* @static
*/
public static function flush($event){
\Illuminate\Events\Dispatcher::flush($event);
}
/**
* Get the event that is currently firing.
*
* @return string
* @static
*/
public static function firing(){
return \Illuminate\Events\Dispatcher::firing();
}
/**
* Fire an event and call the listeners.
*
* @param string|object $event
* @param mixed $payload
* @param bool $halt
* @return array|null
* @static
*/
public static function fire($event, $payload = array(), $halt = false){
return \Illuminate\Events\Dispatcher::fire($event, $payload, $halt);
}
/**
* Get all of the listeners for a given event name.
*
* @param string $eventName
* @return array
* @static
*/
public static function getListeners($eventName){
return \Illuminate\Events\Dispatcher::getListeners($eventName);
}
/**
* Register an event listener with the dispatcher.
*
* @param mixed $listener
* @return mixed
* @static
*/
public static function makeListener($listener){
return \Illuminate\Events\Dispatcher::makeListener($listener);
}
/**
* Create a class based listener using the IoC container.
*
* @param mixed $listener
* @return \Closure
* @static
*/
public static function createClassListener($listener){
return \Illuminate\Events\Dispatcher::createClassListener($listener);
}
/**
* Remove a set of listeners from the dispatcher.
*
* @param string $event
* @return void
* @static
*/
public static function forget($event){
\Illuminate\Events\Dispatcher::forget($event);
}
/**
* Forget all of the pushed listeners.
*
* @return void
* @static
*/
public static function forgetPushed(){
\Illuminate\Events\Dispatcher::forgetPushed();
}
/**
* Set the queue resolver implementation.
*
* @param callable $resolver
* @return $this
* @static
*/
public static function setQueueResolver($resolver){
return \Illuminate\Events\Dispatcher::setQueueResolver($resolver);
}
}
class Hash extends \Illuminate\Support\Facades\Hash{
/**
* Hash the given value.
*
* @param string $value
* @param array $options
* @return string
* @throws \RuntimeException
* @static
*/
public static function make($value, $options = array()){
return \Illuminate\Hashing\BcryptHasher::make($value, $options);
}
/**
* Check the given plain value against a hash.
*
* @param string $value
* @param string $hashedValue
* @param array $options
* @return bool
* @static
*/
public static function check($value, $hashedValue, $options = array()){
return \Illuminate\Hashing\BcryptHasher::check($value, $hashedValue, $options);
}
/**
* Check if the given hash has been hashed using the given options.
*
* @param string $hashedValue
* @param array $options
* @return bool
* @static
*/
public static function needsRehash($hashedValue, $options = array()){
return \Illuminate\Hashing\BcryptHasher::needsRehash($hashedValue, $options);
}
/**
* Set the default password work factor.
*
* @param int $rounds
* @return $this
* @static
*/
public static function setRounds($rounds){
return \Illuminate\Hashing\BcryptHasher::setRounds($rounds);
}
}
class Log extends \Illuminate\Support\Facades\Log{
/**
* Adds a log record at the DEBUG level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function debug($message, $context = array()){
return \Monolog\Logger::debug($message, $context);
}
/**
* Adds a log record at the INFO level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function info($message, $context = array()){
return \Monolog\Logger::info($message, $context);
}
/**
* Adds a log record at the NOTICE level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function notice($message, $context = array()){
return \Monolog\Logger::notice($message, $context);
}
/**
* Adds a log record at the WARNING level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function warning($message, $context = array()){
return \Monolog\Logger::warning($message, $context);
}
/**
* Adds a log record at the ERROR level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function error($message, $context = array()){
return \Monolog\Logger::error($message, $context);
}
/**
* Adds a log record at the CRITICAL level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function critical($message, $context = array()){
return \Monolog\Logger::critical($message, $context);
}
/**
* Adds a log record at the ALERT level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function alert($message, $context = array()){
return \Monolog\Logger::alert($message, $context);
}
/**
* Adds a log record at the EMERGENCY level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function emergency($message, $context = array()){
return \Monolog\Logger::emergency($message, $context);
}
/**
*
*
* @return string
* @static
*/
public static function getName(){
return \Monolog\Logger::getName();
}
/**
* Pushes a handler on to the stack.
*
* @param \Monolog\HandlerInterface $handler
* @return $this
* @static
*/
public static function pushHandler($handler){
return \Monolog\Logger::pushHandler($handler);
}
/**
* Pops a handler from the stack
*
* @return \Monolog\HandlerInterface
* @static
*/
public static function popHandler(){
return \Monolog\Logger::popHandler();
}
/**
* Set handlers, replacing all existing ones.
*
* If a map is passed, keys will be ignored.
*
* @param \Monolog\HandlerInterface[] $handlers
* @return $this
* @static
*/
public static function setHandlers($handlers){
return \Monolog\Logger::setHandlers($handlers);
}
/**
*
*
* @return \Monolog\HandlerInterface[]
* @static
*/
public static function getHandlers(){
return \Monolog\Logger::getHandlers();
}
/**
* Adds a processor on to the stack.
*
* @param callable $callback
* @return $this
* @static
*/
public static function pushProcessor($callback){
return \Monolog\Logger::pushProcessor($callback);
}
/**
* Removes the processor on top of the stack and returns it.
*
* @return callable
* @static
*/
public static function popProcessor(){
return \Monolog\Logger::popProcessor();
}
/**
*
*
* @return callable[]
* @static
*/
public static function getProcessors(){
return \Monolog\Logger::getProcessors();
}
/**
* Adds a log record.
*
* @param integer $level The logging level
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function addRecord($level, $message, $context = array()){
return \Monolog\Logger::addRecord($level, $message, $context);
}
/**
* Adds a log record at the DEBUG level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function addDebug($message, $context = array()){
return \Monolog\Logger::addDebug($message, $context);
}
/**
* Adds a log record at the INFO level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function addInfo($message, $context = array()){
return \Monolog\Logger::addInfo($message, $context);
}
/**
* Adds a log record at the NOTICE level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function addNotice($message, $context = array()){
return \Monolog\Logger::addNotice($message, $context);
}
/**
* Adds a log record at the WARNING level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function addWarning($message, $context = array()){
return \Monolog\Logger::addWarning($message, $context);
}
/**
* Adds a log record at the ERROR level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function addError($message, $context = array()){
return \Monolog\Logger::addError($message, $context);
}
/**
* Adds a log record at the CRITICAL level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function addCritical($message, $context = array()){
return \Monolog\Logger::addCritical($message, $context);
}
/**
* Adds a log record at the ALERT level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function addAlert($message, $context = array()){
return \Monolog\Logger::addAlert($message, $context);
}
/**
* Adds a log record at the EMERGENCY level.
*
* @param string $message The log message
* @param array $context The log context
* @return Boolean Whether the record has been processed
* @static
*/
public static function addEmergency($message, $context = array()){
return \Monolog\Logger::addEmergency($message, $context);
}
/**
* Gets all supported logging levels.
*
* @return array Assoc array with human-readable level names => level codes.
* @static
*/
public static function getLevels(){
return \Monolog\Logger::getLevels();
}
/**
* Gets the name of the logging level.
*
* @param integer $level
* @return string
* @static
*/
public static function getLevelName($level){
return \Monolog\Logger::getLevelName($level);
}
/**
* Converts PSR-3 levels to Monolog ones if necessary
*
* @param string|int Level number (monolog) or name (PSR-3)
* @return int
* @static
*/
public static function toMonologLevel($level){
return \Monolog\Logger::toMonologLevel($level);
}
/**
* Checks whether the Logger has a handler that listens on the given level
*