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

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

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

	oauth "github.com/authgear/authgear-server/pkg/lib/oauth"
	gomock "github.com/golang/mock/gomock"
)

// MockTokenServiceAuthorizationStore is a mock of TokenServiceAuthorizationStore interface.
type MockTokenServiceAuthorizationStore struct {
	ctrl     *gomock.Controller
	recorder *MockTokenServiceAuthorizationStoreMockRecorder
}

// MockTokenServiceAuthorizationStoreMockRecorder is the mock recorder for MockTokenServiceAuthorizationStore.
type MockTokenServiceAuthorizationStoreMockRecorder struct {
	mock *MockTokenServiceAuthorizationStore
}

// NewMockTokenServiceAuthorizationStore creates a new mock instance.
func NewMockTokenServiceAuthorizationStore(ctrl *gomock.Controller) *MockTokenServiceAuthorizationStore {
	mock := &MockTokenServiceAuthorizationStore{ctrl: ctrl}
	mock.recorder = &MockTokenServiceAuthorizationStoreMockRecorder{mock}
	return mock
}

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

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

// Create indicates an expected call of Create.
func (mr *MockTokenServiceAuthorizationStoreMockRecorder) Create(ctx, a interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockTokenServiceAuthorizationStore)(nil).Create), ctx, a)
}

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

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

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

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

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

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

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

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

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

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

// UpdateScopes indicates an expected call of UpdateScopes.
func (mr *MockTokenServiceAuthorizationStoreMockRecorder) UpdateScopes(ctx, a interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateScopes", reflect.TypeOf((*MockTokenServiceAuthorizationStore)(nil).UpdateScopes), ctx, a)
}

// MockTokenServiceOfflineGrantStore is a mock of TokenServiceOfflineGrantStore interface.
type MockTokenServiceOfflineGrantStore struct {
	ctrl     *gomock.Controller
	recorder *MockTokenServiceOfflineGrantStoreMockRecorder
}

// MockTokenServiceOfflineGrantStoreMockRecorder is the mock recorder for MockTokenServiceOfflineGrantStore.
type MockTokenServiceOfflineGrantStoreMockRecorder struct {
	mock *MockTokenServiceOfflineGrantStore
}

// NewMockTokenServiceOfflineGrantStore creates a new mock instance.
func NewMockTokenServiceOfflineGrantStore(ctrl *gomock.Controller) *MockTokenServiceOfflineGrantStore {
	mock := &MockTokenServiceOfflineGrantStore{ctrl: ctrl}
	mock.recorder = &MockTokenServiceOfflineGrantStoreMockRecorder{mock}
	return mock
}

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

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

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

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

// AddOfflineGrantSAMLServiceProviderParticipant indicates an expected call of AddOfflineGrantSAMLServiceProviderParticipant.
func (mr *MockTokenServiceOfflineGrantStoreMockRecorder) AddOfflineGrantSAMLServiceProviderParticipant(ctx, grantID, newServiceProviderID, expireAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOfflineGrantSAMLServiceProviderParticipant", reflect.TypeOf((*MockTokenServiceOfflineGrantStore)(nil).AddOfflineGrantSAMLServiceProviderParticipant), ctx, grantID, newServiceProviderID, expireAt)
}

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

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

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

// CreateOfflineGrant indicates an expected call of CreateOfflineGrant.
func (mr *MockTokenServiceOfflineGrantStoreMockRecorder) CreateOfflineGrant(ctx, offlineGrant interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOfflineGrant", reflect.TypeOf((*MockTokenServiceOfflineGrantStore)(nil).CreateOfflineGrant), ctx, offlineGrant)
}

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

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

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

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

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

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

// RemoveOfflineGrantRefreshTokens indicates an expected call of RemoveOfflineGrantRefreshTokens.
func (mr *MockTokenServiceOfflineGrantStoreMockRecorder) RemoveOfflineGrantRefreshTokens(ctx, grantID, tokenHashes, expireAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveOfflineGrantRefreshTokens", reflect.TypeOf((*MockTokenServiceOfflineGrantStore)(nil).RemoveOfflineGrantRefreshTokens), ctx, grantID, tokenHashes, expireAt)
}

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

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

// UpdateOfflineGrantApp2AppDeviceKey mocks base method.
func (m *MockTokenServiceOfflineGrantStore) 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 *MockTokenServiceOfflineGrantStoreMockRecorder) UpdateOfflineGrantApp2AppDeviceKey(ctx, id, newKey, expireAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOfflineGrantApp2AppDeviceKey", reflect.TypeOf((*MockTokenServiceOfflineGrantStore)(nil).UpdateOfflineGrantApp2AppDeviceKey), ctx, id, newKey, expireAt)
}

// UpdateOfflineGrantAuthenticatedAt mocks base method.
func (m *MockTokenServiceOfflineGrantStore) 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 *MockTokenServiceOfflineGrantStoreMockRecorder) UpdateOfflineGrantAuthenticatedAt(ctx, id, authenticatedAt, expireAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOfflineGrantAuthenticatedAt", reflect.TypeOf((*MockTokenServiceOfflineGrantStore)(nil).UpdateOfflineGrantAuthenticatedAt), ctx, id, authenticatedAt, expireAt)
}

// UpdateOfflineGrantDeviceInfo mocks base method.
func (m *MockTokenServiceOfflineGrantStore) 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 *MockTokenServiceOfflineGrantStoreMockRecorder) UpdateOfflineGrantDeviceInfo(ctx, id, deviceInfo, expireAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOfflineGrantDeviceInfo", reflect.TypeOf((*MockTokenServiceOfflineGrantStore)(nil).UpdateOfflineGrantDeviceInfo), ctx, id, deviceInfo, expireAt)
}

// UpdateOfflineGrantDeviceSecretHash mocks base method.
func (m *MockTokenServiceOfflineGrantStore) 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 *MockTokenServiceOfflineGrantStoreMockRecorder) UpdateOfflineGrantDeviceSecretHash(ctx, grantID, newDeviceSecretHash, dpopJKT, expireAt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOfflineGrantDeviceSecretHash", reflect.TypeOf((*MockTokenServiceOfflineGrantStore)(nil).UpdateOfflineGrantDeviceSecretHash), ctx, grantID, newDeviceSecretHash, dpopJKT, expireAt)
}

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

// UpdateOfflineGrantWithMutator indicates an expected call of UpdateOfflineGrantWithMutator.
func (mr *MockTokenServiceOfflineGrantStoreMockRecorder) UpdateOfflineGrantWithMutator(ctx, grantID, expireAt, mutator interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOfflineGrantWithMutator", reflect.TypeOf((*MockTokenServiceOfflineGrantStore)(nil).UpdateOfflineGrantWithMutator), ctx, grantID, expireAt, mutator)
}

// MockTokenServiceAccessGrantStore is a mock of TokenServiceAccessGrantStore interface.
type MockTokenServiceAccessGrantStore struct {
	ctrl     *gomock.Controller
	recorder *MockTokenServiceAccessGrantStoreMockRecorder
}

// MockTokenServiceAccessGrantStoreMockRecorder is the mock recorder for MockTokenServiceAccessGrantStore.
type MockTokenServiceAccessGrantStoreMockRecorder struct {
	mock *MockTokenServiceAccessGrantStore
}

// NewMockTokenServiceAccessGrantStore creates a new mock instance.
func NewMockTokenServiceAccessGrantStore(ctrl *gomock.Controller) *MockTokenServiceAccessGrantStore {
	mock := &MockTokenServiceAccessGrantStore{ctrl: ctrl}
	mock.recorder = &MockTokenServiceAccessGrantStoreMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// GetAccessGrant indicates an expected call of GetAccessGrant.
func (mr *MockTokenServiceAccessGrantStoreMockRecorder) GetAccessGrant(ctx, tokenHash interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessGrant", reflect.TypeOf((*MockTokenServiceAccessGrantStore)(nil).GetAccessGrant), ctx, tokenHash)
}

// MockTokenServiceOfflineGrantService is a mock of TokenServiceOfflineGrantService interface.
type MockTokenServiceOfflineGrantService struct {
	ctrl     *gomock.Controller
	recorder *MockTokenServiceOfflineGrantServiceMockRecorder
}

// MockTokenServiceOfflineGrantServiceMockRecorder is the mock recorder for MockTokenServiceOfflineGrantService.
type MockTokenServiceOfflineGrantServiceMockRecorder struct {
	mock *MockTokenServiceOfflineGrantService
}

// NewMockTokenServiceOfflineGrantService creates a new mock instance.
func NewMockTokenServiceOfflineGrantService(ctrl *gomock.Controller) *MockTokenServiceOfflineGrantService {
	mock := &MockTokenServiceOfflineGrantService{ctrl: ctrl}
	mock.recorder = &MockTokenServiceOfflineGrantServiceMockRecorder{mock}
	return mock
}

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

// ComputeOfflineGrantExpiry mocks base method.
func (m *MockTokenServiceOfflineGrantService) ComputeOfflineGrantExpiry(session *oauth.OfflineGrant) (time.Time, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ComputeOfflineGrantExpiry", session)
	ret0, _ := ret[0].(time.Time)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ComputeOfflineGrantExpiry indicates an expected call of ComputeOfflineGrantExpiry.
func (mr *MockTokenServiceOfflineGrantServiceMockRecorder) ComputeOfflineGrantExpiry(session interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ComputeOfflineGrantExpiry", reflect.TypeOf((*MockTokenServiceOfflineGrantService)(nil).ComputeOfflineGrantExpiry), session)
}

// CreateNewRefreshToken mocks base method.
func (m *MockTokenServiceOfflineGrantService) CreateNewRefreshToken(ctx context.Context, options oauth.CreateNewRefreshTokenOptions) (*oauth.CreateNewRefreshTokenResult, *oauth.OfflineGrant, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNewRefreshToken", ctx, options)
	ret0, _ := ret[0].(*oauth.CreateNewRefreshTokenResult)
	ret1, _ := ret[1].(*oauth.OfflineGrant)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

// RotateRefreshToken mocks base method.
func (m *MockTokenServiceOfflineGrantService) RotateRefreshToken(ctx context.Context, options oauth.RotateRefreshTokenOptions) (*oauth.RotateRefreshTokenResult, *oauth.OfflineGrant, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RotateRefreshToken", ctx, options)
	ret0, _ := ret[0].(*oauth.RotateRefreshTokenResult)
	ret1, _ := ret[1].(*oauth.OfflineGrant)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// MockTokenServiceAccessGrantService is a mock of TokenServiceAccessGrantService interface.
type MockTokenServiceAccessGrantService struct {
	ctrl     *gomock.Controller
	recorder *MockTokenServiceAccessGrantServiceMockRecorder
}

// MockTokenServiceAccessGrantServiceMockRecorder is the mock recorder for MockTokenServiceAccessGrantService.
type MockTokenServiceAccessGrantServiceMockRecorder struct {
	mock *MockTokenServiceAccessGrantService
}

// NewMockTokenServiceAccessGrantService creates a new mock instance.
func NewMockTokenServiceAccessGrantService(ctrl *gomock.Controller) *MockTokenServiceAccessGrantService {
	mock := &MockTokenServiceAccessGrantService{ctrl: ctrl}
	mock.recorder = &MockTokenServiceAccessGrantServiceMockRecorder{mock}
	return mock
}

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

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

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

// MockTokenServiceAccessTokenIssuer is a mock of TokenServiceAccessTokenIssuer interface.
type MockTokenServiceAccessTokenIssuer struct {
	ctrl     *gomock.Controller
	recorder *MockTokenServiceAccessTokenIssuerMockRecorder
}

// MockTokenServiceAccessTokenIssuerMockRecorder is the mock recorder for MockTokenServiceAccessTokenIssuer.
type MockTokenServiceAccessTokenIssuerMockRecorder struct {
	mock *MockTokenServiceAccessTokenIssuer
}

// NewMockTokenServiceAccessTokenIssuer creates a new mock instance.
func NewMockTokenServiceAccessTokenIssuer(ctrl *gomock.Controller) *MockTokenServiceAccessTokenIssuer {
	mock := &MockTokenServiceAccessTokenIssuer{ctrl: ctrl}
	mock.recorder = &MockTokenServiceAccessTokenIssuerMockRecorder{mock}
	return mock
}

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

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

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