// Code generated by MockGen. DO NOT EDIT.
// Source: handler_authz.go

// Package handler_test is a generated GoMock package.
package handler_test

import (
	context "context"
	http "net/http"
	url "net/url"
	reflect "reflect"

	authenticationinfo "github.com/authgear/authgear-server/pkg/lib/authn/authenticationinfo"
	config "github.com/authgear/authgear-server/pkg/lib/config"
	oauth "github.com/authgear/authgear-server/pkg/lib/oauth"
	oauthsession "github.com/authgear/authgear-server/pkg/lib/oauth/oauthsession"
	oidc "github.com/authgear/authgear-server/pkg/lib/oauth/oidc"
	protocol "github.com/authgear/authgear-server/pkg/lib/oauth/protocol"
	httputil "github.com/authgear/authgear-server/pkg/util/httputil"
	gomock "github.com/golang/mock/gomock"
)

// MockUIInfoResolver is a mock of UIInfoResolver interface.
type MockUIInfoResolver struct {
	ctrl     *gomock.Controller
	recorder *MockUIInfoResolverMockRecorder
}

// MockUIInfoResolverMockRecorder is the mock recorder for MockUIInfoResolver.
type MockUIInfoResolverMockRecorder struct {
	mock *MockUIInfoResolver
}

// NewMockUIInfoResolver creates a new mock instance.
func NewMockUIInfoResolver(ctrl *gomock.Controller) *MockUIInfoResolver {
	mock := &MockUIInfoResolver{ctrl: ctrl}
	mock.recorder = &MockUIInfoResolverMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockUIInfoResolver) EXPECT() *MockUIInfoResolverMockRecorder {
	return m.recorder
}

// ResolveForAuthorizationEndpoint mocks base method.
func (m *MockUIInfoResolver) ResolveForAuthorizationEndpoint(ctx context.Context, client *config.OAuthClientConfig, req protocol.AuthorizationRequest) (*oidc.UIInfo, *oidc.UIInfoByProduct, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveForAuthorizationEndpoint", ctx, client, req)
	ret0, _ := ret[0].(*oidc.UIInfo)
	ret1, _ := ret[1].(*oidc.UIInfoByProduct)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ResolveForAuthorizationEndpoint indicates an expected call of ResolveForAuthorizationEndpoint.
func (mr *MockUIInfoResolverMockRecorder) ResolveForAuthorizationEndpoint(ctx, client, req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveForAuthorizationEndpoint", reflect.TypeOf((*MockUIInfoResolver)(nil).ResolveForAuthorizationEndpoint), ctx, client, req)
}

// MockAuthenticationInfoResolver is a mock of AuthenticationInfoResolver interface.
type MockAuthenticationInfoResolver struct {
	ctrl     *gomock.Controller
	recorder *MockAuthenticationInfoResolverMockRecorder
}

// MockAuthenticationInfoResolverMockRecorder is the mock recorder for MockAuthenticationInfoResolver.
type MockAuthenticationInfoResolverMockRecorder struct {
	mock *MockAuthenticationInfoResolver
}

// NewMockAuthenticationInfoResolver creates a new mock instance.
func NewMockAuthenticationInfoResolver(ctrl *gomock.Controller) *MockAuthenticationInfoResolver {
	mock := &MockAuthenticationInfoResolver{ctrl: ctrl}
	mock.recorder = &MockAuthenticationInfoResolverMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAuthenticationInfoResolver) EXPECT() *MockAuthenticationInfoResolverMockRecorder {
	return m.recorder
}

// GetAuthenticationInfoID mocks base method.
func (m *MockAuthenticationInfoResolver) GetAuthenticationInfoID(req *http.Request) (string, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthenticationInfoID", req)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetAuthenticationInfoID indicates an expected call of GetAuthenticationInfoID.
func (mr *MockAuthenticationInfoResolverMockRecorder) GetAuthenticationInfoID(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthenticationInfoID", reflect.TypeOf((*MockAuthenticationInfoResolver)(nil).GetAuthenticationInfoID), req)
}

// MockUIURLBuilder is a mock of UIURLBuilder interface.
type MockUIURLBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockUIURLBuilderMockRecorder
}

// MockUIURLBuilderMockRecorder is the mock recorder for MockUIURLBuilder.
type MockUIURLBuilderMockRecorder struct {
	mock *MockUIURLBuilder
}

// NewMockUIURLBuilder creates a new mock instance.
func NewMockUIURLBuilder(ctrl *gomock.Controller) *MockUIURLBuilder {
	mock := &MockUIURLBuilder{ctrl: ctrl}
	mock.recorder = &MockUIURLBuilderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockUIURLBuilder) EXPECT() *MockUIURLBuilderMockRecorder {
	return m.recorder
}

// BuildAuthenticationURL mocks base method.
func (m *MockUIURLBuilder) BuildAuthenticationURL(client *config.OAuthClientConfig, r protocol.AuthorizationRequest, e *oauthsession.Entry) (*url.URL, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildAuthenticationURL", client, r, e)
	ret0, _ := ret[0].(*url.URL)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildAuthenticationURL indicates an expected call of BuildAuthenticationURL.
func (mr *MockUIURLBuilderMockRecorder) BuildAuthenticationURL(client, r, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildAuthenticationURL", reflect.TypeOf((*MockUIURLBuilder)(nil).BuildAuthenticationURL), client, r, e)
}

// BuildSettingsActionURL mocks base method.
func (m *MockUIURLBuilder) BuildSettingsActionURL(client *config.OAuthClientConfig, r protocol.AuthorizationRequest, e *oauthsession.Entry) (*url.URL, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildSettingsActionURL", client, r, e)
	ret0, _ := ret[0].(*url.URL)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildSettingsActionURL indicates an expected call of BuildSettingsActionURL.
func (mr *MockUIURLBuilderMockRecorder) BuildSettingsActionURL(client, r, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildSettingsActionURL", reflect.TypeOf((*MockUIURLBuilder)(nil).BuildSettingsActionURL), client, r, e)
}

// MockAppSessionTokenService is a mock of AppSessionTokenService interface.
type MockAppSessionTokenService struct {
	ctrl     *gomock.Controller
	recorder *MockAppSessionTokenServiceMockRecorder
}

// MockAppSessionTokenServiceMockRecorder is the mock recorder for MockAppSessionTokenService.
type MockAppSessionTokenServiceMockRecorder struct {
	mock *MockAppSessionTokenService
}

// NewMockAppSessionTokenService creates a new mock instance.
func NewMockAppSessionTokenService(ctrl *gomock.Controller) *MockAppSessionTokenService {
	mock := &MockAppSessionTokenService{ctrl: ctrl}
	mock.recorder = &MockAppSessionTokenServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAppSessionTokenService) EXPECT() *MockAppSessionTokenServiceMockRecorder {
	return m.recorder
}

// Handle mocks base method.
func (m *MockAppSessionTokenService) Handle(ctx context.Context, input oauth.AppSessionTokenInput) (httputil.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Handle", ctx, input)
	ret0, _ := ret[0].(httputil.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Handle indicates an expected call of Handle.
func (mr *MockAppSessionTokenServiceMockRecorder) Handle(ctx, input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockAppSessionTokenService)(nil).Handle), ctx, input)
}

// MockAuthenticationInfoService is a mock of AuthenticationInfoService interface.
type MockAuthenticationInfoService struct {
	ctrl     *gomock.Controller
	recorder *MockAuthenticationInfoServiceMockRecorder
}

// MockAuthenticationInfoServiceMockRecorder is the mock recorder for MockAuthenticationInfoService.
type MockAuthenticationInfoServiceMockRecorder struct {
	mock *MockAuthenticationInfoService
}

// NewMockAuthenticationInfoService creates a new mock instance.
func NewMockAuthenticationInfoService(ctrl *gomock.Controller) *MockAuthenticationInfoService {
	mock := &MockAuthenticationInfoService{ctrl: ctrl}
	mock.recorder = &MockAuthenticationInfoServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAuthenticationInfoService) EXPECT() *MockAuthenticationInfoServiceMockRecorder {
	return m.recorder
}

// Delete mocks base method.
func (m *MockAuthenticationInfoService) Delete(ctx context.Context, entryID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, entryID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockAuthenticationInfoServiceMockRecorder) Delete(ctx, entryID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockAuthenticationInfoService)(nil).Delete), ctx, entryID)
}

// Get mocks base method.
func (m *MockAuthenticationInfoService) Get(ctx context.Context, entryID string) (*authenticationinfo.Entry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, entryID)
	ret0, _ := ret[0].(*authenticationinfo.Entry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockAuthenticationInfoServiceMockRecorder) Get(ctx, entryID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockAuthenticationInfoService)(nil).Get), ctx, entryID)
}

// MockCookieManager is a mock of CookieManager interface.
type MockCookieManager struct {
	ctrl     *gomock.Controller
	recorder *MockCookieManagerMockRecorder
}

// MockCookieManagerMockRecorder is the mock recorder for MockCookieManager.
type MockCookieManagerMockRecorder struct {
	mock *MockCookieManager
}

// NewMockCookieManager creates a new mock instance.
func NewMockCookieManager(ctrl *gomock.Controller) *MockCookieManager {
	mock := &MockCookieManager{ctrl: ctrl}
	mock.recorder = &MockCookieManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCookieManager) EXPECT() *MockCookieManagerMockRecorder {
	return m.recorder
}

// ClearCookie mocks base method.
func (m *MockCookieManager) ClearCookie(def *httputil.CookieDef) *http.Cookie {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClearCookie", def)
	ret0, _ := ret[0].(*http.Cookie)
	return ret0
}

// ClearCookie indicates an expected call of ClearCookie.
func (mr *MockCookieManagerMockRecorder) ClearCookie(def interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearCookie", reflect.TypeOf((*MockCookieManager)(nil).ClearCookie), def)
}

// GetCookie mocks base method.
func (m *MockCookieManager) GetCookie(r *http.Request, def *httputil.CookieDef) (*http.Cookie, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCookie", r, def)
	ret0, _ := ret[0].(*http.Cookie)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCookie indicates an expected call of GetCookie.
func (mr *MockCookieManagerMockRecorder) GetCookie(r, def interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCookie", reflect.TypeOf((*MockCookieManager)(nil).GetCookie), r, def)
}

// ValueCookie mocks base method.
func (m *MockCookieManager) ValueCookie(def *httputil.CookieDef, value string) *http.Cookie {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValueCookie", def, value)
	ret0, _ := ret[0].(*http.Cookie)
	return ret0
}

// ValueCookie indicates an expected call of ValueCookie.
func (mr *MockCookieManagerMockRecorder) ValueCookie(def, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValueCookie", reflect.TypeOf((*MockCookieManager)(nil).ValueCookie), def, value)
}

// MockOAuthSessionService is a mock of OAuthSessionService interface.
type MockOAuthSessionService struct {
	ctrl     *gomock.Controller
	recorder *MockOAuthSessionServiceMockRecorder
}

// MockOAuthSessionServiceMockRecorder is the mock recorder for MockOAuthSessionService.
type MockOAuthSessionServiceMockRecorder struct {
	mock *MockOAuthSessionService
}

// NewMockOAuthSessionService creates a new mock instance.
func NewMockOAuthSessionService(ctrl *gomock.Controller) *MockOAuthSessionService {
	mock := &MockOAuthSessionService{ctrl: ctrl}
	mock.recorder = &MockOAuthSessionServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockOAuthSessionService) EXPECT() *MockOAuthSessionServiceMockRecorder {
	return m.recorder
}

// Delete mocks base method.
func (m *MockOAuthSessionService) Delete(ctx context.Context, entryID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, entryID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockOAuthSessionServiceMockRecorder) Delete(ctx, entryID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockOAuthSessionService)(nil).Delete), ctx, entryID)
}

// Get mocks base method.
func (m *MockOAuthSessionService) Get(ctx context.Context, entryID string) (*oauthsession.Entry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, entryID)
	ret0, _ := ret[0].(*oauthsession.Entry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockOAuthSessionServiceMockRecorder) Get(ctx, entryID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockOAuthSessionService)(nil).Get), ctx, entryID)
}

// Save mocks base method.
func (m *MockOAuthSessionService) Save(ctx context.Context, entry *oauthsession.Entry) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", ctx, entry)
	ret0, _ := ret[0].(error)
	return ret0
}

// Save indicates an expected call of Save.
func (mr *MockOAuthSessionServiceMockRecorder) Save(ctx, entry interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockOAuthSessionService)(nil).Save), ctx, entry)
}

// MockAuthorizationService is a mock of AuthorizationService interface.
type MockAuthorizationService struct {
	ctrl     *gomock.Controller
	recorder *MockAuthorizationServiceMockRecorder
}

// MockAuthorizationServiceMockRecorder is the mock recorder for MockAuthorizationService.
type MockAuthorizationServiceMockRecorder struct {
	mock *MockAuthorizationService
}

// NewMockAuthorizationService creates a new mock instance.
func NewMockAuthorizationService(ctrl *gomock.Controller) *MockAuthorizationService {
	mock := &MockAuthorizationService{ctrl: ctrl}
	mock.recorder = &MockAuthorizationServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAuthorizationService) EXPECT() *MockAuthorizationServiceMockRecorder {
	return m.recorder
}

// Check mocks base method.
func (m *MockAuthorizationService) Check(ctx context.Context, clientID, userID string, scopes []string) (*oauth.Authorization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Check", ctx, clientID, userID, scopes)
	ret0, _ := ret[0].(*oauth.Authorization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Check indicates an expected call of Check.
func (mr *MockAuthorizationServiceMockRecorder) Check(ctx, clientID, userID, scopes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Check", reflect.TypeOf((*MockAuthorizationService)(nil).Check), ctx, clientID, userID, scopes)
}

// CheckAndGrant mocks base method.
func (m *MockAuthorizationService) CheckAndGrant(ctx context.Context, clientID, userID string, scopes []string) (*oauth.Authorization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAndGrant", ctx, clientID, userID, scopes)
	ret0, _ := ret[0].(*oauth.Authorization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckAndGrant indicates an expected call of CheckAndGrant.
func (mr *MockAuthorizationServiceMockRecorder) CheckAndGrant(ctx, clientID, userID, scopes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckAndGrant", reflect.TypeOf((*MockAuthorizationService)(nil).CheckAndGrant), ctx, clientID, userID, scopes)
}

// GetByID mocks base method.
func (m *MockAuthorizationService) GetByID(ctx context.Context, id string) (*oauth.Authorization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*oauth.Authorization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByID indicates an expected call of GetByID.
func (mr *MockAuthorizationServiceMockRecorder) GetByID(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockAuthorizationService)(nil).GetByID), ctx, id)
}

// MockAuthorizationHandlerAccessTokenEncoding is a mock of AuthorizationHandlerAccessTokenEncoding interface.
type MockAuthorizationHandlerAccessTokenEncoding struct {
	ctrl     *gomock.Controller
	recorder *MockAuthorizationHandlerAccessTokenEncodingMockRecorder
}

// MockAuthorizationHandlerAccessTokenEncodingMockRecorder is the mock recorder for MockAuthorizationHandlerAccessTokenEncoding.
type MockAuthorizationHandlerAccessTokenEncodingMockRecorder struct {
	mock *MockAuthorizationHandlerAccessTokenEncoding
}

// NewMockAuthorizationHandlerAccessTokenEncoding creates a new mock instance.
func NewMockAuthorizationHandlerAccessTokenEncoding(ctrl *gomock.Controller) *MockAuthorizationHandlerAccessTokenEncoding {
	mock := &MockAuthorizationHandlerAccessTokenEncoding{ctrl: ctrl}
	mock.recorder = &MockAuthorizationHandlerAccessTokenEncodingMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAuthorizationHandlerAccessTokenEncoding) EXPECT() *MockAuthorizationHandlerAccessTokenEncodingMockRecorder {
	return m.recorder
}

// MakeUserAccessTokenFromPreparationResult mocks base method.
func (m *MockAuthorizationHandlerAccessTokenEncoding) MakeUserAccessTokenFromPreparationResult(ctx context.Context, options oauth.MakeUserAccessTokenFromPreparationOptions) (*oauth.IssueAccessGrantResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MakeUserAccessTokenFromPreparationResult", ctx, options)
	ret0, _ := ret[0].(*oauth.IssueAccessGrantResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MakeUserAccessTokenFromPreparationResult indicates an expected call of MakeUserAccessTokenFromPreparationResult.
func (mr *MockAuthorizationHandlerAccessTokenEncodingMockRecorder) MakeUserAccessTokenFromPreparationResult(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeUserAccessTokenFromPreparationResult", reflect.TypeOf((*MockAuthorizationHandlerAccessTokenEncoding)(nil).MakeUserAccessTokenFromPreparationResult), ctx, options)
}

// MockAuthorizationHandlerPreAuthenticatedURLTokenService is a mock of AuthorizationHandlerPreAuthenticatedURLTokenService interface.
type MockAuthorizationHandlerPreAuthenticatedURLTokenService struct {
	ctrl     *gomock.Controller
	recorder *MockAuthorizationHandlerPreAuthenticatedURLTokenServiceMockRecorder
}

// MockAuthorizationHandlerPreAuthenticatedURLTokenServiceMockRecorder is the mock recorder for MockAuthorizationHandlerPreAuthenticatedURLTokenService.
type MockAuthorizationHandlerPreAuthenticatedURLTokenServiceMockRecorder struct {
	mock *MockAuthorizationHandlerPreAuthenticatedURLTokenService
}

// NewMockAuthorizationHandlerPreAuthenticatedURLTokenService creates a new mock instance.
func NewMockAuthorizationHandlerPreAuthenticatedURLTokenService(ctrl *gomock.Controller) *MockAuthorizationHandlerPreAuthenticatedURLTokenService {
	mock := &MockAuthorizationHandlerPreAuthenticatedURLTokenService{ctrl: ctrl}
	mock.recorder = &MockAuthorizationHandlerPreAuthenticatedURLTokenServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAuthorizationHandlerPreAuthenticatedURLTokenService) EXPECT() *MockAuthorizationHandlerPreAuthenticatedURLTokenServiceMockRecorder {
	return m.recorder
}

// ExchangeForAccessToken mocks base method.
func (m *MockAuthorizationHandlerPreAuthenticatedURLTokenService) ExchangeForAccessToken(ctx context.Context, client *config.OAuthClientConfig, sessionID, token string) (oauth.PrepareUserAccessTokenResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExchangeForAccessToken", ctx, client, sessionID, token)
	ret0, _ := ret[0].(oauth.PrepareUserAccessTokenResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExchangeForAccessToken indicates an expected call of ExchangeForAccessToken.
func (mr *MockAuthorizationHandlerPreAuthenticatedURLTokenServiceMockRecorder) ExchangeForAccessToken(ctx, client, sessionID, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExchangeForAccessToken", reflect.TypeOf((*MockAuthorizationHandlerPreAuthenticatedURLTokenService)(nil).ExchangeForAccessToken), ctx, client, sessionID, token)
}

// MockAuthorizationHandlerDatabase is a mock of AuthorizationHandlerDatabase interface.
type MockAuthorizationHandlerDatabase struct {
	ctrl     *gomock.Controller
	recorder *MockAuthorizationHandlerDatabaseMockRecorder
}

// MockAuthorizationHandlerDatabaseMockRecorder is the mock recorder for MockAuthorizationHandlerDatabase.
type MockAuthorizationHandlerDatabaseMockRecorder struct {
	mock *MockAuthorizationHandlerDatabase
}

// NewMockAuthorizationHandlerDatabase creates a new mock instance.
func NewMockAuthorizationHandlerDatabase(ctrl *gomock.Controller) *MockAuthorizationHandlerDatabase {
	mock := &MockAuthorizationHandlerDatabase{ctrl: ctrl}
	mock.recorder = &MockAuthorizationHandlerDatabaseMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAuthorizationHandlerDatabase) EXPECT() *MockAuthorizationHandlerDatabaseMockRecorder {
	return m.recorder
}

// WithTx mocks base method.
func (m *MockAuthorizationHandlerDatabase) WithTx(ctx context.Context, do func(context.Context) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithTx", ctx, do)
	ret0, _ := ret[0].(error)
	return ret0
}

// WithTx indicates an expected call of WithTx.
func (mr *MockAuthorizationHandlerDatabaseMockRecorder) WithTx(ctx, do interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTx", reflect.TypeOf((*MockAuthorizationHandlerDatabase)(nil).WithTx), ctx, do)
}
