Register the bindings for the main JWTAuth class.

@return void
856
protected function registerJWTAuth()
    {
        $this->app->singleton('tymon.jwt.auth', function ($app) {
            return (new JWTAuth(
                $app['tymon.jwt.manager'],
                $app['tymon.jwt.provider.auth'],
                $app['tymon.jwt.parser']
            ))->lockSubject($this->config('lock_subject'));
        });
    }
751821
public function register()
	{

		$this->app->bindShared('weloquent.globaljs', function ($app)
		{

			return new GlobalJs($app);

		});

		/**
		 * Generate default values
		 */
		add_action('setup_theme', function(){
			$this->app['weloquent.globaljs']->generateNonce();
			$this->app['weloquent.globaljs']->generateAjaxUrl();

		});

		$this->registerFrontAction();

		$this->registerAdminAction();

	}
1153466
protected function registerBaseTenantBindings()
    {
        $this->singleton(TenantContract::class, function ($app) {
            return new Tenant(new NullUser(), new NullTenant(), new NullTenant());
        });

        $this->alias(TenantContract::class, 'auth.tenant');
    }
529784
protected function registerRequestRebindHandler()
    {
        $this->app->rebinding('request', function ($app, $request) {
            $request->setUserResolver(function ($guard = null) use ($app) {
                return call_user_func($app['auth']->userResolver(), $guard);
            });
        });
    }
721899
public function bindAuth()
    {
        $credentials = [
            'client_id' => env('AUTH_CLIENT_ID'),
            'client_secret' => env('AUTH_CLIENT_SECRET'),
            'username' => env('AUTH_SERVICE_USERNAME'),
            'password' => env('AUTH_SERVICE_PASSWORD'),
        ];

        // Bind token authenticator with its dependencies
        $this->app->bind(Authentication\TokenAuthenticator::class, function (Application $app) use ($credentials) {
            $client = $app->make('ej:sdk:guzzle');
            $cache = $app->make(Repository::class);

            return new Authentication\TokenAuthenticator($client, $cache, $credentials);
        });

        // Bind Authenticator contract to token auth as default implementation
        $this->app->bind(Authentication\Authenticator::class, function (Application $app) use ($credentials) {
            return $app->make(Authentication\TokenAuthenticator::class);
        });
    }
643734
protected function registerEventRebindHandler()
    {
        $this->app->rebinding('events', function ($app, $dispatcher) {
            if (! $app->resolved('auth')) {
                return;
            }

            if (method_exists($guard = $app['auth']->guard(), 'setDispatcher')) {
                $guard->setDispatcher($dispatcher);
            }
        });
    }
163148
protected function registerJWTProvider()
    {
        $this->registerNamshiProvider();
        $this->registerLcobucciProvider();

        $this->app->singleton('tymon.jwt.provider.jwt', function ($app) {
            return $this->getConfigInstance('providers.jwt');
        });
    }
1287861
protected function registerBaseBindings()
    {
        static::setInstance($this);

        $this->instance('app', $this);

        $this->instance(Container::class, $this);
    }
783178
protected function registerJwTProvider()
    {
        $this->app->singleton('afroware.jwT.provider.jwT', function ($app) {
            $provider = $this->config('providers.jwT');

            return new $provider(
                $this->config('secret'),
                $this->config('algo'),
                $this->config('keys')
            );
        });
    }
1038801
private function jwt()
    {
        if (!$this->jwt) {
            if (!$this->accessToken) {
                throw new EndpointException("No access token was provided");
            }

            $this->jwt = (new Parser())->parse($this->accessToken);
            $this->checkSignature();
        }
    }
789673
protected function registerAliases()
    {
        $this->app->alias('tymon.jwt', JWT::class);
        $this->app->alias('tymon.jwt.auth', JWTAuth::class);
        $this->app->alias('tymon.jwt.provider.jwt', JWTContract::class);
        $this->app->alias('tymon.jwt.provider.jwt.namshi', Namshi::class);
        $this->app->alias('tymon.jwt.provider.jwt.lcobucci', Lcobucci::class);
        $this->app->alias('tymon.jwt.provider.auth', Auth::class);
        $this->app->alias('tymon.jwt.provider.storage', Storage::class);
        $this->app->alias('tymon.jwt.manager', Manager::class);
        $this->app->alias('tymon.jwt.blacklist', Blacklist::class);
        $this->app->alias('tymon.jwt.payload.factory', Factory::class);
        $this->app->alias('tymon.jwt.validators.payload', PayloadValidator::class);
    }
99458
protected function registerJWTManager()
    {
        $this->app->singleton('lia.jwt.manager', function ($app) {
            $instance = new JWTManager(
                $app['lia.jwt.provider.jwt'],
                $app['lia.jwt.blacklist'],
                $app['lia.jwt.payload.factory']
            );

            return $instance->setBlacklistEnabled((bool) $this->config('blacklist_enabled'));
        });
    }
30927
private function registerNtrust()
    {
        $this->app->bind('ntrust', function ($app) {
            return new Ntrust($app);
        });
        
        $this->app->alias('ntrust', 'Klaravel\Ntrust');
    }
51431
public function register()
    {
        // JWTAuth
        $this->app->register(LumenJWTServiceProvider::class);

        // Dingo
        $this->app->register(LumenServiceProvider::class);

        // Configure our JWT for Dingo
        $this->app->register(DingoJWTDriverServiceProvider::class);
    }
460364
protected function registerJWTProvider()
    {
        $this->app->singleton('lia.jwt.provider.jwt', function ($app) {
            $secret = $this->config('secret');
            $algo = $this->config('algo');
            $provider = $this->config('providers.jwt');

            return new $provider($secret, $algo);
        });
    }
224221
protected function registerRequestBindings()
  {
    $this->singleton('Illuminate\Http\Request', function () {
      // create a new request object
      $request = Request::capture();
      // create an arbitrary response object
      $this->response = new Response;
      // get a SessionManager from the container
      $manager = $this['session'];
      // startup the StartSession middleware
      $middleware = new StartSession($manager);
      $middleware->handle($request, function() {
        return $this->response;
      });
      // print out any cookies created by the session system
      foreach($this->response->headers->getCookies() as $cookie) {
        @header('Set-Cookie: '.$cookie);
      }
      return $request;
    });
  }
965172
protected function registerJWTAuth()
    {
        $this->app->singleton('lia.jwt.auth', function ($app) {
            $auth = new JWTAuth(
                $app['lia.jwt.manager'],
                $app['lia.jwt.provider.user'],
                $app['lia.jwt.provider.auth'],
                $app['request']
            );

            return $auth->setIdentifier($this->config('identifier'));
        });
    }