zitadel/backend/v3/domain/mock/session.mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: SessionRepository)
//
// Generated by this command:
//
//	mockgen -typed -package domainmock -destination ./mock/session.mock.go . SessionRepository
//

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

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

	domain "github.com/zitadel/zitadel/backend/v3/domain"
	database "github.com/zitadel/zitadel/backend/v3/storage/database"
	gomock "go.uber.org/mock/gomock"
)

// MockSessionRepository is a mock of SessionRepository interface.
type MockSessionRepository struct {
	ctrl     *gomock.Controller
	recorder *MockSessionRepositoryMockRecorder
	isgomock struct{}
}

// MockSessionRepositoryMockRecorder is the mock recorder for MockSessionRepository.
type MockSessionRepositoryMockRecorder struct {
	mock *MockSessionRepository
}

// NewMockSessionRepository creates a new mock instance.
func NewMockSessionRepository(ctrl *gomock.Controller) *MockSessionRepository {
	mock := &MockSessionRepository{ctrl: ctrl}
	mock.recorder = &MockSessionRepositoryMockRecorder{mock}
	return mock
}

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

// ClearFactor mocks base method.
func (m *MockSessionRepository) ClearFactor(factor domain.SessionFactorType) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClearFactor", factor)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// ClearFactor indicates an expected call of ClearFactor.
func (mr *MockSessionRepositoryMockRecorder) ClearFactor(factor any) *MockSessionRepositoryClearFactorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearFactor", reflect.TypeOf((*MockSessionRepository)(nil).ClearFactor), factor)
	return &MockSessionRepositoryClearFactorCall{Call: call}
}

// MockSessionRepositoryClearFactorCall wrap *gomock.Call
type MockSessionRepositoryClearFactorCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryClearFactorCall) Return(arg0 database.Change) *MockSessionRepositoryClearFactorCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryClearFactorCall) Do(f func(domain.SessionFactorType) database.Change) *MockSessionRepositoryClearFactorCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryClearFactorCall) DoAndReturn(f func(domain.SessionFactorType) database.Change) *MockSessionRepositoryClearFactorCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Create mocks base method.
func (m *MockSessionRepository) Create(ctx context.Context, client database.QueryExecutor, user *domain.Session) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, client, user)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockSessionRepositoryMockRecorder) Create(ctx, client, user any) *MockSessionRepositoryCreateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSessionRepository)(nil).Create), ctx, client, user)
	return &MockSessionRepositoryCreateCall{Call: call}
}

// MockSessionRepositoryCreateCall wrap *gomock.Call
type MockSessionRepositoryCreateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryCreateCall) Return(arg0 error) *MockSessionRepositoryCreateCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryCreateCall) Do(f func(context.Context, database.QueryExecutor, *domain.Session) error) *MockSessionRepositoryCreateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryCreateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.Session) error) *MockSessionRepositoryCreateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreatedAtColumn mocks base method.
func (m *MockSessionRepository) CreatedAtColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatedAtColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// CreatedAtColumn indicates an expected call of CreatedAtColumn.
func (mr *MockSessionRepositoryMockRecorder) CreatedAtColumn() *MockSessionRepositoryCreatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockSessionRepository)(nil).CreatedAtColumn))
	return &MockSessionRepositoryCreatedAtColumnCall{Call: call}
}

// MockSessionRepositoryCreatedAtColumnCall wrap *gomock.Call
type MockSessionRepositoryCreatedAtColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockSessionRepositoryCreatedAtColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockSessionRepositoryCreatedAtColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryCreatedAtColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreatedAtCondition mocks base method.
func (m *MockSessionRepository) CreatedAtCondition(op database.NumberOperation, createdAt time.Time) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatedAtCondition", op, createdAt)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// CreatedAtCondition indicates an expected call of CreatedAtCondition.
func (mr *MockSessionRepositoryMockRecorder) CreatedAtCondition(op, createdAt any) *MockSessionRepositoryCreatedAtConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtCondition", reflect.TypeOf((*MockSessionRepository)(nil).CreatedAtCondition), op, createdAt)
	return &MockSessionRepositoryCreatedAtConditionCall{Call: call}
}

// MockSessionRepositoryCreatedAtConditionCall wrap *gomock.Call
type MockSessionRepositoryCreatedAtConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryCreatedAtConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryCreatedAtConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryCreatedAtConditionCall) Do(f func(database.NumberOperation, time.Time) database.Condition) *MockSessionRepositoryCreatedAtConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryCreatedAtConditionCall) DoAndReturn(f func(database.NumberOperation, time.Time) database.Condition) *MockSessionRepositoryCreatedAtConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// CreatorIDCondition indicates an expected call of CreatorIDCondition.
func (mr *MockSessionRepositoryMockRecorder) CreatorIDCondition(creatorID any) *MockSessionRepositoryCreatorIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatorIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).CreatorIDCondition), creatorID)
	return &MockSessionRepositoryCreatorIDConditionCall{Call: call}
}

// MockSessionRepositoryCreatorIDConditionCall wrap *gomock.Call
type MockSessionRepositoryCreatorIDConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryCreatorIDConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryCreatorIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryCreatorIDConditionCall) Do(f func(string) database.Condition) *MockSessionRepositoryCreatorIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryCreatorIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSessionRepositoryCreatorIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Delete mocks base method.
func (m *MockSessionRepository) Delete(ctx context.Context, client database.QueryExecutor, condition, permissionCondition database.Condition) (int64, time.Time, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, client, condition, permissionCondition)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(time.Time)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Delete indicates an expected call of Delete.
func (mr *MockSessionRepositoryMockRecorder) Delete(ctx, client, condition, permissionCondition any) *MockSessionRepositoryDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSessionRepository)(nil).Delete), ctx, client, condition, permissionCondition)
	return &MockSessionRepositoryDeleteCall{Call: call}
}

// MockSessionRepositoryDeleteCall wrap *gomock.Call
type MockSessionRepositoryDeleteCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryDeleteCall) Return(arg0 int64, arg1 time.Time, arg2 error) *MockSessionRepositoryDeleteCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, database.Condition) (int64, time.Time, error)) *MockSessionRepositoryDeleteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, database.Condition) (int64, time.Time, error)) *MockSessionRepositoryDeleteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ExistsFactor mocks base method.
func (m *MockSessionRepository) ExistsFactor(condition database.Condition) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExistsFactor", condition)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// ExistsFactor indicates an expected call of ExistsFactor.
func (mr *MockSessionRepositoryMockRecorder) ExistsFactor(condition any) *MockSessionRepositoryExistsFactorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsFactor", reflect.TypeOf((*MockSessionRepository)(nil).ExistsFactor), condition)
	return &MockSessionRepositoryExistsFactorCall{Call: call}
}

// MockSessionRepositoryExistsFactorCall wrap *gomock.Call
type MockSessionRepositoryExistsFactorCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryExistsFactorCall) Return(arg0 database.Condition) *MockSessionRepositoryExistsFactorCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryExistsFactorCall) Do(f func(database.Condition) database.Condition) *MockSessionRepositoryExistsFactorCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryExistsFactorCall) DoAndReturn(f func(database.Condition) database.Condition) *MockSessionRepositoryExistsFactorCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ExistsMetadata mocks base method.
func (m *MockSessionRepository) ExistsMetadata(condition database.Condition) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExistsMetadata", condition)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// ExistsMetadata indicates an expected call of ExistsMetadata.
func (mr *MockSessionRepositoryMockRecorder) ExistsMetadata(condition any) *MockSessionRepositoryExistsMetadataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsMetadata", reflect.TypeOf((*MockSessionRepository)(nil).ExistsMetadata), condition)
	return &MockSessionRepositoryExistsMetadataCall{Call: call}
}

// MockSessionRepositoryExistsMetadataCall wrap *gomock.Call
type MockSessionRepositoryExistsMetadataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryExistsMetadataCall) Return(arg0 database.Condition) *MockSessionRepositoryExistsMetadataCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryExistsMetadataCall) Do(f func(database.Condition) database.Condition) *MockSessionRepositoryExistsMetadataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryExistsMetadataCall) DoAndReturn(f func(database.Condition) database.Condition) *MockSessionRepositoryExistsMetadataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ExpirationColumn mocks base method.
func (m *MockSessionRepository) ExpirationColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpirationColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// ExpirationColumn indicates an expected call of ExpirationColumn.
func (mr *MockSessionRepositoryMockRecorder) ExpirationColumn() *MockSessionRepositoryExpirationColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpirationColumn", reflect.TypeOf((*MockSessionRepository)(nil).ExpirationColumn))
	return &MockSessionRepositoryExpirationColumnCall{Call: call}
}

// MockSessionRepositoryExpirationColumnCall wrap *gomock.Call
type MockSessionRepositoryExpirationColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryExpirationColumnCall) Return(arg0 database.Column) *MockSessionRepositoryExpirationColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryExpirationColumnCall) Do(f func() database.Column) *MockSessionRepositoryExpirationColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryExpirationColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryExpirationColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ExpirationCondition mocks base method.
func (m *MockSessionRepository) ExpirationCondition(op database.NumberOperation, expiration time.Time) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpirationCondition", op, expiration)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// ExpirationCondition indicates an expected call of ExpirationCondition.
func (mr *MockSessionRepositoryMockRecorder) ExpirationCondition(op, expiration any) *MockSessionRepositoryExpirationConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpirationCondition", reflect.TypeOf((*MockSessionRepository)(nil).ExpirationCondition), op, expiration)
	return &MockSessionRepositoryExpirationConditionCall{Call: call}
}

// MockSessionRepositoryExpirationConditionCall wrap *gomock.Call
type MockSessionRepositoryExpirationConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryExpirationConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryExpirationConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryExpirationConditionCall) Do(f func(database.NumberOperation, time.Time) database.Condition) *MockSessionRepositoryExpirationConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryExpirationConditionCall) DoAndReturn(f func(database.NumberOperation, time.Time) database.Condition) *MockSessionRepositoryExpirationConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FactorConditions mocks base method.
func (m *MockSessionRepository) FactorConditions() domain.SessionFactorConditions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FactorConditions")
	ret0, _ := ret[0].(domain.SessionFactorConditions)
	return ret0
}

// FactorConditions indicates an expected call of FactorConditions.
func (mr *MockSessionRepositoryMockRecorder) FactorConditions() *MockSessionRepositoryFactorConditionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FactorConditions", reflect.TypeOf((*MockSessionRepository)(nil).FactorConditions))
	return &MockSessionRepositoryFactorConditionsCall{Call: call}
}

// MockSessionRepositoryFactorConditionsCall wrap *gomock.Call
type MockSessionRepositoryFactorConditionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryFactorConditionsCall) Return(arg0 domain.SessionFactorConditions) *MockSessionRepositoryFactorConditionsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryFactorConditionsCall) Do(f func() domain.SessionFactorConditions) *MockSessionRepositoryFactorConditionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryFactorConditionsCall) DoAndReturn(f func() domain.SessionFactorConditions) *MockSessionRepositoryFactorConditionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Get mocks base method.
func (m *MockSessionRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.Session, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Get", varargs...)
	ret0, _ := ret[0].(*domain.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockSessionRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockSessionRepositoryGetCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSessionRepository)(nil).Get), varargs...)
	return &MockSessionRepositoryGetCall{Call: call}
}

// MockSessionRepositoryGetCall wrap *gomock.Call
type MockSessionRepositoryGetCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryGetCall) Return(arg0 *domain.Session, arg1 error) *MockSessionRepositoryGetCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.Session, error)) *MockSessionRepositoryGetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.Session, error)) *MockSessionRepositoryGetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IDColumn mocks base method.
func (m *MockSessionRepository) IDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// IDColumn indicates an expected call of IDColumn.
func (mr *MockSessionRepositoryMockRecorder) IDColumn() *MockSessionRepositoryIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockSessionRepository)(nil).IDColumn))
	return &MockSessionRepositoryIDColumnCall{Call: call}
}

// MockSessionRepositoryIDColumnCall wrap *gomock.Call
type MockSessionRepositoryIDColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryIDColumnCall) Return(arg0 database.Column) *MockSessionRepositoryIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryIDColumnCall) Do(f func() database.Column) *MockSessionRepositoryIDColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryIDColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// IDCondition indicates an expected call of IDCondition.
func (mr *MockSessionRepositoryMockRecorder) IDCondition(sessionID any) *MockSessionRepositoryIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockSessionRepository)(nil).IDCondition), sessionID)
	return &MockSessionRepositoryIDConditionCall{Call: call}
}

// MockSessionRepositoryIDConditionCall wrap *gomock.Call
type MockSessionRepositoryIDConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryIDConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockSessionRepositoryIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSessionRepositoryIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// InstanceIDColumn mocks base method.
func (m *MockSessionRepository) InstanceIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstanceIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// InstanceIDColumn indicates an expected call of InstanceIDColumn.
func (mr *MockSessionRepositoryMockRecorder) InstanceIDColumn() *MockSessionRepositoryInstanceIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockSessionRepository)(nil).InstanceIDColumn))
	return &MockSessionRepositoryInstanceIDColumnCall{Call: call}
}

// MockSessionRepositoryInstanceIDColumnCall wrap *gomock.Call
type MockSessionRepositoryInstanceIDColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockSessionRepositoryInstanceIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockSessionRepositoryInstanceIDColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryInstanceIDColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockSessionRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockSessionRepositoryInstanceIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).InstanceIDCondition), instanceID)
	return &MockSessionRepositoryInstanceIDConditionCall{Call: call}
}

// MockSessionRepositoryInstanceIDConditionCall wrap *gomock.Call
type MockSessionRepositoryInstanceIDConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryInstanceIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockSessionRepositoryInstanceIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSessionRepositoryInstanceIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LifetimeColumn mocks base method.
func (m *MockSessionRepository) LifetimeColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LifetimeColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// LifetimeColumn indicates an expected call of LifetimeColumn.
func (mr *MockSessionRepositoryMockRecorder) LifetimeColumn() *MockSessionRepositoryLifetimeColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LifetimeColumn", reflect.TypeOf((*MockSessionRepository)(nil).LifetimeColumn))
	return &MockSessionRepositoryLifetimeColumnCall{Call: call}
}

// MockSessionRepositoryLifetimeColumnCall wrap *gomock.Call
type MockSessionRepositoryLifetimeColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryLifetimeColumnCall) Return(arg0 database.Column) *MockSessionRepositoryLifetimeColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryLifetimeColumnCall) Do(f func() database.Column) *MockSessionRepositoryLifetimeColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryLifetimeColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryLifetimeColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// List mocks base method.
func (m *MockSessionRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.Session, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].([]*domain.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockSessionRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockSessionRepositoryListCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockSessionRepository)(nil).List), varargs...)
	return &MockSessionRepositoryListCall{Call: call}
}

// MockSessionRepositoryListCall wrap *gomock.Call
type MockSessionRepositoryListCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryListCall) Return(arg0 []*domain.Session, arg1 error) *MockSessionRepositoryListCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.Session, error)) *MockSessionRepositoryListCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.Session, error)) *MockSessionRepositoryListCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MetadataConditions mocks base method.
func (m *MockSessionRepository) MetadataConditions() domain.SessionMetadataConditions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MetadataConditions")
	ret0, _ := ret[0].(domain.SessionMetadataConditions)
	return ret0
}

// MetadataConditions indicates an expected call of MetadataConditions.
func (mr *MockSessionRepositoryMockRecorder) MetadataConditions() *MockSessionRepositoryMetadataConditionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataConditions", reflect.TypeOf((*MockSessionRepository)(nil).MetadataConditions))
	return &MockSessionRepositoryMetadataConditionsCall{Call: call}
}

// MockSessionRepositoryMetadataConditionsCall wrap *gomock.Call
type MockSessionRepositoryMetadataConditionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryMetadataConditionsCall) Return(arg0 domain.SessionMetadataConditions) *MockSessionRepositoryMetadataConditionsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryMetadataConditionsCall) Do(f func() domain.SessionMetadataConditions) *MockSessionRepositoryMetadataConditionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryMetadataConditionsCall) DoAndReturn(f func() domain.SessionMetadataConditions) *MockSessionRepositoryMetadataConditionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PrimaryKeyColumns mocks base method.
func (m *MockSessionRepository) PrimaryKeyColumns() []database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrimaryKeyColumns")
	ret0, _ := ret[0].([]database.Column)
	return ret0
}

// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns.
func (mr *MockSessionRepositoryMockRecorder) PrimaryKeyColumns() *MockSessionRepositoryPrimaryKeyColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockSessionRepository)(nil).PrimaryKeyColumns))
	return &MockSessionRepositoryPrimaryKeyColumnsCall{Call: call}
}

// MockSessionRepositoryPrimaryKeyColumnsCall wrap *gomock.Call
type MockSessionRepositoryPrimaryKeyColumnsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockSessionRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockSessionRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockSessionRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PrimaryKeyCondition mocks base method.
func (m *MockSessionRepository) PrimaryKeyCondition(instanceID, sessionID string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, sessionID)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
func (mr *MockSessionRepositoryMockRecorder) PrimaryKeyCondition(instanceID, sessionID any) *MockSessionRepositoryPrimaryKeyConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockSessionRepository)(nil).PrimaryKeyCondition), instanceID, sessionID)
	return &MockSessionRepositoryPrimaryKeyConditionCall{Call: call}
}

// MockSessionRepositoryPrimaryKeyConditionCall wrap *gomock.Call
type MockSessionRepositoryPrimaryKeyConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockSessionRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockSessionRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetChallenge mocks base method.
func (m *MockSessionRepository) SetChallenge(challenge domain.SessionChallenge) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetChallenge", challenge)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetChallenge indicates an expected call of SetChallenge.
func (mr *MockSessionRepositoryMockRecorder) SetChallenge(challenge any) *MockSessionRepositorySetChallengeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChallenge", reflect.TypeOf((*MockSessionRepository)(nil).SetChallenge), challenge)
	return &MockSessionRepositorySetChallengeCall{Call: call}
}

// MockSessionRepositorySetChallengeCall wrap *gomock.Call
type MockSessionRepositorySetChallengeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositorySetChallengeCall) Return(arg0 database.Change) *MockSessionRepositorySetChallengeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositorySetChallengeCall) Do(f func(domain.SessionChallenge) database.Change) *MockSessionRepositorySetChallengeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositorySetChallengeCall) DoAndReturn(f func(domain.SessionChallenge) database.Change) *MockSessionRepositorySetChallengeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetFactor mocks base method.
func (m *MockSessionRepository) SetFactor(factor domain.SessionFactor) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetFactor", factor)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetFactor indicates an expected call of SetFactor.
func (mr *MockSessionRepositoryMockRecorder) SetFactor(factor any) *MockSessionRepositorySetFactorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFactor", reflect.TypeOf((*MockSessionRepository)(nil).SetFactor), factor)
	return &MockSessionRepositorySetFactorCall{Call: call}
}

// MockSessionRepositorySetFactorCall wrap *gomock.Call
type MockSessionRepositorySetFactorCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositorySetFactorCall) Return(arg0 database.Change) *MockSessionRepositorySetFactorCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositorySetFactorCall) Do(f func(domain.SessionFactor) database.Change) *MockSessionRepositorySetFactorCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositorySetFactorCall) DoAndReturn(f func(domain.SessionFactor) database.Change) *MockSessionRepositorySetFactorCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLifetime mocks base method.
func (m *MockSessionRepository) SetLifetime(lifetime time.Duration) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLifetime", lifetime)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetLifetime indicates an expected call of SetLifetime.
func (mr *MockSessionRepositoryMockRecorder) SetLifetime(lifetime any) *MockSessionRepositorySetLifetimeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLifetime", reflect.TypeOf((*MockSessionRepository)(nil).SetLifetime), lifetime)
	return &MockSessionRepositorySetLifetimeCall{Call: call}
}

// MockSessionRepositorySetLifetimeCall wrap *gomock.Call
type MockSessionRepositorySetLifetimeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositorySetLifetimeCall) Return(arg0 database.Change) *MockSessionRepositorySetLifetimeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositorySetLifetimeCall) Do(f func(time.Duration) database.Change) *MockSessionRepositorySetLifetimeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositorySetLifetimeCall) DoAndReturn(f func(time.Duration) database.Change) *MockSessionRepositorySetLifetimeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetMetadata mocks base method.
func (m *MockSessionRepository) SetMetadata(metadata []*domain.SessionMetadata) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetMetadata", metadata)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetMetadata indicates an expected call of SetMetadata.
func (mr *MockSessionRepositoryMockRecorder) SetMetadata(metadata any) *MockSessionRepositorySetMetadataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockSessionRepository)(nil).SetMetadata), metadata)
	return &MockSessionRepositorySetMetadataCall{Call: call}
}

// MockSessionRepositorySetMetadataCall wrap *gomock.Call
type MockSessionRepositorySetMetadataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositorySetMetadataCall) Return(arg0 database.Change) *MockSessionRepositorySetMetadataCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositorySetMetadataCall) Do(f func([]*domain.SessionMetadata) database.Change) *MockSessionRepositorySetMetadataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositorySetMetadataCall) DoAndReturn(f func([]*domain.SessionMetadata) database.Change) *MockSessionRepositorySetMetadataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetToken indicates an expected call of SetToken.
func (mr *MockSessionRepositoryMockRecorder) SetToken(token any) *MockSessionRepositorySetTokenCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetToken", reflect.TypeOf((*MockSessionRepository)(nil).SetToken), token)
	return &MockSessionRepositorySetTokenCall{Call: call}
}

// MockSessionRepositorySetTokenCall wrap *gomock.Call
type MockSessionRepositorySetTokenCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositorySetTokenCall) Return(arg0 database.Change) *MockSessionRepositorySetTokenCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositorySetTokenCall) Do(f func(string) database.Change) *MockSessionRepositorySetTokenCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositorySetTokenCall) DoAndReturn(f func(string) database.Change) *MockSessionRepositorySetTokenCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetUpdatedAt mocks base method.
func (m *MockSessionRepository) SetUpdatedAt(updatedAt time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetUpdatedAt indicates an expected call of SetUpdatedAt.
func (mr *MockSessionRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockSessionRepositorySetUpdatedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockSessionRepository)(nil).SetUpdatedAt), updatedAt)
	return &MockSessionRepositorySetUpdatedAtCall{Call: call}
}

// MockSessionRepositorySetUpdatedAtCall wrap *gomock.Call
type MockSessionRepositorySetUpdatedAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockSessionRepositorySetUpdatedAtCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositorySetUpdatedAtCall) Do(f func(time.Time) database.Change) *MockSessionRepositorySetUpdatedAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositorySetUpdatedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockSessionRepositorySetUpdatedAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// TokenIDColumn mocks base method.
func (m *MockSessionRepository) TokenIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TokenIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// TokenIDColumn indicates an expected call of TokenIDColumn.
func (mr *MockSessionRepositoryMockRecorder) TokenIDColumn() *MockSessionRepositoryTokenIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenIDColumn", reflect.TypeOf((*MockSessionRepository)(nil).TokenIDColumn))
	return &MockSessionRepositoryTokenIDColumnCall{Call: call}
}

// MockSessionRepositoryTokenIDColumnCall wrap *gomock.Call
type MockSessionRepositoryTokenIDColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryTokenIDColumnCall) Return(arg0 database.Column) *MockSessionRepositoryTokenIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryTokenIDColumnCall) Do(f func() database.Column) *MockSessionRepositoryTokenIDColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryTokenIDColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryTokenIDColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// TokenIDCondition indicates an expected call of TokenIDCondition.
func (mr *MockSessionRepositoryMockRecorder) TokenIDCondition(tokenID any) *MockSessionRepositoryTokenIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).TokenIDCondition), tokenID)
	return &MockSessionRepositoryTokenIDConditionCall{Call: call}
}

// MockSessionRepositoryTokenIDConditionCall wrap *gomock.Call
type MockSessionRepositoryTokenIDConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryTokenIDConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryTokenIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryTokenIDConditionCall) Do(f func(string) database.Condition) *MockSessionRepositoryTokenIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryTokenIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSessionRepositoryTokenIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Update mocks base method.
func (m *MockSessionRepository) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client, condition}
	for _, a := range changes {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Update", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockSessionRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockSessionRepositoryUpdateCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client, condition}, changes...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockSessionRepository)(nil).Update), varargs...)
	return &MockSessionRepositoryUpdateCall{Call: call}
}

// MockSessionRepositoryUpdateCall wrap *gomock.Call
type MockSessionRepositoryUpdateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryUpdateCall) Return(arg0 int64, arg1 error) *MockSessionRepositoryUpdateCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryUpdateCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockSessionRepositoryUpdateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryUpdateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockSessionRepositoryUpdateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdatedAtColumn mocks base method.
func (m *MockSessionRepository) UpdatedAtColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatedAtColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// UpdatedAtColumn indicates an expected call of UpdatedAtColumn.
func (mr *MockSessionRepositoryMockRecorder) UpdatedAtColumn() *MockSessionRepositoryUpdatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockSessionRepository)(nil).UpdatedAtColumn))
	return &MockSessionRepositoryUpdatedAtColumnCall{Call: call}
}

// MockSessionRepositoryUpdatedAtColumnCall wrap *gomock.Call
type MockSessionRepositoryUpdatedAtColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockSessionRepositoryUpdatedAtColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockSessionRepositoryUpdatedAtColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryUpdatedAtColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdatedAtCondition mocks base method.
func (m *MockSessionRepository) UpdatedAtCondition(op database.NumberOperation, updatedAt time.Time) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatedAtCondition", op, updatedAt)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// UpdatedAtCondition indicates an expected call of UpdatedAtCondition.
func (mr *MockSessionRepositoryMockRecorder) UpdatedAtCondition(op, updatedAt any) *MockSessionRepositoryUpdatedAtConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtCondition", reflect.TypeOf((*MockSessionRepository)(nil).UpdatedAtCondition), op, updatedAt)
	return &MockSessionRepositoryUpdatedAtConditionCall{Call: call}
}

// MockSessionRepositoryUpdatedAtConditionCall wrap *gomock.Call
type MockSessionRepositoryUpdatedAtConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryUpdatedAtConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryUpdatedAtConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryUpdatedAtConditionCall) Do(f func(database.NumberOperation, time.Time) database.Condition) *MockSessionRepositoryUpdatedAtConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryUpdatedAtConditionCall) DoAndReturn(f func(database.NumberOperation, time.Time) database.Condition) *MockSessionRepositoryUpdatedAtConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// UserAgentIDCondition indicates an expected call of UserAgentIDCondition.
func (mr *MockSessionRepositoryMockRecorder) UserAgentIDCondition(userAgentID any) *MockSessionRepositoryUserAgentIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserAgentIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).UserAgentIDCondition), userAgentID)
	return &MockSessionRepositoryUserAgentIDConditionCall{Call: call}
}

// MockSessionRepositoryUserAgentIDConditionCall wrap *gomock.Call
type MockSessionRepositoryUserAgentIDConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryUserAgentIDConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryUserAgentIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryUserAgentIDConditionCall) Do(f func(string) database.Condition) *MockSessionRepositoryUserAgentIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryUserAgentIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSessionRepositoryUserAgentIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UserIDColumn mocks base method.
func (m *MockSessionRepository) UserIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// UserIDColumn indicates an expected call of UserIDColumn.
func (mr *MockSessionRepositoryMockRecorder) UserIDColumn() *MockSessionRepositoryUserIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDColumn", reflect.TypeOf((*MockSessionRepository)(nil).UserIDColumn))
	return &MockSessionRepositoryUserIDColumnCall{Call: call}
}

// MockSessionRepositoryUserIDColumnCall wrap *gomock.Call
type MockSessionRepositoryUserIDColumnCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryUserIDColumnCall) Return(arg0 database.Column) *MockSessionRepositoryUserIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryUserIDColumnCall) Do(f func() database.Column) *MockSessionRepositoryUserIDColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryUserIDColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryUserIDColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// UserIDCondition indicates an expected call of UserIDCondition.
func (mr *MockSessionRepositoryMockRecorder) UserIDCondition(userID any) *MockSessionRepositoryUserIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).UserIDCondition), userID)
	return &MockSessionRepositoryUserIDConditionCall{Call: call}
}

// MockSessionRepositoryUserIDConditionCall wrap *gomock.Call
type MockSessionRepositoryUserIDConditionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryUserIDConditionCall) Return(arg0 database.Condition) *MockSessionRepositoryUserIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryUserIDConditionCall) Do(f func(string) database.Condition) *MockSessionRepositoryUserIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryUserIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSessionRepositoryUserIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}