vendor and env first commit

vendor/laravel/fortify/src/Http/Controllers/AuthenticatedSessionController.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Contracts\Auth\StatefulGuard;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Illuminate\Routing\Pipeline;
+use Laravel\Fortify\Actions\AttemptToAuthenticate;
+use Laravel\Fortify\Actions\CanonicalizeUsername;
+use Laravel\Fortify\Actions\EnsureLoginIsNotThrottled;
+use Laravel\Fortify\Actions\PrepareAuthenticatedSession;
+use Laravel\Fortify\Actions\RedirectIfTwoFactorAuthenticatable;
+use Laravel\Fortify\Contracts\LoginResponse;
+use Laravel\Fortify\Contracts\LoginViewResponse;
+use Laravel\Fortify\Contracts\LogoutResponse;
+use Laravel\Fortify\Features;
+use Laravel\Fortify\Fortify;
+use Laravel\Fortify\Http\Requests\LoginRequest;
+
+class AuthenticatedSessionController extends Controller
+{
+    /**
+     * The guard implementation.
+     *
+     * @var \Illuminate\Contracts\Auth\StatefulGuard
+     */
+    protected $guard;
+
+    /**
+     * Create a new controller instance.
+     *
+     * @param  \Illuminate\Contracts\Auth\StatefulGuard  $guard
+     * @return void
+     */
+    public function __construct(StatefulGuard $guard)
+    {
+        $this->guard = $guard;
+    }
+
+    /**
+     * Show the login view.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Laravel\Fortify\Contracts\LoginViewResponse
+     */
+    public function create(Request $request): LoginViewResponse
+    {
+        return app(LoginViewResponse::class);
+    }
+
+    /**
+     * Attempt to authenticate a new session.
+     *
+     * @param  \Laravel\Fortify\Http\Requests\LoginRequest  $request
+     * @return mixed
+     */
+    public function store(LoginRequest $request)
+    {
+        return $this->loginPipeline($request)->then(function ($request) {
+            return app(LoginResponse::class);
+        });
+    }
+
+    /**
+     * Get the authentication pipeline instance.
+     *
+     * @param  \Laravel\Fortify\Http\Requests\LoginRequest  $request
+     * @return \Illuminate\Pipeline\Pipeline
+     */
+    protected function loginPipeline(LoginRequest $request)
+    {
+        if (Fortify::$authenticateThroughCallback) {
+            return (new Pipeline(app()))->send($request)->through(array_filter(
+                call_user_func(Fortify::$authenticateThroughCallback, $request)
+            ));
+        }
+
+        if (is_array(config('fortify.pipelines.login'))) {
+            return (new Pipeline(app()))->send($request)->through(array_filter(
+                config('fortify.pipelines.login')
+            ));
+        }
+
+        return (new Pipeline(app()))->send($request)->through(array_filter([
+            config('fortify.limiters.login') ? null : EnsureLoginIsNotThrottled::class,
+            config('fortify.lowercase_usernames') ? CanonicalizeUsername::class : null,
+            Features::enabled(Features::twoFactorAuthentication()) ? RedirectIfTwoFactorAuthenticatable::class : null,
+            AttemptToAuthenticate::class,
+            PrepareAuthenticatedSession::class,
+        ]));
+    }
+
+    /**
+     * Destroy an authenticated session.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Laravel\Fortify\Contracts\LogoutResponse
+     */
+    public function destroy(Request $request): LogoutResponse
+    {
+        $this->guard->logout();
+
+        if ($request->hasSession()) {
+            $request->session()->invalidate();
+            $request->session()->regenerateToken();
+        }
+
+        return app(LogoutResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/ConfirmablePasswordController.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Contracts\Auth\StatefulGuard;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Illuminate\Support\Facades\Date;
+use Laravel\Fortify\Actions\ConfirmPassword;
+use Laravel\Fortify\Contracts\ConfirmPasswordViewResponse;
+use Laravel\Fortify\Contracts\FailedPasswordConfirmationResponse;
+use Laravel\Fortify\Contracts\PasswordConfirmedResponse;
+
+class ConfirmablePasswordController extends Controller
+{
+    /**
+     * The guard implementation.
+     *
+     * @var \Illuminate\Contracts\Auth\StatefulGuard
+     */
+    protected $guard;
+
+    /**
+     * Create a new controller instance.
+     *
+     * @param  \Illuminate\Contracts\Auth\StatefulGuard  $guard
+     * @return void
+     */
+    public function __construct(StatefulGuard $guard)
+    {
+        $this->guard = $guard;
+    }
+
+    /**
+     * Show the confirm password view.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Laravel\Fortify\Contracts\ConfirmPasswordViewResponse
+     */
+    public function show(Request $request)
+    {
+        return app(ConfirmPasswordViewResponse::class);
+    }
+
+    /**
+     * Confirm the user's password.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Contracts\Support\Responsable
+     */
+    public function store(Request $request)
+    {
+        $confirmed = app(ConfirmPassword::class)(
+            $this->guard, $request->user(), $request->input('password')
+        );
+
+        if ($confirmed) {
+            $request->session()->put('auth.password_confirmed_at', Date::now()->unix());
+        }
+
+        return $confirmed
+                    ? app(PasswordConfirmedResponse::class)
+                    : app(FailedPasswordConfirmationResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/ConfirmedPasswordStatusController.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+
+class ConfirmedPasswordStatusController extends Controller
+{
+    /**
+     * Get the password confirmation status.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\JsonResponse
+     */
+    public function show(Request $request)
+    {
+        return response()->json([
+            'confirmed' => (time() - $request->session()->get('auth.password_confirmed_at', 0)) < $request->input('seconds', config('auth.password_timeout', 900)),
+        ]);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/ConfirmedTwoFactorAuthenticationController.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Laravel\Fortify\Actions\ConfirmTwoFactorAuthentication;
+use Laravel\Fortify\Contracts\TwoFactorConfirmedResponse;
+
+class ConfirmedTwoFactorAuthenticationController extends Controller
+{
+    /**
+     * Enable two factor authentication for the user.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Laravel\Fortify\Actions\ConfirmTwoFactorAuthentication  $confirm
+     * @return \Laravel\Fortify\Contracts\TwoFactorConfirmedResponse
+     */
+    public function store(Request $request, ConfirmTwoFactorAuthentication $confirm)
+    {
+        $confirm($request->user(), $request->input('code'));
+
+        return app(TwoFactorConfirmedResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/EmailVerificationNotificationController.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Laravel\Fortify\Contracts\EmailVerificationNotificationSentResponse;
+use Laravel\Fortify\Http\Responses\RedirectAsIntended;
+
+class EmailVerificationNotificationController extends Controller
+{
+    /**
+     * Send a new email verification notification.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\Response
+     */
+    public function store(Request $request)
+    {
+        if ($request->user()->hasVerifiedEmail()) {
+            return $request->wantsJson()
+                        ? new JsonResponse('', 204)
+                        : app(RedirectAsIntended::class, ['name' => 'email-verification']);
+        }
+
+        $request->user()->sendEmailVerificationNotification();
+
+        return app(EmailVerificationNotificationSentResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/EmailVerificationPromptController.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Laravel\Fortify\Contracts\VerifyEmailViewResponse;
+use Laravel\Fortify\Http\Responses\RedirectAsIntended;
+
+class EmailVerificationPromptController extends Controller
+{
+    /**
+     * Display the email verification prompt.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Laravel\Fortify\Contracts\VerifyEmailViewResponse
+     */
+    public function __invoke(Request $request)
+    {
+        return $request->user()->hasVerifiedEmail()
+                    ? app(RedirectAsIntended::class, ['name' => 'email-verification'])
+                    : app(VerifyEmailViewResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/NewPasswordController.php

@@ -0,0 +1,92 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Contracts\Auth\PasswordBroker;
+use Illuminate\Contracts\Auth\StatefulGuard;
+use Illuminate\Contracts\Support\Responsable;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Illuminate\Support\Facades\Password;
+use Laravel\Fortify\Actions\CompletePasswordReset;
+use Laravel\Fortify\Contracts\FailedPasswordResetResponse;
+use Laravel\Fortify\Contracts\PasswordResetResponse;
+use Laravel\Fortify\Contracts\ResetPasswordViewResponse;
+use Laravel\Fortify\Contracts\ResetsUserPasswords;
+use Laravel\Fortify\Fortify;
+
+class NewPasswordController extends Controller
+{
+    /**
+     * The guard implementation.
+     *
+     * @var \Illuminate\Contracts\Auth\StatefulGuard
+     */
+    protected $guard;
+
+    /**
+     * Create a new controller instance.
+     *
+     * @param  \Illuminate\Contracts\Auth\StatefulGuard  $guard
+     * @return void
+     */
+    public function __construct(StatefulGuard $guard)
+    {
+        $this->guard = $guard;
+    }
+
+    /**
+     * Show the new password view.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Laravel\Fortify\Contracts\ResetPasswordViewResponse
+     */
+    public function create(Request $request): ResetPasswordViewResponse
+    {
+        return app(ResetPasswordViewResponse::class);
+    }
+
+    /**
+     * Reset the user's password.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Contracts\Support\Responsable
+     */
+    public function store(Request $request): Responsable
+    {
+        $request->validate([
+            'token' => 'required',
+            Fortify::email() => 'required|email',
+            'password' => 'required',
+        ]);
+
+        // Here we will attempt to reset the user's password. If it is successful we
+        // will update the password on an actual user model and persist it to the
+        // database. Otherwise we will parse the error and return the response.
+        $status = $this->broker()->reset(
+            $request->only(Fortify::email(), 'password', 'password_confirmation', 'token'),
+            function ($user) use ($request) {
+                app(ResetsUserPasswords::class)->reset($user, $request->all());
+
+                app(CompletePasswordReset::class)($this->guard, $user);
+            }
+        );
+
+        // If the password was successfully reset, we will redirect the user back to
+        // the application's home authenticated view. If there is an error we can
+        // redirect them back to where they came from with their error message.
+        return $status == Password::PASSWORD_RESET
+                    ? app(PasswordResetResponse::class, ['status' => $status])
+                    : app(FailedPasswordResetResponse::class, ['status' => $status]);
+    }
+
+    /**
+     * Get the broker to be used during password reset.
+     *
+     * @return \Illuminate\Contracts\Auth\PasswordBroker
+     */
+    protected function broker(): PasswordBroker
+    {
+        return Password::broker(config('fortify.passwords'));
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/PasswordController.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Laravel\Fortify\Contracts\PasswordUpdateResponse;
+use Laravel\Fortify\Contracts\UpdatesUserPasswords;
+use Laravel\Fortify\Events\PasswordUpdatedViaController;
+
+class PasswordController extends Controller
+{
+    /**
+     * Update the user's password.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Laravel\Fortify\Contracts\UpdatesUserPasswords  $updater
+     * @return \Laravel\Fortify\Contracts\PasswordUpdateResponse
+     */
+    public function update(Request $request, UpdatesUserPasswords $updater)
+    {
+        $updater->update($request->user(), $request->all());
+
+        event(new PasswordUpdatedViaController($request->user()));
+
+        return app(PasswordUpdateResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/PasswordResetLinkController.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Contracts\Auth\PasswordBroker;
+use Illuminate\Contracts\Support\Responsable;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Illuminate\Support\Facades\Password;
+use Laravel\Fortify\Contracts\FailedPasswordResetLinkRequestResponse;
+use Laravel\Fortify\Contracts\RequestPasswordResetLinkViewResponse;
+use Laravel\Fortify\Contracts\SuccessfulPasswordResetLinkRequestResponse;
+use Laravel\Fortify\Fortify;
+
+class PasswordResetLinkController extends Controller
+{
+    /**
+     * Show the reset password link request view.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Laravel\Fortify\Contracts\RequestPasswordResetLinkViewResponse
+     */
+    public function create(Request $request): RequestPasswordResetLinkViewResponse
+    {
+        return app(RequestPasswordResetLinkViewResponse::class);
+    }
+
+    /**
+     * Send a reset link to the given user.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Contracts\Support\Responsable
+     */
+    public function store(Request $request): Responsable
+    {
+        $request->validate([Fortify::email() => 'required|email']);
+
+        // We will send the password reset link to this user. Once we have attempted
+        // to send the link, we will examine the response then see the message we
+        // need to show to the user. Finally, we'll send out a proper response.
+        $status = $this->broker()->sendResetLink(
+            $request->only(Fortify::email())
+        );
+
+        return $status == Password::RESET_LINK_SENT
+                    ? app(SuccessfulPasswordResetLinkRequestResponse::class, ['status' => $status])
+                    : app(FailedPasswordResetLinkRequestResponse::class, ['status' => $status]);
+    }
+
+    /**
+     * Get the broker to be used during password reset.
+     *
+     * @return \Illuminate\Contracts\Auth\PasswordBroker
+     */
+    protected function broker(): PasswordBroker
+    {
+        return Password::broker(config('fortify.passwords'));
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/ProfileInformationController.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Illuminate\Support\Str;
+use Laravel\Fortify\Contracts\ProfileInformationUpdatedResponse;
+use Laravel\Fortify\Contracts\UpdatesUserProfileInformation;
+use Laravel\Fortify\Fortify;
+
+class ProfileInformationController extends Controller
+{
+    /**
+     * Update the user's profile information.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Laravel\Fortify\Contracts\UpdatesUserProfileInformation  $updater
+     * @return \Laravel\Fortify\Contracts\ProfileInformationUpdatedResponse
+     */
+    public function update(Request $request,
+                           UpdatesUserProfileInformation $updater)
+    {
+        if (config('fortify.lowercase_usernames')) {
+            $request->merge([
+                Fortify::username() => Str::lower($request->{Fortify::username()}),
+            ]);
+        }
+
+        $updater->update($request->user(), $request->all());
+
+        return app(ProfileInformationUpdatedResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/RecoveryCodeController.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Laravel\Fortify\Actions\GenerateNewRecoveryCodes;
+use Laravel\Fortify\Contracts\RecoveryCodesGeneratedResponse;
+
+class RecoveryCodeController extends Controller
+{
+    /**
+     * Get the two factor authentication recovery codes for authenticated user.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Illuminate\Http\Response
+     */
+    public function index(Request $request)
+    {
+        if (! $request->user()->two_factor_secret ||
+            ! $request->user()->two_factor_recovery_codes) {
+            return [];
+        }
+
+        return response()->json(json_decode(decrypt(
+            $request->user()->two_factor_recovery_codes
+        ), true));
+    }
+
+    /**
+     * Generate a fresh set of two factor authentication recovery codes.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Laravel\Fortify\Actions\GenerateNewRecoveryCodes  $generate
+     * @return \Laravel\Fortify\Contracts\RecoveryCodesGeneratedResponse
+     */
+    public function store(Request $request, GenerateNewRecoveryCodes $generate)
+    {
+        $generate($request->user());
+
+        return app(RecoveryCodesGeneratedResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/RegisteredUserController.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Auth\Events\Registered;
+use Illuminate\Contracts\Auth\StatefulGuard;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Illuminate\Support\Str;
+use Laravel\Fortify\Contracts\CreatesNewUsers;
+use Laravel\Fortify\Contracts\RegisterResponse;
+use Laravel\Fortify\Contracts\RegisterViewResponse;
+use Laravel\Fortify\Fortify;
+
+class RegisteredUserController extends Controller
+{
+    /**
+     * The guard implementation.
+     *
+     * @var \Illuminate\Contracts\Auth\StatefulGuard
+     */
+    protected $guard;
+
+    /**
+     * Create a new controller instance.
+     *
+     * @param  \Illuminate\Contracts\Auth\StatefulGuard  $guard
+     * @return void
+     */
+    public function __construct(StatefulGuard $guard)
+    {
+        $this->guard = $guard;
+    }
+
+    /**
+     * Show the registration view.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Laravel\Fortify\Contracts\RegisterViewResponse
+     */
+    public function create(Request $request): RegisterViewResponse
+    {
+        return app(RegisterViewResponse::class);
+    }
+
+    /**
+     * Create a new registered user.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Laravel\Fortify\Contracts\CreatesNewUsers  $creator
+     * @return \Laravel\Fortify\Contracts\RegisterResponse
+     */
+    public function store(Request $request,
+                          CreatesNewUsers $creator): RegisterResponse
+    {
+        if (config('fortify.lowercase_usernames')) {
+            $request->merge([
+                Fortify::username() => Str::lower($request->{Fortify::username()}),
+            ]);
+        }
+
+        event(new Registered($user = $creator->create($request->all())));
+
+        $this->guard->login($user);
+
+        return app(RegisterResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/TwoFactorAuthenticatedSessionController.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Contracts\Auth\StatefulGuard;
+use Illuminate\Http\Exceptions\HttpResponseException;
+use Illuminate\Routing\Controller;
+use Laravel\Fortify\Contracts\FailedTwoFactorLoginResponse;
+use Laravel\Fortify\Contracts\TwoFactorChallengeViewResponse;
+use Laravel\Fortify\Contracts\TwoFactorLoginResponse;
+use Laravel\Fortify\Events\RecoveryCodeReplaced;
+use Laravel\Fortify\Events\TwoFactorAuthenticationFailed;
+use Laravel\Fortify\Http\Requests\TwoFactorLoginRequest;
+
+class TwoFactorAuthenticatedSessionController extends Controller
+{
+    /**
+     * The guard implementation.
+     *
+     * @var \Illuminate\Contracts\Auth\StatefulGuard
+     */
+    protected $guard;
+
+    /**
+     * Create a new controller instance.
+     *
+     * @param  \Illuminate\Contracts\Auth\StatefulGuard  $guard
+     * @return void
+     */
+    public function __construct(StatefulGuard $guard)
+    {
+        $this->guard = $guard;
+    }
+
+    /**
+     * Show the two factor authentication challenge view.
+     *
+     * @param  \Laravel\Fortify\Http\Requests\TwoFactorLoginRequest  $request
+     * @return \Laravel\Fortify\Contracts\TwoFactorChallengeViewResponse
+     */
+    public function create(TwoFactorLoginRequest $request): TwoFactorChallengeViewResponse
+    {
+        if (! $request->hasChallengedUser()) {
+            throw new HttpResponseException(redirect()->route('login'));
+        }
+
+        return app(TwoFactorChallengeViewResponse::class);
+    }
+
+    /**
+     * Attempt to authenticate a new session using the two factor authentication code.
+     *
+     * @param  \Laravel\Fortify\Http\Requests\TwoFactorLoginRequest  $request
+     * @return mixed
+     */
+    public function store(TwoFactorLoginRequest $request)
+    {
+        $user = $request->challengedUser();
+
+        if ($code = $request->validRecoveryCode()) {
+            $user->replaceRecoveryCode($code);
+
+            event(new RecoveryCodeReplaced($user, $code));
+        } elseif (! $request->hasValidCode()) {
+            event(new TwoFactorAuthenticationFailed($user));
+
+            return app(FailedTwoFactorLoginResponse::class)->toResponse($request);
+        }
+
+        $this->guard->login($user, $request->remember());
+
+        $request->session()->regenerate();
+
+        return app(TwoFactorLoginResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/TwoFactorAuthenticationController.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+use Laravel\Fortify\Actions\DisableTwoFactorAuthentication;
+use Laravel\Fortify\Actions\EnableTwoFactorAuthentication;
+use Laravel\Fortify\Contracts\TwoFactorDisabledResponse;
+use Laravel\Fortify\Contracts\TwoFactorEnabledResponse;
+
+class TwoFactorAuthenticationController extends Controller
+{
+    /**
+     * Enable two factor authentication for the user.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Laravel\Fortify\Actions\EnableTwoFactorAuthentication  $enable
+     * @return \Laravel\Fortify\Contracts\TwoFactorEnabledResponse
+     */
+    public function store(Request $request, EnableTwoFactorAuthentication $enable)
+    {
+        $enable($request->user(), $request->boolean('force', false));
+
+        return app(TwoFactorEnabledResponse::class);
+    }
+
+    /**
+     * Disable two factor authentication for the user.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Laravel\Fortify\Actions\DisableTwoFactorAuthentication  $disable
+     * @return \Laravel\Fortify\Contracts\TwoFactorDisabledResponse
+     */
+    public function destroy(Request $request, DisableTwoFactorAuthentication $disable)
+    {
+        $disable($request->user());
+
+        return app(TwoFactorDisabledResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/TwoFactorQrCodeController.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+
+class TwoFactorQrCodeController extends Controller
+{
+    /**
+     * Get the SVG element for the user's two factor authentication QR code.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function show(Request $request)
+    {
+        if (is_null($request->user()->two_factor_secret)) {
+            return [];
+        }
+
+        return response()->json([
+            'svg' => $request->user()->twoFactorQrCodeSvg(),
+            'url' => $request->user()->twoFactorQrCodeUrl(),
+        ]);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/TwoFactorSecretKeyController.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controller;
+
+class TwoFactorSecretKeyController extends Controller
+{
+    /**
+     * Get the current user's two factor authentication setup / secret key.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function show(Request $request)
+    {
+        if (is_null($request->user()->two_factor_secret)) {
+            abort(404, 'Two factor authentication has not been enabled.');
+        }
+
+        return response()->json([
+            'secretKey' => decrypt($request->user()->two_factor_secret),
+        ]);
+    }
+}

vendor/laravel/fortify/src/Http/Controllers/VerifyEmailController.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Laravel\Fortify\Http\Controllers;
+
+use Illuminate\Auth\Events\Verified;
+use Illuminate\Routing\Controller;
+use Laravel\Fortify\Contracts\VerifyEmailResponse;
+use Laravel\Fortify\Http\Requests\VerifyEmailRequest;
+
+class VerifyEmailController extends Controller
+{
+    /**
+     * Mark the authenticated user's email address as verified.
+     *
+     * @param  \Laravel\Fortify\Http\Requests\VerifyEmailRequest  $request
+     * @return \Laravel\Fortify\Contracts\VerifyEmailResponse
+     */
+    public function __invoke(VerifyEmailRequest $request)
+    {
+        if ($request->user()->hasVerifiedEmail()) {
+            return app(VerifyEmailResponse::class);
+        }
+
+        if ($request->user()->markEmailAsVerified()) {
+            event(new Verified($request->user()));
+        }
+
+        return app(VerifyEmailResponse::class);
+    }
+}

vendor/laravel/fortify/src/Http/Requests/LoginRequest.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Laravel\Fortify\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+use Laravel\Fortify\Fortify;
+
+class LoginRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     *
+     * @return bool
+     */
+    public function authorize()
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array
+     */
+    public function rules()
+    {
+        return [
+            Fortify::username() => 'required|string',
+            'password' => 'required|string',
+        ];
+    }
+}

vendor/laravel/fortify/src/Http/Requests/TwoFactorLoginRequest.php

@@ -0,0 +1,139 @@
+<?php
+
+namespace Laravel\Fortify\Http\Requests;
+
+use Illuminate\Contracts\Auth\StatefulGuard;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Http\Exceptions\HttpResponseException;
+use Laravel\Fortify\Contracts\FailedTwoFactorLoginResponse;
+use Laravel\Fortify\Contracts\TwoFactorAuthenticationProvider;
+
+class TwoFactorLoginRequest extends FormRequest
+{
+    /**
+     * The user attempting the two factor challenge.
+     *
+     * @var mixed
+     */
+    protected $challengedUser;
+
+    /**
+     * Indicates if the user wished to be remembered after login.
+     *
+     * @var bool
+     */
+    protected $remember;
+
+    /**
+     * Determine if the user is authorized to make this request.
+     *
+     * @return bool
+     */
+    public function authorize()
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array
+     */
+    public function rules()
+    {
+        return [
+            'code' => 'nullable|string',
+            'recovery_code' => 'nullable|string',
+        ];
+    }
+
+    /**
+     * Determine if the request has a valid two factor code.
+     *
+     * @return bool
+     */
+    public function hasValidCode()
+    {
+        return $this->code && tap(app(TwoFactorAuthenticationProvider::class)->verify(
+            decrypt($this->challengedUser()->two_factor_secret), $this->code
+        ), function ($result) {
+            if ($result) {
+                $this->session()->forget('login.id');
+            }
+        });
+    }
+
+    /**
+     * Get the valid recovery code if one exists on the request.
+     *
+     * @return string|null
+     */
+    public function validRecoveryCode()
+    {
+        if (! $this->recovery_code) {
+            return;
+        }
+
+        return tap(collect($this->challengedUser()->recoveryCodes())->first(function ($code) {
+            return hash_equals($code, $this->recovery_code) ? $code : null;
+        }), function ($code) {
+            if ($code) {
+                $this->session()->forget('login.id');
+            }
+        });
+    }
+
+    /**
+     * Determine if there is a challenged user in the current session.
+     *
+     * @return bool
+     */
+    public function hasChallengedUser()
+    {
+        if ($this->challengedUser) {
+            return true;
+        }
+
+        $model = app(StatefulGuard::class)->getProvider()->getModel();
+
+        return $this->session()->has('login.id') &&
+            $model::find($this->session()->get('login.id'));
+    }
+
+    /**
+     * Get the user that is attempting the two factor challenge.
+     *
+     * @return mixed
+     */
+    public function challengedUser()
+    {
+        if ($this->challengedUser) {
+            return $this->challengedUser;
+        }
+
+        $model = app(StatefulGuard::class)->getProvider()->getModel();
+
+        if (! $this->session()->has('login.id') ||
+            ! $user = $model::find($this->session()->get('login.id'))) {
+            throw new HttpResponseException(
+                app(FailedTwoFactorLoginResponse::class)->toResponse($this)
+            );
+        }
+
+        return $this->challengedUser = $user;
+    }
+
+    /**
+     * Determine if the user wanted to be remembered after login.
+     *
+     * @return bool
+     */
+    public function remember()
+    {
+        if (! $this->remember) {
+            $this->remember = $this->session()->pull('login.remember', false);
+        }
+
+        return $this->remember;
+    }
+}

vendor/laravel/fortify/src/Http/Requests/VerifyEmailRequest.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Laravel\Fortify\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class VerifyEmailRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     *
+     * @return bool
+     */
+    public function authorize()
+    {
+        if (! hash_equals((string) $this->user()->getKey(), (string) $this->route('id'))) {
+            return false;
+        }
+
+        if (! hash_equals(sha1($this->user()->getEmailForVerification()), (string) $this->route('hash'))) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array
+     */
+    public function rules()
+    {
+        return [];
+    }
+}

vendor/laravel/fortify/src/Http/Responses/EmailVerificationNotificationSentResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\EmailVerificationNotificationSentResponse as EmailVerificationNotificationSentResponseContract;
+use Laravel\Fortify\Fortify;
+
+class EmailVerificationNotificationSentResponse implements EmailVerificationNotificationSentResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse('', 202)
+                    : back()->with('status', Fortify::VERIFICATION_LINK_SENT);
+    }
+}

vendor/laravel/fortify/src/Http/Responses/FailedPasswordConfirmationResponse.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Validation\ValidationException;
+use Laravel\Fortify\Contracts\FailedPasswordConfirmationResponse as FailedPasswordConfirmationResponseContract;
+
+class FailedPasswordConfirmationResponse implements FailedPasswordConfirmationResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        $message = __('The provided password was incorrect.');
+
+        if ($request->wantsJson()) {
+            throw ValidationException::withMessages([
+                'password' => [$message],
+            ]);
+        }
+
+        return back()->withErrors(['password' => $message]);
+    }
+}

vendor/laravel/fortify/src/Http/Responses/FailedPasswordResetLinkRequestResponse.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Validation\ValidationException;
+use Laravel\Fortify\Contracts\FailedPasswordResetLinkRequestResponse as FailedPasswordResetLinkRequestResponseContract;
+
+class FailedPasswordResetLinkRequestResponse implements FailedPasswordResetLinkRequestResponseContract
+{
+    /**
+     * The response status language key.
+     *
+     * @var string
+     */
+    protected $status;
+
+    /**
+     * Create a new response instance.
+     *
+     * @param  string  $status
+     * @return void
+     */
+    public function __construct(string $status)
+    {
+        $this->status = $status;
+    }
+
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        if ($request->wantsJson()) {
+            throw ValidationException::withMessages([
+                'email' => [trans($this->status)],
+            ]);
+        }
+
+        return back()
+                ->withInput($request->only('email'))
+                ->withErrors(['email' => trans($this->status)]);
+    }
+}

vendor/laravel/fortify/src/Http/Responses/FailedPasswordResetResponse.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Validation\ValidationException;
+use Laravel\Fortify\Contracts\FailedPasswordResetResponse as FailedPasswordResetResponseContract;
+
+class FailedPasswordResetResponse implements FailedPasswordResetResponseContract
+{
+    /**
+     * The response status language key.
+     *
+     * @var string
+     */
+    protected $status;
+
+    /**
+     * Create a new response instance.
+     *
+     * @param  string  $status
+     * @return void
+     */
+    public function __construct(string $status)
+    {
+        $this->status = $status;
+    }
+
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        if ($request->wantsJson()) {
+            throw ValidationException::withMessages([
+                'email' => [trans($this->status)],
+            ]);
+        }
+
+        return back()
+                ->withInput($request->only('email'))
+                ->withErrors(['email' => trans($this->status)]);
+    }
+}

vendor/laravel/fortify/src/Http/Responses/FailedTwoFactorLoginResponse.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Validation\ValidationException;
+use Laravel\Fortify\Contracts\FailedTwoFactorLoginResponse as FailedTwoFactorLoginResponseContract;
+
+class FailedTwoFactorLoginResponse implements FailedTwoFactorLoginResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        [$key, $message] = $request->filled('recovery_code')
+            ? ['recovery_code', __('The provided two factor recovery code was invalid.')]
+            : ['code', __('The provided two factor authentication code was invalid.')];
+
+        if ($request->wantsJson()) {
+            throw ValidationException::withMessages([
+                $key => [$message],
+            ]);
+        }
+
+        return redirect()->route('two-factor.login')->withErrors([$key => $message]);
+    }
+}

vendor/laravel/fortify/src/Http/Responses/LockoutResponse.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\Response;
+use Illuminate\Validation\ValidationException;
+use Laravel\Fortify\Contracts\LockoutResponse as LockoutResponseContract;
+use Laravel\Fortify\Fortify;
+use Laravel\Fortify\LoginRateLimiter;
+
+class LockoutResponse implements LockoutResponseContract
+{
+    /**
+     * The login rate limiter instance.
+     *
+     * @var \Laravel\Fortify\LoginRateLimiter
+     */
+    protected $limiter;
+
+    /**
+     * Create a new response instance.
+     *
+     * @param  \Laravel\Fortify\LoginRateLimiter  $limiter
+     * @return void
+     */
+    public function __construct(LoginRateLimiter $limiter)
+    {
+        $this->limiter = $limiter;
+    }
+
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return with($this->limiter->availableIn($request), function ($seconds) {
+            throw ValidationException::withMessages([
+                Fortify::username() => [
+                    trans('auth.throttle', [
+                        'seconds' => $seconds,
+                        'minutes' => ceil($seconds / 60),
+                    ]),
+                ],
+            ])->status(Response::HTTP_TOO_MANY_REQUESTS);
+        });
+    }
+}

vendor/laravel/fortify/src/Http/Responses/LoginResponse.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Laravel\Fortify\Contracts\LoginResponse as LoginResponseContract;
+use Laravel\Fortify\Fortify;
+
+class LoginResponse implements LoginResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? response()->json(['two_factor' => false])
+                    : redirect()->intended(Fortify::redirects('login'));
+    }
+}

vendor/laravel/fortify/src/Http/Responses/LogoutResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\LogoutResponse as LogoutResponseContract;
+use Laravel\Fortify\Fortify;
+
+class LogoutResponse implements LogoutResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse('', 204)
+                    : redirect(Fortify::redirects('logout', '/'));
+    }
+}

vendor/laravel/fortify/src/Http/Responses/PasswordConfirmedResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\PasswordConfirmedResponse as PasswordConfirmedResponseContract;
+use Laravel\Fortify\Fortify;
+
+class PasswordConfirmedResponse implements PasswordConfirmedResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse('', 201)
+                    : redirect()->intended(Fortify::redirects('password-confirmation'));
+    }
+}

vendor/laravel/fortify/src/Http/Responses/PasswordResetResponse.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\PasswordResetResponse as PasswordResetResponseContract;
+use Laravel\Fortify\Fortify;
+
+class PasswordResetResponse implements PasswordResetResponseContract
+{
+    /**
+     * The response status language key.
+     *
+     * @var string
+     */
+    protected $status;
+
+    /**
+     * Create a new response instance.
+     *
+     * @param  string  $status
+     * @return void
+     */
+    public function __construct(string $status)
+    {
+        $this->status = $status;
+    }
+
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse(['message' => trans($this->status)], 200)
+                    : redirect(Fortify::redirects('password-reset', config('fortify.views', true) ? route('login') : null))->with('status', trans($this->status));
+    }
+}

vendor/laravel/fortify/src/Http/Responses/PasswordUpdateResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\PasswordUpdateResponse as PasswordUpdateResponseContract;
+use Laravel\Fortify\Fortify;
+
+class PasswordUpdateResponse implements PasswordUpdateResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+            ? new JsonResponse('', 200)
+            : back()->with('status', Fortify::PASSWORD_UPDATED);
+    }
+}

vendor/laravel/fortify/src/Http/Responses/ProfileInformationUpdatedResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\ProfileInformationUpdatedResponse as ProfileInformationUpdatedResponseContract;
+use Laravel\Fortify\Fortify;
+
+class ProfileInformationUpdatedResponse implements ProfileInformationUpdatedResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse('', 200)
+                    : back()->with('status', Fortify::PROFILE_INFORMATION_UPDATED);
+    }
+}

vendor/laravel/fortify/src/Http/Responses/RecoveryCodesGeneratedResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\RecoveryCodesGeneratedResponse as RecoveryCodesGeneratedResponseContract;
+use Laravel\Fortify\Fortify;
+
+class RecoveryCodesGeneratedResponse implements RecoveryCodesGeneratedResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse('', 200)
+                    : back()->with('status', Fortify::RECOVERY_CODES_GENERATED);
+    }
+}

vendor/laravel/fortify/src/Http/Responses/RedirectAsIntended.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Contracts\Support\Responsable;
+use Laravel\Fortify\Fortify;
+
+class RedirectAsIntended implements Responsable
+{
+    /**
+     * Create a new class instance.
+     *
+     * @param  string  $name
+     * @return void
+     */
+    public function __construct(public string $name)
+    {
+        //
+    }
+
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return redirect()->intended(Fortify::redirects($this->name));
+    }
+}

vendor/laravel/fortify/src/Http/Responses/RegisterResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\RegisterResponse as RegisterResponseContract;
+use Laravel\Fortify\Fortify;
+
+class RegisterResponse implements RegisterResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse('', 201)
+                    : redirect()->intended(Fortify::redirects('register'));
+    }
+}

vendor/laravel/fortify/src/Http/Responses/SimpleViewResponse.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Contracts\Support\Responsable;
+use Laravel\Fortify\Contracts\ConfirmPasswordViewResponse;
+use Laravel\Fortify\Contracts\LoginViewResponse;
+use Laravel\Fortify\Contracts\RegisterViewResponse;
+use Laravel\Fortify\Contracts\RequestPasswordResetLinkViewResponse;
+use Laravel\Fortify\Contracts\ResetPasswordViewResponse;
+use Laravel\Fortify\Contracts\TwoFactorChallengeViewResponse;
+use Laravel\Fortify\Contracts\VerifyEmailViewResponse;
+
+class SimpleViewResponse implements
+    LoginViewResponse,
+    ResetPasswordViewResponse,
+    RegisterViewResponse,
+    RequestPasswordResetLinkViewResponse,
+    TwoFactorChallengeViewResponse,
+    VerifyEmailViewResponse,
+    ConfirmPasswordViewResponse
+{
+    /**
+     * The name of the view or the callable used to generate the view.
+     *
+     * @var callable|string
+     */
+    protected $view;
+
+    /**
+     * Create a new response instance.
+     *
+     * @param  callable|string  $view
+     * @return void
+     */
+    public function __construct($view)
+    {
+        $this->view = $view;
+    }
+
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        if (! is_callable($this->view) || is_string($this->view)) {
+            return view($this->view, ['request' => $request]);
+        }
+
+        $response = call_user_func($this->view, $request);
+
+        if ($response instanceof Responsable) {
+            return $response->toResponse($request);
+        }
+
+        return $response;
+    }
+}

vendor/laravel/fortify/src/Http/Responses/SuccessfulPasswordResetLinkRequestResponse.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\SuccessfulPasswordResetLinkRequestResponse as SuccessfulPasswordResetLinkRequestResponseContract;
+
+class SuccessfulPasswordResetLinkRequestResponse implements SuccessfulPasswordResetLinkRequestResponseContract
+{
+    /**
+     * The response status language key.
+     *
+     * @var string
+     */
+    protected $status;
+
+    /**
+     * Create a new response instance.
+     *
+     * @param  string  $status
+     * @return void
+     */
+    public function __construct(string $status)
+    {
+        $this->status = $status;
+    }
+
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse(['message' => trans($this->status)], 200)
+                    : back()->with('status', trans($this->status));
+    }
+}

vendor/laravel/fortify/src/Http/Responses/TwoFactorConfirmedResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\TwoFactorConfirmedResponse as TwoFactorConfirmedResponseContract;
+use Laravel\Fortify\Fortify;
+
+class TwoFactorConfirmedResponse implements TwoFactorConfirmedResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse('', 200)
+                    : back()->with('status', Fortify::TWO_FACTOR_AUTHENTICATION_CONFIRMED);
+    }
+}

vendor/laravel/fortify/src/Http/Responses/TwoFactorDisabledResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\TwoFactorLoginResponse as TwoFactorLoginResponseContract;
+use Laravel\Fortify\Fortify;
+
+class TwoFactorDisabledResponse implements TwoFactorLoginResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse('', 200)
+                    : back()->with('status', Fortify::TWO_FACTOR_AUTHENTICATION_DISABLED);
+    }
+}

vendor/laravel/fortify/src/Http/Responses/TwoFactorEnabledResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\TwoFactorLoginResponse as TwoFactorLoginResponseContract;
+use Laravel\Fortify\Fortify;
+
+class TwoFactorEnabledResponse implements TwoFactorLoginResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse('', 200)
+                    : back()->with('status', Fortify::TWO_FACTOR_AUTHENTICATION_ENABLED);
+    }
+}

vendor/laravel/fortify/src/Http/Responses/TwoFactorLoginResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\TwoFactorLoginResponse as TwoFactorLoginResponseContract;
+use Laravel\Fortify\Fortify;
+
+class TwoFactorLoginResponse implements TwoFactorLoginResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+                    ? new JsonResponse('', 204)
+                    : redirect()->intended(Fortify::redirects('login'));
+    }
+}

vendor/laravel/fortify/src/Http/Responses/VerifyEmailResponse.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Laravel\Fortify\Http\Responses;
+
+use Illuminate\Http\JsonResponse;
+use Laravel\Fortify\Contracts\VerifyEmailResponse as VerifyEmailResponseContract;
+use Laravel\Fortify\Fortify;
+
+class VerifyEmailResponse implements VerifyEmailResponseContract
+{
+    /**
+     * Create an HTTP response that represents the object.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @return \Symfony\Component\HttpFoundation\Response
+     */
+    public function toResponse($request)
+    {
+        return $request->wantsJson()
+            ? new JsonResponse('', 204)
+            : redirect()->intended(Fortify::redirects('email-verification').'?verified=1');
+    }
+}