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

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

import (
	context "context"
	reflect "reflect"
	time "time"

	event "github.com/authgear/authgear-server/pkg/api/event"
	app2app "github.com/authgear/authgear-server/pkg/lib/app2app"
	challenge "github.com/authgear/authgear-server/pkg/lib/authn/challenge"
	user "github.com/authgear/authgear-server/pkg/lib/authn/user"
	config "github.com/authgear/authgear-server/pkg/lib/config"
	oauth "github.com/authgear/authgear-server/pkg/lib/oauth"
	handler "github.com/authgear/authgear-server/pkg/lib/oauth/handler"
	oidc "github.com/authgear/authgear-server/pkg/lib/oauth/oidc"
	protocol "github.com/authgear/authgear-server/pkg/lib/oauth/protocol"
	ratelimit "github.com/authgear/authgear-server/pkg/lib/ratelimit"
	resourcescope "github.com/authgear/authgear-server/pkg/lib/resourcescope"
	access "github.com/authgear/authgear-server/pkg/lib/session/access"
	idpsession "github.com/authgear/authgear-server/pkg/lib/session/idpsession"
	gomock "github.com/golang/mock/gomock"
	jwk "github.com/lestrrat-go/jwx/v2/jwk"
	jwt "github.com/lestrrat-go/jwx/v2/jwt"
)

// MockIDTokenIssuer is a mock of IDTokenIssuer interface.
type MockIDTokenIssuer struct {
	ctrl     *gomock.Controller
	recorder *MockIDTokenIssuerMockRecorder
}

// MockIDTokenIssuerMockRecorder is the mock recorder for MockIDTokenIssuer.
type MockIDTokenIssuerMockRecorder struct {
	mock *MockIDTokenIssuer
}

// NewMockIDTokenIssuer creates a new mock instance.
func NewMockIDTokenIssuer(ctrl *gomock.Controller) *MockIDTokenIssuer {
	mock := &MockIDTokenIssuer{ctrl: ctrl}
	mock.recorder = &MockIDTokenIssuerMockRecorder{mock}
	return mock
}

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

// Iss mocks base method.
func (m *MockIDTokenIssuer) Iss() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Iss")
	ret0, _ := ret[0].(string)
	return ret0
}

// Iss indicates an expected call of Iss.
func (mr *MockIDTokenIssuerMockRecorder) Iss() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iss", reflect.TypeOf((*MockIDTokenIssuer)(nil).Iss))
}

// MakeIDTokenFromPreparationResult mocks base method.
func (m *MockIDTokenIssuer) MakeIDTokenFromPreparationResult(ctx context.Context, opts oidc.MakeIDTokenFromPreparationResultOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MakeIDTokenFromPreparationResult", ctx, opts)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MakeIDTokenFromPreparationResult indicates an expected call of MakeIDTokenFromPreparationResult.
func (mr *MockIDTokenIssuerMockRecorder) MakeIDTokenFromPreparationResult(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeIDTokenFromPreparationResult", reflect.TypeOf((*MockIDTokenIssuer)(nil).MakeIDTokenFromPreparationResult), ctx, opts)
}

// PrepareIDToken mocks base method.
func (m *MockIDTokenIssuer) PrepareIDToken(ctx context.Context, opts oidc.PrepareIDTokenOptions) (*oidc.PrepareIDTokenResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrepareIDToken", ctx, opts)
	ret0, _ := ret[0].(*oidc.PrepareIDTokenResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PrepareIDToken indicates an expected call of PrepareIDToken.
func (mr *MockIDTokenIssuerMockRecorder) PrepareIDToken(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareIDToken", reflect.TypeOf((*MockIDTokenIssuer)(nil).PrepareIDToken), ctx, opts)
}

// VerifyIDToken mocks base method.
func (m *MockIDTokenIssuer) VerifyIDToken(idToken string) (jwt.Token, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyIDToken", idToken)
	ret0, _ := ret[0].(jwt.Token)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyIDToken indicates an expected call of VerifyIDToken.
func (mr *MockIDTokenIssuerMockRecorder) VerifyIDToken(idToken interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyIDToken", reflect.TypeOf((*MockIDTokenIssuer)(nil).VerifyIDToken), idToken)
}

// MockEventService is a mock of EventService interface.
type MockEventService struct {
	ctrl     *gomock.Controller
	recorder *MockEventServiceMockRecorder
}

// MockEventServiceMockRecorder is the mock recorder for MockEventService.
type MockEventServiceMockRecorder struct {
	mock *MockEventService
}

// NewMockEventService creates a new mock instance.
func NewMockEventService(ctrl *gomock.Controller) *MockEventService {
	mock := &MockEventService{ctrl: ctrl}
	mock.recorder = &MockEventServiceMockRecorder{mock}
	return mock
}

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

// DispatchEventOnCommit mocks base method.
func (m *MockEventService) DispatchEventOnCommit(ctx context.Context, payload event.Payload) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DispatchEventOnCommit", ctx, payload)
	ret0, _ := ret[0].(error)
	return ret0
}

// DispatchEventOnCommit indicates an expected call of DispatchEventOnCommit.
func (mr *MockEventServiceMockRecorder) DispatchEventOnCommit(ctx, payload interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DispatchEventOnCommit", reflect.TypeOf((*MockEventService)(nil).DispatchEventOnCommit), ctx, payload)
}

// MockTokenHandlerUserFacade is a mock of TokenHandlerUserFacade interface.
type MockTokenHandlerUserFacade struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerUserFacadeMockRecorder
}

// MockTokenHandlerUserFacadeMockRecorder is the mock recorder for MockTokenHandlerUserFacade.
type MockTokenHandlerUserFacadeMockRecorder struct {
	mock *MockTokenHandlerUserFacade
}

// NewMockTokenHandlerUserFacade creates a new mock instance.
func NewMockTokenHandlerUserFacade(ctrl *gomock.Controller) *MockTokenHandlerUserFacade {
	mock := &MockTokenHandlerUserFacade{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerUserFacadeMockRecorder{mock}
	return mock
}

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

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

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

// MockApp2AppService is a mock of App2AppService interface.
type MockApp2AppService struct {
	ctrl     *gomock.Controller
	recorder *MockApp2AppServiceMockRecorder
}

// MockApp2AppServiceMockRecorder is the mock recorder for MockApp2AppService.
type MockApp2AppServiceMockRecorder struct {
	mock *MockApp2AppService
}

// NewMockApp2AppService creates a new mock instance.
func NewMockApp2AppService(ctrl *gomock.Controller) *MockApp2AppService {
	mock := &MockApp2AppService{ctrl: ctrl}
	mock.recorder = &MockApp2AppServiceMockRecorder{mock}
	return mock
}

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

// ParseToken mocks base method.
func (m *MockApp2AppService) ParseToken(requestJWT string, key jwk.Key) (*app2app.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseToken", requestJWT, key)
	ret0, _ := ret[0].(*app2app.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ParseToken indicates an expected call of ParseToken.
func (mr *MockApp2AppServiceMockRecorder) ParseToken(requestJWT, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseToken", reflect.TypeOf((*MockApp2AppService)(nil).ParseToken), requestJWT, key)
}

// ParseTokenUnverified mocks base method.
func (m *MockApp2AppService) ParseTokenUnverified(requestJWT string) (*app2app.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseTokenUnverified", requestJWT)
	ret0, _ := ret[0].(*app2app.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ParseTokenUnverified indicates an expected call of ParseTokenUnverified.
func (mr *MockApp2AppServiceMockRecorder) ParseTokenUnverified(requestJWT interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseTokenUnverified", reflect.TypeOf((*MockApp2AppService)(nil).ParseTokenUnverified), requestJWT)
}

// MockChallengeProvider is a mock of ChallengeProvider interface.
type MockChallengeProvider struct {
	ctrl     *gomock.Controller
	recorder *MockChallengeProviderMockRecorder
}

// MockChallengeProviderMockRecorder is the mock recorder for MockChallengeProvider.
type MockChallengeProviderMockRecorder struct {
	mock *MockChallengeProvider
}

// NewMockChallengeProvider creates a new mock instance.
func NewMockChallengeProvider(ctrl *gomock.Controller) *MockChallengeProvider {
	mock := &MockChallengeProvider{ctrl: ctrl}
	mock.recorder = &MockChallengeProviderMockRecorder{mock}
	return mock
}

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

// Consume mocks base method.
func (m *MockChallengeProvider) Consume(ctx context.Context, token string) (*challenge.Purpose, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Consume", ctx, token)
	ret0, _ := ret[0].(*challenge.Purpose)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Consume indicates an expected call of Consume.
func (mr *MockChallengeProviderMockRecorder) Consume(ctx, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Consume", reflect.TypeOf((*MockChallengeProvider)(nil).Consume), ctx, token)
}

// MockTokenHandlerCodeGrantStore is a mock of TokenHandlerCodeGrantStore interface.
type MockTokenHandlerCodeGrantStore struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerCodeGrantStoreMockRecorder
}

// MockTokenHandlerCodeGrantStoreMockRecorder is the mock recorder for MockTokenHandlerCodeGrantStore.
type MockTokenHandlerCodeGrantStoreMockRecorder struct {
	mock *MockTokenHandlerCodeGrantStore
}

// NewMockTokenHandlerCodeGrantStore creates a new mock instance.
func NewMockTokenHandlerCodeGrantStore(ctrl *gomock.Controller) *MockTokenHandlerCodeGrantStore {
	mock := &MockTokenHandlerCodeGrantStore{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerCodeGrantStoreMockRecorder{mock}
	return mock
}

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

// DeleteCodeGrant mocks base method.
func (m *MockTokenHandlerCodeGrantStore) DeleteCodeGrant(ctx context.Context, g *oauth.CodeGrant) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCodeGrant", ctx, g)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCodeGrant indicates an expected call of DeleteCodeGrant.
func (mr *MockTokenHandlerCodeGrantStoreMockRecorder) DeleteCodeGrant(ctx, g interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCodeGrant", reflect.TypeOf((*MockTokenHandlerCodeGrantStore)(nil).DeleteCodeGrant), ctx, g)
}

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

// GetCodeGrant indicates an expected call of GetCodeGrant.
func (mr *MockTokenHandlerCodeGrantStoreMockRecorder) GetCodeGrant(ctx, codeHash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCodeGrant", reflect.TypeOf((*MockTokenHandlerCodeGrantStore)(nil).GetCodeGrant), ctx, codeHash)
}

// MockTokenHandlerSettingsActionGrantStore is a mock of TokenHandlerSettingsActionGrantStore interface.
type MockTokenHandlerSettingsActionGrantStore struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerSettingsActionGrantStoreMockRecorder
}

// MockTokenHandlerSettingsActionGrantStoreMockRecorder is the mock recorder for MockTokenHandlerSettingsActionGrantStore.
type MockTokenHandlerSettingsActionGrantStoreMockRecorder struct {
	mock *MockTokenHandlerSettingsActionGrantStore
}

// NewMockTokenHandlerSettingsActionGrantStore creates a new mock instance.
func NewMockTokenHandlerSettingsActionGrantStore(ctrl *gomock.Controller) *MockTokenHandlerSettingsActionGrantStore {
	mock := &MockTokenHandlerSettingsActionGrantStore{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerSettingsActionGrantStoreMockRecorder{mock}
	return mock
}

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

// DeleteSettingsActionGrant mocks base method.
func (m *MockTokenHandlerSettingsActionGrantStore) DeleteSettingsActionGrant(ctx context.Context, g *oauth.SettingsActionGrant) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSettingsActionGrant", ctx, g)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSettingsActionGrant indicates an expected call of DeleteSettingsActionGrant.
func (mr *MockTokenHandlerSettingsActionGrantStoreMockRecorder) DeleteSettingsActionGrant(ctx, g interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSettingsActionGrant", reflect.TypeOf((*MockTokenHandlerSettingsActionGrantStore)(nil).DeleteSettingsActionGrant), ctx, g)
}

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

// GetSettingsActionGrant indicates an expected call of GetSettingsActionGrant.
func (mr *MockTokenHandlerSettingsActionGrantStoreMockRecorder) GetSettingsActionGrant(ctx, codeHash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSettingsActionGrant", reflect.TypeOf((*MockTokenHandlerSettingsActionGrantStore)(nil).GetSettingsActionGrant), ctx, codeHash)
}

// MockTokenHandlerOfflineGrantStore is a mock of TokenHandlerOfflineGrantStore interface.
type MockTokenHandlerOfflineGrantStore struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerOfflineGrantStoreMockRecorder
}

// MockTokenHandlerOfflineGrantStoreMockRecorder is the mock recorder for MockTokenHandlerOfflineGrantStore.
type MockTokenHandlerOfflineGrantStoreMockRecorder struct {
	mock *MockTokenHandlerOfflineGrantStore
}

// NewMockTokenHandlerOfflineGrantStore creates a new mock instance.
func NewMockTokenHandlerOfflineGrantStore(ctrl *gomock.Controller) *MockTokenHandlerOfflineGrantStore {
	mock := &MockTokenHandlerOfflineGrantStore{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerOfflineGrantStoreMockRecorder{mock}
	return mock
}

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

// DeleteOfflineGrant mocks base method.
func (m *MockTokenHandlerOfflineGrantStore) DeleteOfflineGrant(ctx context.Context, g *oauth.OfflineGrant) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOfflineGrant", ctx, g)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOfflineGrant indicates an expected call of DeleteOfflineGrant.
func (mr *MockTokenHandlerOfflineGrantStoreMockRecorder) DeleteOfflineGrant(ctx, g interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOfflineGrant", reflect.TypeOf((*MockTokenHandlerOfflineGrantStore)(nil).DeleteOfflineGrant), ctx, g)
}

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

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

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

// ListOfflineGrants indicates an expected call of ListOfflineGrants.
func (mr *MockTokenHandlerOfflineGrantStoreMockRecorder) ListOfflineGrants(ctx, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOfflineGrants", reflect.TypeOf((*MockTokenHandlerOfflineGrantStore)(nil).ListOfflineGrants), ctx, userID)
}

// UpdateOfflineGrantApp2AppDeviceKey mocks base method.
func (m *MockTokenHandlerOfflineGrantStore) UpdateOfflineGrantApp2AppDeviceKey(ctx context.Context, id, newKey string, expireAt time.Time) (*oauth.OfflineGrant, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOfflineGrantApp2AppDeviceKey", ctx, id, newKey, expireAt)
	ret0, _ := ret[0].(*oauth.OfflineGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOfflineGrantApp2AppDeviceKey indicates an expected call of UpdateOfflineGrantApp2AppDeviceKey.
func (mr *MockTokenHandlerOfflineGrantStoreMockRecorder) UpdateOfflineGrantApp2AppDeviceKey(ctx, id, newKey, expireAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOfflineGrantApp2AppDeviceKey", reflect.TypeOf((*MockTokenHandlerOfflineGrantStore)(nil).UpdateOfflineGrantApp2AppDeviceKey), ctx, id, newKey, expireAt)
}

// UpdateOfflineGrantAuthenticatedAt mocks base method.
func (m *MockTokenHandlerOfflineGrantStore) UpdateOfflineGrantAuthenticatedAt(ctx context.Context, id string, authenticatedAt, expireAt time.Time) (*oauth.OfflineGrant, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOfflineGrantAuthenticatedAt", ctx, id, authenticatedAt, expireAt)
	ret0, _ := ret[0].(*oauth.OfflineGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOfflineGrantAuthenticatedAt indicates an expected call of UpdateOfflineGrantAuthenticatedAt.
func (mr *MockTokenHandlerOfflineGrantStoreMockRecorder) UpdateOfflineGrantAuthenticatedAt(ctx, id, authenticatedAt, expireAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOfflineGrantAuthenticatedAt", reflect.TypeOf((*MockTokenHandlerOfflineGrantStore)(nil).UpdateOfflineGrantAuthenticatedAt), ctx, id, authenticatedAt, expireAt)
}

// UpdateOfflineGrantDeviceInfo mocks base method.
func (m *MockTokenHandlerOfflineGrantStore) UpdateOfflineGrantDeviceInfo(ctx context.Context, id string, deviceInfo map[string]interface{}, expireAt time.Time) (*oauth.OfflineGrant, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOfflineGrantDeviceInfo", ctx, id, deviceInfo, expireAt)
	ret0, _ := ret[0].(*oauth.OfflineGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOfflineGrantDeviceInfo indicates an expected call of UpdateOfflineGrantDeviceInfo.
func (mr *MockTokenHandlerOfflineGrantStoreMockRecorder) UpdateOfflineGrantDeviceInfo(ctx, id, deviceInfo, expireAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOfflineGrantDeviceInfo", reflect.TypeOf((*MockTokenHandlerOfflineGrantStore)(nil).UpdateOfflineGrantDeviceInfo), ctx, id, deviceInfo, expireAt)
}

// UpdateOfflineGrantDeviceSecretHash mocks base method.
func (m *MockTokenHandlerOfflineGrantStore) UpdateOfflineGrantDeviceSecretHash(ctx context.Context, grantID, newDeviceSecretHash, dpopJKT string, expireAt time.Time) (*oauth.OfflineGrant, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOfflineGrantDeviceSecretHash", ctx, grantID, newDeviceSecretHash, dpopJKT, expireAt)
	ret0, _ := ret[0].(*oauth.OfflineGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOfflineGrantDeviceSecretHash indicates an expected call of UpdateOfflineGrantDeviceSecretHash.
func (mr *MockTokenHandlerOfflineGrantStoreMockRecorder) UpdateOfflineGrantDeviceSecretHash(ctx, grantID, newDeviceSecretHash, dpopJKT, expireAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOfflineGrantDeviceSecretHash", reflect.TypeOf((*MockTokenHandlerOfflineGrantStore)(nil).UpdateOfflineGrantDeviceSecretHash), ctx, grantID, newDeviceSecretHash, dpopJKT, expireAt)
}

// MockTokenHandlerAppSessionTokenStore is a mock of TokenHandlerAppSessionTokenStore interface.
type MockTokenHandlerAppSessionTokenStore struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerAppSessionTokenStoreMockRecorder
}

// MockTokenHandlerAppSessionTokenStoreMockRecorder is the mock recorder for MockTokenHandlerAppSessionTokenStore.
type MockTokenHandlerAppSessionTokenStoreMockRecorder struct {
	mock *MockTokenHandlerAppSessionTokenStore
}

// NewMockTokenHandlerAppSessionTokenStore creates a new mock instance.
func NewMockTokenHandlerAppSessionTokenStore(ctrl *gomock.Controller) *MockTokenHandlerAppSessionTokenStore {
	mock := &MockTokenHandlerAppSessionTokenStore{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerAppSessionTokenStoreMockRecorder{mock}
	return mock
}

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

// CreateAppSessionToken mocks base method.
func (m *MockTokenHandlerAppSessionTokenStore) CreateAppSessionToken(ctx context.Context, t *oauth.AppSessionToken) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAppSessionToken", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateAppSessionToken indicates an expected call of CreateAppSessionToken.
func (mr *MockTokenHandlerAppSessionTokenStoreMockRecorder) CreateAppSessionToken(ctx, t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAppSessionToken", reflect.TypeOf((*MockTokenHandlerAppSessionTokenStore)(nil).CreateAppSessionToken), ctx, t)
}

// MockTokenHandlerOfflineGrantService is a mock of TokenHandlerOfflineGrantService interface.
type MockTokenHandlerOfflineGrantService struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerOfflineGrantServiceMockRecorder
}

// MockTokenHandlerOfflineGrantServiceMockRecorder is the mock recorder for MockTokenHandlerOfflineGrantService.
type MockTokenHandlerOfflineGrantServiceMockRecorder struct {
	mock *MockTokenHandlerOfflineGrantService
}

// NewMockTokenHandlerOfflineGrantService creates a new mock instance.
func NewMockTokenHandlerOfflineGrantService(ctrl *gomock.Controller) *MockTokenHandlerOfflineGrantService {
	mock := &MockTokenHandlerOfflineGrantService{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerOfflineGrantServiceMockRecorder{mock}
	return mock
}

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

// AccessOfflineGrant mocks base method.
func (m *MockTokenHandlerOfflineGrantService) AccessOfflineGrant(ctx context.Context, id, refreshTokenHash string, accessEvent *access.Event, expireAt time.Time) (*oauth.OfflineGrant, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AccessOfflineGrant", ctx, id, refreshTokenHash, accessEvent, expireAt)
	ret0, _ := ret[0].(*oauth.OfflineGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AccessOfflineGrant indicates an expected call of AccessOfflineGrant.
func (mr *MockTokenHandlerOfflineGrantServiceMockRecorder) AccessOfflineGrant(ctx, id, refreshTokenHash, accessEvent, expireAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccessOfflineGrant", reflect.TypeOf((*MockTokenHandlerOfflineGrantService)(nil).AccessOfflineGrant), ctx, id, refreshTokenHash, accessEvent, expireAt)
}

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

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

// MockTokenHandlerRateLimiter is a mock of TokenHandlerRateLimiter interface.
type MockTokenHandlerRateLimiter struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerRateLimiterMockRecorder
}

// MockTokenHandlerRateLimiterMockRecorder is the mock recorder for MockTokenHandlerRateLimiter.
type MockTokenHandlerRateLimiterMockRecorder struct {
	mock *MockTokenHandlerRateLimiter
}

// NewMockTokenHandlerRateLimiter creates a new mock instance.
func NewMockTokenHandlerRateLimiter(ctrl *gomock.Controller) *MockTokenHandlerRateLimiter {
	mock := &MockTokenHandlerRateLimiter{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerRateLimiterMockRecorder{mock}
	return mock
}

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

// Allow mocks base method.
func (m *MockTokenHandlerRateLimiter) Allow(ctx context.Context, spec ratelimit.BucketSpec) (*ratelimit.FailedReservation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Allow", ctx, spec)
	ret0, _ := ret[0].(*ratelimit.FailedReservation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Allow indicates an expected call of Allow.
func (mr *MockTokenHandlerRateLimiterMockRecorder) Allow(ctx, spec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Allow", reflect.TypeOf((*MockTokenHandlerRateLimiter)(nil).Allow), ctx, spec)
}

// MockTokenHandlerTokenService is a mock of TokenHandlerTokenService interface.
type MockTokenHandlerTokenService struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerTokenServiceMockRecorder
}

// MockTokenHandlerTokenServiceMockRecorder is the mock recorder for MockTokenHandlerTokenService.
type MockTokenHandlerTokenServiceMockRecorder struct {
	mock *MockTokenHandlerTokenService
}

// NewMockTokenHandlerTokenService creates a new mock instance.
func NewMockTokenHandlerTokenService(ctrl *gomock.Controller) *MockTokenHandlerTokenService {
	mock := &MockTokenHandlerTokenService{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerTokenServiceMockRecorder{mock}
	return mock
}

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

// IssueClientCredentialsAccessToken mocks base method.
func (m *MockTokenHandlerTokenService) IssueClientCredentialsAccessToken(ctx context.Context, options handler.ClientCredentialsAccessTokenOptions, resp protocol.TokenResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IssueClientCredentialsAccessToken", ctx, options, resp)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// IssueDeviceSecret mocks base method.
func (m *MockTokenHandlerTokenService) IssueDeviceSecret(ctx context.Context, resp protocol.TokenResponse) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IssueDeviceSecret", ctx, resp)
	ret0, _ := ret[0].(string)
	return ret0
}

// IssueDeviceSecret indicates an expected call of IssueDeviceSecret.
func (mr *MockTokenHandlerTokenServiceMockRecorder) IssueDeviceSecret(ctx, resp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IssueDeviceSecret", reflect.TypeOf((*MockTokenHandlerTokenService)(nil).IssueDeviceSecret), ctx, resp)
}

// IssueOfflineGrant mocks base method.
func (m *MockTokenHandlerTokenService) IssueOfflineGrant(ctx context.Context, client *config.OAuthClientConfig, opts handler.IssueOfflineGrantOptions, resp protocol.TokenResponse) (*oauth.OfflineGrant, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IssueOfflineGrant", ctx, client, opts, resp)
	ret0, _ := ret[0].(*oauth.OfflineGrant)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// IssueOfflineGrant indicates an expected call of IssueOfflineGrant.
func (mr *MockTokenHandlerTokenServiceMockRecorder) IssueOfflineGrant(ctx, client, opts, resp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IssueOfflineGrant", reflect.TypeOf((*MockTokenHandlerTokenService)(nil).IssueOfflineGrant), ctx, client, opts, resp)
}

// IssueRefreshTokenForOfflineGrant mocks base method.
func (m *MockTokenHandlerTokenService) IssueRefreshTokenForOfflineGrant(ctx context.Context, offlineGrantID string, client *config.OAuthClientConfig, opts handler.IssueOfflineGrantRefreshTokenOptions, resp protocol.TokenResponse) (*oauth.OfflineGrant, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IssueRefreshTokenForOfflineGrant", ctx, offlineGrantID, client, opts, resp)
	ret0, _ := ret[0].(*oauth.OfflineGrant)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// IssueRefreshTokenForOfflineGrant indicates an expected call of IssueRefreshTokenForOfflineGrant.
func (mr *MockTokenHandlerTokenServiceMockRecorder) IssueRefreshTokenForOfflineGrant(ctx, offlineGrantID, client, opts, resp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IssueRefreshTokenForOfflineGrant", reflect.TypeOf((*MockTokenHandlerTokenService)(nil).IssueRefreshTokenForOfflineGrant), ctx, offlineGrantID, client, opts, resp)
}

// ParseRefreshToken mocks base method.
func (m *MockTokenHandlerTokenService) ParseRefreshToken(ctx context.Context, token string) (*oauth.Authorization, *oauth.OfflineGrant, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseRefreshToken", ctx, token)
	ret0, _ := ret[0].(*oauth.Authorization)
	ret1, _ := ret[1].(*oauth.OfflineGrant)
	ret2, _ := ret[2].(string)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

// ParseRefreshToken indicates an expected call of ParseRefreshToken.
func (mr *MockTokenHandlerTokenServiceMockRecorder) ParseRefreshToken(ctx, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseRefreshToken", reflect.TypeOf((*MockTokenHandlerTokenService)(nil).ParseRefreshToken), ctx, token)
}

// PrepareUserAccessGrantByRefreshToken mocks base method.
func (m *MockTokenHandlerTokenService) PrepareUserAccessGrantByRefreshToken(ctx context.Context, options handler.PrepareUserAccessGrantByRefreshTokenOptions) (*handler.PrepareUserAccessGrantByRefreshTokenResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrepareUserAccessGrantByRefreshToken", ctx, options)
	ret0, _ := ret[0].(*handler.PrepareUserAccessGrantByRefreshTokenResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockTokenHandlerIDPSessionProvider is a mock of TokenHandlerIDPSessionProvider interface.
type MockTokenHandlerIDPSessionProvider struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerIDPSessionProviderMockRecorder
}

// MockTokenHandlerIDPSessionProviderMockRecorder is the mock recorder for MockTokenHandlerIDPSessionProvider.
type MockTokenHandlerIDPSessionProviderMockRecorder struct {
	mock *MockTokenHandlerIDPSessionProvider
}

// NewMockTokenHandlerIDPSessionProvider creates a new mock instance.
func NewMockTokenHandlerIDPSessionProvider(ctrl *gomock.Controller) *MockTokenHandlerIDPSessionProvider {
	mock := &MockTokenHandlerIDPSessionProvider{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerIDPSessionProviderMockRecorder{mock}
	return mock
}

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

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

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

// MockPreAuthenticatedURLTokenService is a mock of PreAuthenticatedURLTokenService interface.
type MockPreAuthenticatedURLTokenService struct {
	ctrl     *gomock.Controller
	recorder *MockPreAuthenticatedURLTokenServiceMockRecorder
}

// MockPreAuthenticatedURLTokenServiceMockRecorder is the mock recorder for MockPreAuthenticatedURLTokenService.
type MockPreAuthenticatedURLTokenServiceMockRecorder struct {
	mock *MockPreAuthenticatedURLTokenService
}

// NewMockPreAuthenticatedURLTokenService creates a new mock instance.
func NewMockPreAuthenticatedURLTokenService(ctrl *gomock.Controller) *MockPreAuthenticatedURLTokenService {
	mock := &MockPreAuthenticatedURLTokenService{ctrl: ctrl}
	mock.recorder = &MockPreAuthenticatedURLTokenServiceMockRecorder{mock}
	return mock
}

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

// IssuePreAuthenticatedURLToken mocks base method.
func (m *MockPreAuthenticatedURLTokenService) IssuePreAuthenticatedURLToken(ctx context.Context, options *handler.IssuePreAuthenticatedURLTokenOptions) (*handler.IssuePreAuthenticatedURLTokenResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IssuePreAuthenticatedURLToken", ctx, options)
	ret0, _ := ret[0].(*handler.IssuePreAuthenticatedURLTokenResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockTokenHandlerClientResourceScopeService is a mock of TokenHandlerClientResourceScopeService interface.
type MockTokenHandlerClientResourceScopeService struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerClientResourceScopeServiceMockRecorder
}

// MockTokenHandlerClientResourceScopeServiceMockRecorder is the mock recorder for MockTokenHandlerClientResourceScopeService.
type MockTokenHandlerClientResourceScopeServiceMockRecorder struct {
	mock *MockTokenHandlerClientResourceScopeService
}

// NewMockTokenHandlerClientResourceScopeService creates a new mock instance.
func NewMockTokenHandlerClientResourceScopeService(ctrl *gomock.Controller) *MockTokenHandlerClientResourceScopeService {
	mock := &MockTokenHandlerClientResourceScopeService{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerClientResourceScopeServiceMockRecorder{mock}
	return mock
}

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

// GetClientResourceByURI mocks base method.
func (m *MockTokenHandlerClientResourceScopeService) GetClientResourceByURI(ctx context.Context, clientID, uri string) (*resourcescope.Resource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClientResourceByURI", ctx, clientID, uri)
	ret0, _ := ret[0].(*resourcescope.Resource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClientResourceByURI indicates an expected call of GetClientResourceByURI.
func (mr *MockTokenHandlerClientResourceScopeServiceMockRecorder) GetClientResourceByURI(ctx, clientID, uri interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClientResourceByURI", reflect.TypeOf((*MockTokenHandlerClientResourceScopeService)(nil).GetClientResourceByURI), ctx, clientID, uri)
}

// GetClientResourceScopes mocks base method.
func (m *MockTokenHandlerClientResourceScopeService) GetClientResourceScopes(ctx context.Context, clientID, resourceID string) ([]*resourcescope.Scope, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClientResourceScopes", ctx, clientID, resourceID)
	ret0, _ := ret[0].([]*resourcescope.Scope)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClientResourceScopes indicates an expected call of GetClientResourceScopes.
func (mr *MockTokenHandlerClientResourceScopeServiceMockRecorder) GetClientResourceScopes(ctx, clientID, resourceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClientResourceScopes", reflect.TypeOf((*MockTokenHandlerClientResourceScopeService)(nil).GetClientResourceScopes), ctx, clientID, resourceID)
}

// MockTokenHandlerAppDatabase is a mock of TokenHandlerAppDatabase interface.
type MockTokenHandlerAppDatabase struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerAppDatabaseMockRecorder
}

// MockTokenHandlerAppDatabaseMockRecorder is the mock recorder for MockTokenHandlerAppDatabase.
type MockTokenHandlerAppDatabaseMockRecorder struct {
	mock *MockTokenHandlerAppDatabase
}

// NewMockTokenHandlerAppDatabase creates a new mock instance.
func NewMockTokenHandlerAppDatabase(ctrl *gomock.Controller) *MockTokenHandlerAppDatabase {
	mock := &MockTokenHandlerAppDatabase{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerAppDatabaseMockRecorder{mock}
	return mock
}

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

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

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

// MockTokenHandlerCodeGrantService is a mock of TokenHandlerCodeGrantService interface.
type MockTokenHandlerCodeGrantService struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerCodeGrantServiceMockRecorder
}

// MockTokenHandlerCodeGrantServiceMockRecorder is the mock recorder for MockTokenHandlerCodeGrantService.
type MockTokenHandlerCodeGrantServiceMockRecorder struct {
	mock *MockTokenHandlerCodeGrantService
}

// NewMockTokenHandlerCodeGrantService creates a new mock instance.
func NewMockTokenHandlerCodeGrantService(ctrl *gomock.Controller) *MockTokenHandlerCodeGrantService {
	mock := &MockTokenHandlerCodeGrantService{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerCodeGrantServiceMockRecorder{mock}
	return mock
}

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

// CreateCodeGrant mocks base method.
func (m *MockTokenHandlerCodeGrantService) CreateCodeGrant(ctx context.Context, opts *handler.CreateCodeGrantOptions) (string, *oauth.CodeGrant, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCodeGrant", ctx, opts)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(*oauth.CodeGrant)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateCodeGrant indicates an expected call of CreateCodeGrant.
func (mr *MockTokenHandlerCodeGrantServiceMockRecorder) CreateCodeGrant(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCodeGrant", reflect.TypeOf((*MockTokenHandlerCodeGrantService)(nil).CreateCodeGrant), ctx, opts)
}

// MockTokenHandlerAccessTokenEncoding is a mock of TokenHandlerAccessTokenEncoding interface.
type MockTokenHandlerAccessTokenEncoding struct {
	ctrl     *gomock.Controller
	recorder *MockTokenHandlerAccessTokenEncodingMockRecorder
}

// MockTokenHandlerAccessTokenEncodingMockRecorder is the mock recorder for MockTokenHandlerAccessTokenEncoding.
type MockTokenHandlerAccessTokenEncodingMockRecorder struct {
	mock *MockTokenHandlerAccessTokenEncoding
}

// NewMockTokenHandlerAccessTokenEncoding creates a new mock instance.
func NewMockTokenHandlerAccessTokenEncoding(ctrl *gomock.Controller) *MockTokenHandlerAccessTokenEncoding {
	mock := &MockTokenHandlerAccessTokenEncoding{ctrl: ctrl}
	mock.recorder = &MockTokenHandlerAccessTokenEncodingMockRecorder{mock}
	return mock
}

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

// MakeUserAccessTokenFromPreparationResult mocks base method.
func (m *MockTokenHandlerAccessTokenEncoding) 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 *MockTokenHandlerAccessTokenEncodingMockRecorder) MakeUserAccessTokenFromPreparationResult(ctx, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeUserAccessTokenFromPreparationResult", reflect.TypeOf((*MockTokenHandlerAccessTokenEncoding)(nil).MakeUserAccessTokenFromPreparationResult), ctx, options)
}
