chore: fix generators in crypto package (#12008)

# Which Problems Are Solved

`@zitadel/api:generate-go` failed due to duplicate generated files.
https://github.com/zitadel/zitadel/pull/11820 removed the old generated
file and added a generate command to the `internal/crypto/crypto.go`
file. However, there was already a `internal/crypto/generate.go` with a
different output file name (the old file).

# How the Problems Are Solved

Removed the `internal/crypto/generate.go` file and moved the second
generate into `internal/crypto/code.go`.

# Additional Changes

Noticed that mockgen is an old version and updated it. Also then checked
all other tools and updated them.

# Additional Context

- relates to #11820
- noted internally

backend/v3/domain/mock/branding_settings.mock.go

@@ -1547,6 +1547,44 @@ func (c *MockBrandingSettingsRepositoryTypeColumnCall) DoAndReturn(f func() data
 	return c
 }
 
+// TypeCondition mocks base method.
+func (m *MockBrandingSettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeCondition", typ)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// TypeCondition indicates an expected call of TypeCondition.
+func (mr *MockBrandingSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockBrandingSettingsRepositoryTypeConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).TypeCondition), typ)
+	return &MockBrandingSettingsRepositoryTypeConditionCall{Call: call}
+}
+
+// MockBrandingSettingsRepositoryTypeConditionCall wrap *gomock.Call
+type MockBrandingSettingsRepositoryTypeConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockBrandingSettingsRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockBrandingSettingsRepositoryTypeConditionCall) Do(f func(domain.SettingType) database.Condition) *MockBrandingSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockBrandingSettingsRepositoryTypeConditionCall) DoAndReturn(f func(domain.SettingType) database.Condition) *MockBrandingSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // UniqueColumns mocks base method.
 func (m *MockBrandingSettingsRepository) UniqueColumns() []database.Column {
 	m.ctrl.T.Helper()

backend/v3/domain/mock/domain_settings.mock.go

@@ -855,6 +855,44 @@ func (c *MockDomainSettingsRepositoryTypeColumnCall) DoAndReturn(f func() databa
 	return c
 }
 
+// TypeCondition mocks base method.
+func (m *MockDomainSettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeCondition", typ)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// TypeCondition indicates an expected call of TypeCondition.
+func (mr *MockDomainSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockDomainSettingsRepositoryTypeConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockDomainSettingsRepository)(nil).TypeCondition), typ)
+	return &MockDomainSettingsRepositoryTypeConditionCall{Call: call}
+}
+
+// MockDomainSettingsRepositoryTypeConditionCall wrap *gomock.Call
+type MockDomainSettingsRepositoryTypeConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockDomainSettingsRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockDomainSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockDomainSettingsRepositoryTypeConditionCall) Do(f func(domain.SettingType) database.Condition) *MockDomainSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockDomainSettingsRepositoryTypeConditionCall) DoAndReturn(f func(domain.SettingType) database.Condition) *MockDomainSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // UniqueColumns mocks base method.
 func (m *MockDomainSettingsRepository) UniqueColumns() []database.Column {
 	m.ctrl.T.Helper()

backend/v3/domain/mock/legal_and_support_settings.mock.go

@@ -1007,6 +1007,44 @@ func (c *MockLegalAndSupportSettingsRepositoryTypeColumnCall) DoAndReturn(f func
 	return c
 }
 
+// TypeCondition mocks base method.
+func (m *MockLegalAndSupportSettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeCondition", typ)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// TypeCondition indicates an expected call of TypeCondition.
+func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockLegalAndSupportSettingsRepositoryTypeConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).TypeCondition), typ)
+	return &MockLegalAndSupportSettingsRepositoryTypeConditionCall{Call: call}
+}
+
+// MockLegalAndSupportSettingsRepositoryTypeConditionCall wrap *gomock.Call
+type MockLegalAndSupportSettingsRepositoryTypeConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLegalAndSupportSettingsRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockLegalAndSupportSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLegalAndSupportSettingsRepositoryTypeConditionCall) Do(f func(domain.SettingType) database.Condition) *MockLegalAndSupportSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLegalAndSupportSettingsRepositoryTypeConditionCall) DoAndReturn(f func(domain.SettingType) database.Condition) *MockLegalAndSupportSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // UniqueColumns mocks base method.
 func (m *MockLegalAndSupportSettingsRepository) UniqueColumns() []database.Column {
 	m.ctrl.T.Helper()

backend/v3/domain/mock/lockout_settings.mock.go

@@ -855,6 +855,44 @@ func (c *MockLockoutSettingsRepositoryTypeColumnCall) DoAndReturn(f func() datab
 	return c
 }
 
+// TypeCondition mocks base method.
+func (m *MockLockoutSettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeCondition", typ)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// TypeCondition indicates an expected call of TypeCondition.
+func (mr *MockLockoutSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockLockoutSettingsRepositoryTypeConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).TypeCondition), typ)
+	return &MockLockoutSettingsRepositoryTypeConditionCall{Call: call}
+}
+
+// MockLockoutSettingsRepositoryTypeConditionCall wrap *gomock.Call
+type MockLockoutSettingsRepositoryTypeConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLockoutSettingsRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockLockoutSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLockoutSettingsRepositoryTypeConditionCall) Do(f func(domain.SettingType) database.Condition) *MockLockoutSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLockoutSettingsRepositoryTypeConditionCall) DoAndReturn(f func(domain.SettingType) database.Condition) *MockLockoutSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // UniqueColumns mocks base method.
 func (m *MockLockoutSettingsRepository) UniqueColumns() []database.Column {
 	m.ctrl.T.Helper()

backend/v3/domain/mock/login_settings.mock.go

@@ -1582,6 +1582,44 @@ func (c *MockLoginSettingsRepositoryTypeColumnCall) DoAndReturn(f func() databas
 	return c
 }
 
+// TypeCondition mocks base method.
+func (m *MockLoginSettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeCondition", typ)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// TypeCondition indicates an expected call of TypeCondition.
+func (mr *MockLoginSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockLoginSettingsRepositoryTypeConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).TypeCondition), typ)
+	return &MockLoginSettingsRepositoryTypeConditionCall{Call: call}
+}
+
+// MockLoginSettingsRepositoryTypeConditionCall wrap *gomock.Call
+type MockLoginSettingsRepositoryTypeConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockLoginSettingsRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockLoginSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockLoginSettingsRepositoryTypeConditionCall) Do(f func(domain.SettingType) database.Condition) *MockLoginSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockLoginSettingsRepositoryTypeConditionCall) DoAndReturn(f func(domain.SettingType) database.Condition) *MockLoginSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // UniqueColumns mocks base method.
 func (m *MockLoginSettingsRepository) UniqueColumns() []database.Column {
 	m.ctrl.T.Helper()

backend/v3/domain/mock/notification_settings.mock.go

@@ -779,6 +779,44 @@ func (c *MockNotificationSettingsRepositoryTypeColumnCall) DoAndReturn(f func()
 	return c
 }
 
+// TypeCondition mocks base method.
+func (m *MockNotificationSettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeCondition", typ)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// TypeCondition indicates an expected call of TypeCondition.
+func (mr *MockNotificationSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockNotificationSettingsRepositoryTypeConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).TypeCondition), typ)
+	return &MockNotificationSettingsRepositoryTypeConditionCall{Call: call}
+}
+
+// MockNotificationSettingsRepositoryTypeConditionCall wrap *gomock.Call
+type MockNotificationSettingsRepositoryTypeConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockNotificationSettingsRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockNotificationSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockNotificationSettingsRepositoryTypeConditionCall) Do(f func(domain.SettingType) database.Condition) *MockNotificationSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockNotificationSettingsRepositoryTypeConditionCall) DoAndReturn(f func(domain.SettingType) database.Condition) *MockNotificationSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // UniqueColumns mocks base method.
 func (m *MockNotificationSettingsRepository) UniqueColumns() []database.Column {
 	m.ctrl.T.Helper()

backend/v3/domain/mock/organization_settings.mock.go

@@ -779,6 +779,44 @@ func (c *MockOrganizationSettingsRepositoryTypeColumnCall) DoAndReturn(f func()
 	return c
 }
 
+// TypeCondition mocks base method.
+func (m *MockOrganizationSettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeCondition", typ)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// TypeCondition indicates an expected call of TypeCondition.
+func (mr *MockOrganizationSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockOrganizationSettingsRepositoryTypeConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).TypeCondition), typ)
+	return &MockOrganizationSettingsRepositoryTypeConditionCall{Call: call}
+}
+
+// MockOrganizationSettingsRepositoryTypeConditionCall wrap *gomock.Call
+type MockOrganizationSettingsRepositoryTypeConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockOrganizationSettingsRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockOrganizationSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockOrganizationSettingsRepositoryTypeConditionCall) Do(f func(domain.SettingType) database.Condition) *MockOrganizationSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockOrganizationSettingsRepositoryTypeConditionCall) DoAndReturn(f func(domain.SettingType) database.Condition) *MockOrganizationSettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // UniqueColumns mocks base method.
 func (m *MockOrganizationSettingsRepository) UniqueColumns() []database.Column {
 	m.ctrl.T.Helper()

backend/v3/domain/mock/password_complexity_settings.mock.go

@@ -931,6 +931,44 @@ func (c *MockPasswordComplexitySettingsRepositoryTypeColumnCall) DoAndReturn(f f
 	return c
 }
 
+// TypeCondition mocks base method.
+func (m *MockPasswordComplexitySettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeCondition", typ)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// TypeCondition indicates an expected call of TypeCondition.
+func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) TypeCondition(typ any) *MockPasswordComplexitySettingsRepositoryTypeConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).TypeCondition), typ)
+	return &MockPasswordComplexitySettingsRepositoryTypeConditionCall{Call: call}
+}
+
+// MockPasswordComplexitySettingsRepositoryTypeConditionCall wrap *gomock.Call
+type MockPasswordComplexitySettingsRepositoryTypeConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordComplexitySettingsRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockPasswordComplexitySettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordComplexitySettingsRepositoryTypeConditionCall) Do(f func(domain.SettingType) database.Condition) *MockPasswordComplexitySettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordComplexitySettingsRepositoryTypeConditionCall) DoAndReturn(f func(domain.SettingType) database.Condition) *MockPasswordComplexitySettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // UniqueColumns mocks base method.
 func (m *MockPasswordComplexitySettingsRepository) UniqueColumns() []database.Column {
 	m.ctrl.T.Helper()

backend/v3/domain/mock/password_expiry_settings.mock.go

@@ -817,6 +817,44 @@ func (c *MockPasswordExpirySettingsRepositoryTypeColumnCall) DoAndReturn(f func(
 	return c
 }
 
+// TypeCondition mocks base method.
+func (m *MockPasswordExpirySettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeCondition", typ)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// TypeCondition indicates an expected call of TypeCondition.
+func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) TypeCondition(typ any) *MockPasswordExpirySettingsRepositoryTypeConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).TypeCondition), typ)
+	return &MockPasswordExpirySettingsRepositoryTypeConditionCall{Call: call}
+}
+
+// MockPasswordExpirySettingsRepositoryTypeConditionCall wrap *gomock.Call
+type MockPasswordExpirySettingsRepositoryTypeConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockPasswordExpirySettingsRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockPasswordExpirySettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockPasswordExpirySettingsRepositoryTypeConditionCall) Do(f func(domain.SettingType) database.Condition) *MockPasswordExpirySettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockPasswordExpirySettingsRepositoryTypeConditionCall) DoAndReturn(f func(domain.SettingType) database.Condition) *MockPasswordExpirySettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // UniqueColumns mocks base method.
 func (m *MockPasswordExpirySettingsRepository) UniqueColumns() []database.Column {
 	m.ctrl.T.Helper()

backend/v3/domain/mock/security_settings.mock.go

@@ -855,6 +855,44 @@ func (c *MockSecuritySettingsRepositoryTypeColumnCall) DoAndReturn(f func() data
 	return c
 }
 
+// TypeCondition mocks base method.
+func (m *MockSecuritySettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TypeCondition", typ)
+	ret0, _ := ret[0].(database.Condition)
+	return ret0
+}
+
+// TypeCondition indicates an expected call of TypeCondition.
+func (mr *MockSecuritySettingsRepositoryMockRecorder) TypeCondition(typ any) *MockSecuritySettingsRepositoryTypeConditionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).TypeCondition), typ)
+	return &MockSecuritySettingsRepositoryTypeConditionCall{Call: call}
+}
+
+// MockSecuritySettingsRepositoryTypeConditionCall wrap *gomock.Call
+type MockSecuritySettingsRepositoryTypeConditionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockSecuritySettingsRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockSecuritySettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockSecuritySettingsRepositoryTypeConditionCall) Do(f func(domain.SettingType) database.Condition) *MockSecuritySettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockSecuritySettingsRepositoryTypeConditionCall) DoAndReturn(f func(domain.SettingType) database.Condition) *MockSecuritySettingsRepositoryTypeConditionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
 // UniqueColumns mocks base method.
 func (m *MockSecuritySettingsRepository) UniqueColumns() []database.Column {
 	m.ctrl.T.Helper()

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

@@ -23,6 +23,7 @@ import (
 type MockSessionRepository struct {
 	ctrl     *gomock.Controller
 	recorder *MockSessionRepositoryMockRecorder
+	isgomock struct{}
 }
 
 // MockSessionRepositoryMockRecorder is the mock recorder for MockSessionRepository.
@@ -43,17 +44,17 @@ func (m *MockSessionRepository) EXPECT() *MockSessionRepositoryMockRecorder {
 }
 
 // ClearFactor mocks base method.
-func (m *MockSessionRepository) ClearFactor(arg0 domain.SessionFactorType) database.Change {
+func (m *MockSessionRepository) ClearFactor(factor domain.SessionFactorType) database.Change {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClearFactor", arg0)
+	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(arg0 any) *MockSessionRepositoryClearFactorCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearFactor", reflect.TypeOf((*MockSessionRepository)(nil).ClearFactor), factor)
 	return &MockSessionRepositoryClearFactorCall{Call: call}
 }
 
@@ -81,17 +82,17 @@ func (c *MockSessionRepositoryClearFactorCall) DoAndReturn(f func(domain.Session
 }
 
 // Create mocks base method.
-func (m *MockSessionRepository) Create(arg0 context.Context, arg1 database.QueryExecutor, arg2 *domain.Session) error {
+func (m *MockSessionRepository) Create(ctx context.Context, client database.QueryExecutor, user *domain.Session) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
+	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(arg0, arg1, arg2 any) *MockSessionRepositoryCreateCall {
+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), arg0, arg1, arg2)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSessionRepository)(nil).Create), ctx, client, user)
 	return &MockSessionRepositoryCreateCall{Call: call}
 }
 
@@ -157,17 +158,17 @@ func (c *MockSessionRepositoryCreatedAtColumnCall) DoAndReturn(f func() database
 }
 
 // CreatedAtCondition mocks base method.
-func (m *MockSessionRepository) CreatedAtCondition(arg0 database.NumberOperation, arg1 time.Time) database.Condition {
+func (m *MockSessionRepository) CreatedAtCondition(op database.NumberOperation, createdAt time.Time) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreatedAtCondition", arg0, arg1)
+	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(arg0, arg1 any) *MockSessionRepositoryCreatedAtConditionCall {
+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), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtCondition", reflect.TypeOf((*MockSessionRepository)(nil).CreatedAtCondition), op, createdAt)
 	return &MockSessionRepositoryCreatedAtConditionCall{Call: call}
 }
 
@@ -195,17 +196,17 @@ func (c *MockSessionRepositoryCreatedAtConditionCall) DoAndReturn(f func(databas
 }
 
 // CreatorIDCondition mocks base method.
-func (m *MockSessionRepository) CreatorIDCondition(arg0 string) database.Condition {
+func (m *MockSessionRepository) CreatorIDCondition(creatorID string) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreatorIDCondition", arg0)
+	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(arg0 any) *MockSessionRepositoryCreatorIDConditionCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatorIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).CreatorIDCondition), creatorID)
 	return &MockSessionRepositoryCreatorIDConditionCall{Call: call}
 }
 
@@ -233,9 +234,9 @@ func (c *MockSessionRepositoryCreatorIDConditionCall) DoAndReturn(f func(string)
 }
 
 // Delete mocks base method.
-func (m *MockSessionRepository) Delete(arg0 context.Context, arg1 database.QueryExecutor, arg2, arg3 database.Condition) (int64, time.Time, error) {
+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", arg0, arg1, arg2, arg3)
+	ret := m.ctrl.Call(m, "Delete", ctx, client, condition, permissionCondition)
 	ret0, _ := ret[0].(int64)
 	ret1, _ := ret[1].(time.Time)
 	ret2, _ := ret[2].(error)
@@ -243,9 +244,9 @@ func (m *MockSessionRepository) Delete(arg0 context.Context, arg1 database.Query
 }
 
 // Delete indicates an expected call of Delete.
-func (mr *MockSessionRepositoryMockRecorder) Delete(arg0, arg1, arg2, arg3 any) *MockSessionRepositoryDeleteCall {
+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), arg0, arg1, arg2, arg3)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSessionRepository)(nil).Delete), ctx, client, condition, permissionCondition)
 	return &MockSessionRepositoryDeleteCall{Call: call}
 }
 
@@ -273,17 +274,17 @@ func (c *MockSessionRepositoryDeleteCall) DoAndReturn(f func(context.Context, da
 }
 
 // ExistsFactor mocks base method.
-func (m *MockSessionRepository) ExistsFactor(arg0 database.Condition) database.Condition {
+func (m *MockSessionRepository) ExistsFactor(condition database.Condition) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExistsFactor", arg0)
+	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(arg0 any) *MockSessionRepositoryExistsFactorCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsFactor", reflect.TypeOf((*MockSessionRepository)(nil).ExistsFactor), condition)
 	return &MockSessionRepositoryExistsFactorCall{Call: call}
 }
 
@@ -311,17 +312,17 @@ func (c *MockSessionRepositoryExistsFactorCall) DoAndReturn(f func(database.Cond
 }
 
 // ExistsMetadata mocks base method.
-func (m *MockSessionRepository) ExistsMetadata(arg0 database.Condition) database.Condition {
+func (m *MockSessionRepository) ExistsMetadata(condition database.Condition) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExistsMetadata", arg0)
+	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(arg0 any) *MockSessionRepositoryExistsMetadataCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsMetadata", reflect.TypeOf((*MockSessionRepository)(nil).ExistsMetadata), condition)
 	return &MockSessionRepositoryExistsMetadataCall{Call: call}
 }
 
@@ -387,17 +388,17 @@ func (c *MockSessionRepositoryExpirationColumnCall) DoAndReturn(f func() databas
 }
 
 // ExpirationCondition mocks base method.
-func (m *MockSessionRepository) ExpirationCondition(arg0 database.NumberOperation, arg1 time.Time) database.Condition {
+func (m *MockSessionRepository) ExpirationCondition(op database.NumberOperation, expiration time.Time) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExpirationCondition", arg0, arg1)
+	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(arg0, arg1 any) *MockSessionRepositoryExpirationConditionCall {
+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), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpirationCondition", reflect.TypeOf((*MockSessionRepository)(nil).ExpirationCondition), op, expiration)
 	return &MockSessionRepositoryExpirationConditionCall{Call: call}
 }
 
@@ -463,10 +464,10 @@ func (c *MockSessionRepositoryFactorConditionsCall) DoAndReturn(f func() domain.
 }
 
 // Get mocks base method.
-func (m *MockSessionRepository) Get(arg0 context.Context, arg1 database.QueryExecutor, arg2 ...database.QueryOption) (*domain.Session, error) {
+func (m *MockSessionRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.Session, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, client}
+	for _, a := range opts {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Get", varargs...)
@@ -476,9 +477,9 @@ func (m *MockSessionRepository) Get(arg0 context.Context, arg1 database.QueryExe
 }
 
 // Get indicates an expected call of Get.
-func (mr *MockSessionRepositoryMockRecorder) Get(arg0, arg1 any, arg2 ...any) *MockSessionRepositoryGetCall {
+func (mr *MockSessionRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockSessionRepositoryGetCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, client}, opts...)
 	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSessionRepository)(nil).Get), varargs...)
 	return &MockSessionRepositoryGetCall{Call: call}
 }
@@ -545,17 +546,17 @@ func (c *MockSessionRepositoryIDColumnCall) DoAndReturn(f func() database.Column
 }
 
 // IDCondition mocks base method.
-func (m *MockSessionRepository) IDCondition(arg0 string) database.Condition {
+func (m *MockSessionRepository) IDCondition(sessionID string) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "IDCondition", arg0)
+	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(arg0 any) *MockSessionRepositoryIDConditionCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockSessionRepository)(nil).IDCondition), sessionID)
 	return &MockSessionRepositoryIDConditionCall{Call: call}
 }
 
@@ -621,17 +622,17 @@ func (c *MockSessionRepositoryInstanceIDColumnCall) DoAndReturn(f func() databas
 }
 
 // InstanceIDCondition mocks base method.
-func (m *MockSessionRepository) InstanceIDCondition(arg0 string) database.Condition {
+func (m *MockSessionRepository) InstanceIDCondition(instanceID string) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "InstanceIDCondition", arg0)
+	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(arg0 any) *MockSessionRepositoryInstanceIDConditionCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).InstanceIDCondition), instanceID)
 	return &MockSessionRepositoryInstanceIDConditionCall{Call: call}
 }
 
@@ -697,10 +698,10 @@ func (c *MockSessionRepositoryLifetimeColumnCall) DoAndReturn(f func() database.
 }
 
 // List mocks base method.
-func (m *MockSessionRepository) List(arg0 context.Context, arg1 database.QueryExecutor, arg2 ...database.QueryOption) ([]*domain.Session, error) {
+func (m *MockSessionRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.Session, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, client}
+	for _, a := range opts {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "List", varargs...)
@@ -710,9 +711,9 @@ func (m *MockSessionRepository) List(arg0 context.Context, arg1 database.QueryEx
 }
 
 // List indicates an expected call of List.
-func (mr *MockSessionRepositoryMockRecorder) List(arg0, arg1 any, arg2 ...any) *MockSessionRepositoryListCall {
+func (mr *MockSessionRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockSessionRepositoryListCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, client}, opts...)
 	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockSessionRepository)(nil).List), varargs...)
 	return &MockSessionRepositoryListCall{Call: call}
 }
@@ -817,17 +818,17 @@ func (c *MockSessionRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []data
 }
 
 // PrimaryKeyCondition mocks base method.
-func (m *MockSessionRepository) PrimaryKeyCondition(arg0, arg1 string) database.Condition {
+func (m *MockSessionRepository) PrimaryKeyCondition(instanceID, sessionID string) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PrimaryKeyCondition", arg0, arg1)
+	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(arg0, arg1 any) *MockSessionRepositoryPrimaryKeyConditionCall {
+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), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockSessionRepository)(nil).PrimaryKeyCondition), instanceID, sessionID)
 	return &MockSessionRepositoryPrimaryKeyConditionCall{Call: call}
 }
 
@@ -855,17 +856,17 @@ func (c *MockSessionRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string
 }
 
 // SetChallenge mocks base method.
-func (m *MockSessionRepository) SetChallenge(arg0 domain.SessionChallenge) database.Change {
+func (m *MockSessionRepository) SetChallenge(challenge domain.SessionChallenge) database.Change {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetChallenge", arg0)
+	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(arg0 any) *MockSessionRepositorySetChallengeCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChallenge", reflect.TypeOf((*MockSessionRepository)(nil).SetChallenge), challenge)
 	return &MockSessionRepositorySetChallengeCall{Call: call}
 }
 
@@ -893,17 +894,17 @@ func (c *MockSessionRepositorySetChallengeCall) DoAndReturn(f func(domain.Sessio
 }
 
 // SetFactor mocks base method.
-func (m *MockSessionRepository) SetFactor(arg0 domain.SessionFactor) database.Change {
+func (m *MockSessionRepository) SetFactor(factor domain.SessionFactor) database.Change {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetFactor", arg0)
+	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(arg0 any) *MockSessionRepositorySetFactorCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFactor", reflect.TypeOf((*MockSessionRepository)(nil).SetFactor), factor)
 	return &MockSessionRepositorySetFactorCall{Call: call}
 }
 
@@ -931,17 +932,17 @@ func (c *MockSessionRepositorySetFactorCall) DoAndReturn(f func(domain.SessionFa
 }
 
 // SetLifetime mocks base method.
-func (m *MockSessionRepository) SetLifetime(arg0 time.Duration) database.Change {
+func (m *MockSessionRepository) SetLifetime(lifetime time.Duration) database.Change {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetLifetime", arg0)
+	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(arg0 any) *MockSessionRepositorySetLifetimeCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLifetime", reflect.TypeOf((*MockSessionRepository)(nil).SetLifetime), lifetime)
 	return &MockSessionRepositorySetLifetimeCall{Call: call}
 }
 
@@ -969,17 +970,17 @@ func (c *MockSessionRepositorySetLifetimeCall) DoAndReturn(f func(time.Duration)
 }
 
 // SetMetadata mocks base method.
-func (m *MockSessionRepository) SetMetadata(arg0 []*domain.SessionMetadata) database.Change {
+func (m *MockSessionRepository) SetMetadata(metadata []*domain.SessionMetadata) database.Change {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetMetadata", arg0)
+	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(arg0 any) *MockSessionRepositorySetMetadataCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockSessionRepository)(nil).SetMetadata), metadata)
 	return &MockSessionRepositorySetMetadataCall{Call: call}
 }
 
@@ -1007,17 +1008,17 @@ func (c *MockSessionRepositorySetMetadataCall) DoAndReturn(f func([]*domain.Sess
 }
 
 // SetToken mocks base method.
-func (m *MockSessionRepository) SetToken(arg0 string) database.Change {
+func (m *MockSessionRepository) SetToken(token string) database.Change {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetToken", arg0)
+	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(arg0 any) *MockSessionRepositorySetTokenCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetToken", reflect.TypeOf((*MockSessionRepository)(nil).SetToken), token)
 	return &MockSessionRepositorySetTokenCall{Call: call}
 }
 
@@ -1045,17 +1046,17 @@ func (c *MockSessionRepositorySetTokenCall) DoAndReturn(f func(string) database.
 }
 
 // SetUpdatedAt mocks base method.
-func (m *MockSessionRepository) SetUpdatedAt(arg0 time.Time) database.Change {
+func (m *MockSessionRepository) SetUpdatedAt(updatedAt time.Time) database.Change {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetUpdatedAt", arg0)
+	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(arg0 any) *MockSessionRepositorySetUpdatedAtCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockSessionRepository)(nil).SetUpdatedAt), updatedAt)
 	return &MockSessionRepositorySetUpdatedAtCall{Call: call}
 }
 
@@ -1121,17 +1122,17 @@ func (c *MockSessionRepositoryTokenIDColumnCall) DoAndReturn(f func() database.C
 }
 
 // TokenIDCondition mocks base method.
-func (m *MockSessionRepository) TokenIDCondition(arg0 string) database.Condition {
+func (m *MockSessionRepository) TokenIDCondition(tokenID string) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TokenIDCondition", arg0)
+	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(arg0 any) *MockSessionRepositoryTokenIDConditionCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).TokenIDCondition), tokenID)
 	return &MockSessionRepositoryTokenIDConditionCall{Call: call}
 }
 
@@ -1159,10 +1160,10 @@ func (c *MockSessionRepositoryTokenIDConditionCall) DoAndReturn(f func(string) d
 }
 
 // Update mocks base method.
-func (m *MockSessionRepository) Update(arg0 context.Context, arg1 database.QueryExecutor, arg2 database.Condition, arg3 ...database.Change) (int64, error) {
+func (m *MockSessionRepository) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1, arg2}
-	for _, a := range arg3 {
+	varargs := []any{ctx, client, condition}
+	for _, a := range changes {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Update", varargs...)
@@ -1172,9 +1173,9 @@ func (m *MockSessionRepository) Update(arg0 context.Context, arg1 database.Query
 }
 
 // Update indicates an expected call of Update.
-func (mr *MockSessionRepositoryMockRecorder) Update(arg0, arg1, arg2 any, arg3 ...any) *MockSessionRepositoryUpdateCall {
+func (mr *MockSessionRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockSessionRepositoryUpdateCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1, arg2}, arg3...)
+	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}
 }
@@ -1241,17 +1242,17 @@ func (c *MockSessionRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database
 }
 
 // UpdatedAtCondition mocks base method.
-func (m *MockSessionRepository) UpdatedAtCondition(arg0 database.NumberOperation, arg1 time.Time) database.Condition {
+func (m *MockSessionRepository) UpdatedAtCondition(op database.NumberOperation, updatedAt time.Time) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdatedAtCondition", arg0, arg1)
+	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(arg0, arg1 any) *MockSessionRepositoryUpdatedAtConditionCall {
+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), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtCondition", reflect.TypeOf((*MockSessionRepository)(nil).UpdatedAtCondition), op, updatedAt)
 	return &MockSessionRepositoryUpdatedAtConditionCall{Call: call}
 }
 
@@ -1279,17 +1280,17 @@ func (c *MockSessionRepositoryUpdatedAtConditionCall) DoAndReturn(f func(databas
 }
 
 // UserAgentIDCondition mocks base method.
-func (m *MockSessionRepository) UserAgentIDCondition(arg0 string) database.Condition {
+func (m *MockSessionRepository) UserAgentIDCondition(userAgentID string) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserAgentIDCondition", arg0)
+	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(arg0 any) *MockSessionRepositoryUserAgentIDConditionCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserAgentIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).UserAgentIDCondition), userAgentID)
 	return &MockSessionRepositoryUserAgentIDConditionCall{Call: call}
 }
 
@@ -1355,17 +1356,17 @@ func (c *MockSessionRepositoryUserIDColumnCall) DoAndReturn(f func() database.Co
 }
 
 // UserIDCondition mocks base method.
-func (m *MockSessionRepository) UserIDCondition(arg0 string) database.Condition {
+func (m *MockSessionRepository) UserIDCondition(userID string) database.Condition {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UserIDCondition", arg0)
+	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(arg0 any) *MockSessionRepositoryUserIDConditionCall {
+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), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).UserIDCondition), userID)
 	return &MockSessionRepositoryUserIDConditionCall{Call: call}
 }
 

backend/v3/storage/database/dbmock/database.mock.go

@@ -21,6 +21,7 @@ import (
 type MockPool struct {
 	ctrl     *gomock.Controller
 	recorder *MockPoolMockRecorder
+	isgomock struct{}
 }
 
 // MockPoolMockRecorder is the mock recorder for MockPool.
@@ -41,18 +42,18 @@ func (m *MockPool) EXPECT() *MockPoolMockRecorder {
 }
 
 // Acquire mocks base method.
-func (m *MockPool) Acquire(arg0 context.Context) (database.Connection, error) {
+func (m *MockPool) Acquire(ctx context.Context) (database.Connection, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Acquire", arg0)
+	ret := m.ctrl.Call(m, "Acquire", ctx)
 	ret0, _ := ret[0].(database.Connection)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Acquire indicates an expected call of Acquire.
-func (mr *MockPoolMockRecorder) Acquire(arg0 any) *MockPoolAcquireCall {
+func (mr *MockPoolMockRecorder) Acquire(ctx any) *MockPoolAcquireCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Acquire", reflect.TypeOf((*MockPool)(nil).Acquire), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Acquire", reflect.TypeOf((*MockPool)(nil).Acquire), ctx)
 	return &MockPoolAcquireCall{Call: call}
 }
 
@@ -80,18 +81,18 @@ func (c *MockPoolAcquireCall) DoAndReturn(f func(context.Context) (database.Conn
 }
 
 // Begin mocks base method.
-func (m *MockPool) Begin(arg0 context.Context, arg1 *database.TransactionOptions) (database.Transaction, error) {
+func (m *MockPool) Begin(ctx context.Context, opts *database.TransactionOptions) (database.Transaction, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Begin", arg0, arg1)
+	ret := m.ctrl.Call(m, "Begin", ctx, opts)
 	ret0, _ := ret[0].(database.Transaction)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Begin indicates an expected call of Begin.
-func (mr *MockPoolMockRecorder) Begin(arg0, arg1 any) *MockPoolBeginCall {
+func (mr *MockPoolMockRecorder) Begin(ctx, opts any) *MockPoolBeginCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockPool)(nil).Begin), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockPool)(nil).Begin), ctx, opts)
 	return &MockPoolBeginCall{Call: call}
 }
 
@@ -119,17 +120,17 @@ func (c *MockPoolBeginCall) DoAndReturn(f func(context.Context, *database.Transa
 }
 
 // Close mocks base method.
-func (m *MockPool) Close(arg0 context.Context) error {
+func (m *MockPool) Close(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Close", arg0)
+	ret := m.ctrl.Call(m, "Close", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Close indicates an expected call of Close.
-func (mr *MockPoolMockRecorder) Close(arg0 any) *MockPoolCloseCall {
+func (mr *MockPoolMockRecorder) Close(ctx any) *MockPoolCloseCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPool)(nil).Close), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPool)(nil).Close), ctx)
 	return &MockPoolCloseCall{Call: call}
 }
 
@@ -157,10 +158,10 @@ func (c *MockPoolCloseCall) DoAndReturn(f func(context.Context) error) *MockPool
 }
 
 // Exec mocks base method.
-func (m *MockPool) Exec(arg0 context.Context, arg1 string, arg2 ...any) (int64, error) {
+func (m *MockPool) Exec(ctx context.Context, stmt string, args ...any) (int64, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, stmt}
+	for _, a := range args {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Exec", varargs...)
@@ -170,9 +171,9 @@ func (m *MockPool) Exec(arg0 context.Context, arg1 string, arg2 ...any) (int64,
 }
 
 // Exec indicates an expected call of Exec.
-func (mr *MockPoolMockRecorder) Exec(arg0, arg1 any, arg2 ...any) *MockPoolExecCall {
+func (mr *MockPoolMockRecorder) Exec(ctx, stmt any, args ...any) *MockPoolExecCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, stmt}, args...)
 	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockPool)(nil).Exec), varargs...)
 	return &MockPoolExecCall{Call: call}
 }
@@ -201,17 +202,17 @@ func (c *MockPoolExecCall) DoAndReturn(f func(context.Context, string, ...any) (
 }
 
 // Migrate mocks base method.
-func (m *MockPool) Migrate(arg0 context.Context) error {
+func (m *MockPool) Migrate(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Migrate", arg0)
+	ret := m.ctrl.Call(m, "Migrate", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Migrate indicates an expected call of Migrate.
-func (mr *MockPoolMockRecorder) Migrate(arg0 any) *MockPoolMigrateCall {
+func (mr *MockPoolMockRecorder) Migrate(ctx any) *MockPoolMigrateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockPool)(nil).Migrate), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockPool)(nil).Migrate), ctx)
 	return &MockPoolMigrateCall{Call: call}
 }
 
@@ -239,17 +240,17 @@ func (c *MockPoolMigrateCall) DoAndReturn(f func(context.Context) error) *MockPo
 }
 
 // Ping mocks base method.
-func (m *MockPool) Ping(arg0 context.Context) error {
+func (m *MockPool) Ping(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Ping", arg0)
+	ret := m.ctrl.Call(m, "Ping", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Ping indicates an expected call of Ping.
-func (mr *MockPoolMockRecorder) Ping(arg0 any) *MockPoolPingCall {
+func (mr *MockPoolMockRecorder) Ping(ctx any) *MockPoolPingCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockPool)(nil).Ping), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockPool)(nil).Ping), ctx)
 	return &MockPoolPingCall{Call: call}
 }
 
@@ -277,10 +278,10 @@ func (c *MockPoolPingCall) DoAndReturn(f func(context.Context) error) *MockPoolP
 }
 
 // Query mocks base method.
-func (m *MockPool) Query(arg0 context.Context, arg1 string, arg2 ...any) (database.Rows, error) {
+func (m *MockPool) Query(ctx context.Context, stmt string, args ...any) (database.Rows, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, stmt}
+	for _, a := range args {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Query", varargs...)
@@ -290,9 +291,9 @@ func (m *MockPool) Query(arg0 context.Context, arg1 string, arg2 ...any) (databa
 }
 
 // Query indicates an expected call of Query.
-func (mr *MockPoolMockRecorder) Query(arg0, arg1 any, arg2 ...any) *MockPoolQueryCall {
+func (mr *MockPoolMockRecorder) Query(ctx, stmt any, args ...any) *MockPoolQueryCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, stmt}, args...)
 	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockPool)(nil).Query), varargs...)
 	return &MockPoolQueryCall{Call: call}
 }
@@ -321,10 +322,10 @@ func (c *MockPoolQueryCall) DoAndReturn(f func(context.Context, string, ...any)
 }
 
 // QueryRow mocks base method.
-func (m *MockPool) QueryRow(arg0 context.Context, arg1 string, arg2 ...any) database.Row {
+func (m *MockPool) QueryRow(ctx context.Context, stmt string, args ...any) database.Row {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, stmt}
+	for _, a := range args {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "QueryRow", varargs...)
@@ -333,9 +334,9 @@ func (m *MockPool) QueryRow(arg0 context.Context, arg1 string, arg2 ...any) data
 }
 
 // QueryRow indicates an expected call of QueryRow.
-func (mr *MockPoolMockRecorder) QueryRow(arg0, arg1 any, arg2 ...any) *MockPoolQueryRowCall {
+func (mr *MockPoolMockRecorder) QueryRow(ctx, stmt any, args ...any) *MockPoolQueryRowCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, stmt}, args...)
 	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRow", reflect.TypeOf((*MockPool)(nil).QueryRow), varargs...)
 	return &MockPoolQueryRowCall{Call: call}
 }
@@ -367,6 +368,7 @@ func (c *MockPoolQueryRowCall) DoAndReturn(f func(context.Context, string, ...an
 type MockConnection struct {
 	ctrl     *gomock.Controller
 	recorder *MockConnectionMockRecorder
+	isgomock struct{}
 }
 
 // MockConnectionMockRecorder is the mock recorder for MockConnection.
@@ -387,18 +389,18 @@ func (m *MockConnection) EXPECT() *MockConnectionMockRecorder {
 }
 
 // Begin mocks base method.
-func (m *MockConnection) Begin(arg0 context.Context, arg1 *database.TransactionOptions) (database.Transaction, error) {
+func (m *MockConnection) Begin(ctx context.Context, opts *database.TransactionOptions) (database.Transaction, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Begin", arg0, arg1)
+	ret := m.ctrl.Call(m, "Begin", ctx, opts)
 	ret0, _ := ret[0].(database.Transaction)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Begin indicates an expected call of Begin.
-func (mr *MockConnectionMockRecorder) Begin(arg0, arg1 any) *MockConnectionBeginCall {
+func (mr *MockConnectionMockRecorder) Begin(ctx, opts any) *MockConnectionBeginCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockConnection)(nil).Begin), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockConnection)(nil).Begin), ctx, opts)
 	return &MockConnectionBeginCall{Call: call}
 }
 
@@ -426,10 +428,10 @@ func (c *MockConnectionBeginCall) DoAndReturn(f func(context.Context, *database.
 }
 
 // Exec mocks base method.
-func (m *MockConnection) Exec(arg0 context.Context, arg1 string, arg2 ...any) (int64, error) {
+func (m *MockConnection) Exec(ctx context.Context, stmt string, args ...any) (int64, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, stmt}
+	for _, a := range args {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Exec", varargs...)
@@ -439,9 +441,9 @@ func (m *MockConnection) Exec(arg0 context.Context, arg1 string, arg2 ...any) (i
 }
 
 // Exec indicates an expected call of Exec.
-func (mr *MockConnectionMockRecorder) Exec(arg0, arg1 any, arg2 ...any) *MockConnectionExecCall {
+func (mr *MockConnectionMockRecorder) Exec(ctx, stmt any, args ...any) *MockConnectionExecCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, stmt}, args...)
 	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockConnection)(nil).Exec), varargs...)
 	return &MockConnectionExecCall{Call: call}
 }
@@ -470,17 +472,17 @@ func (c *MockConnectionExecCall) DoAndReturn(f func(context.Context, string, ...
 }
 
 // Migrate mocks base method.
-func (m *MockConnection) Migrate(arg0 context.Context) error {
+func (m *MockConnection) Migrate(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Migrate", arg0)
+	ret := m.ctrl.Call(m, "Migrate", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Migrate indicates an expected call of Migrate.
-func (mr *MockConnectionMockRecorder) Migrate(arg0 any) *MockConnectionMigrateCall {
+func (mr *MockConnectionMockRecorder) Migrate(ctx any) *MockConnectionMigrateCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockConnection)(nil).Migrate), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockConnection)(nil).Migrate), ctx)
 	return &MockConnectionMigrateCall{Call: call}
 }
 
@@ -508,17 +510,17 @@ func (c *MockConnectionMigrateCall) DoAndReturn(f func(context.Context) error) *
 }
 
 // Ping mocks base method.
-func (m *MockConnection) Ping(arg0 context.Context) error {
+func (m *MockConnection) Ping(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Ping", arg0)
+	ret := m.ctrl.Call(m, "Ping", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Ping indicates an expected call of Ping.
-func (mr *MockConnectionMockRecorder) Ping(arg0 any) *MockConnectionPingCall {
+func (mr *MockConnectionMockRecorder) Ping(ctx any) *MockConnectionPingCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockConnection)(nil).Ping), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockConnection)(nil).Ping), ctx)
 	return &MockConnectionPingCall{Call: call}
 }
 
@@ -546,10 +548,10 @@ func (c *MockConnectionPingCall) DoAndReturn(f func(context.Context) error) *Moc
 }
 
 // Query mocks base method.
-func (m *MockConnection) Query(arg0 context.Context, arg1 string, arg2 ...any) (database.Rows, error) {
+func (m *MockConnection) Query(ctx context.Context, stmt string, args ...any) (database.Rows, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, stmt}
+	for _, a := range args {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Query", varargs...)
@@ -559,9 +561,9 @@ func (m *MockConnection) Query(arg0 context.Context, arg1 string, arg2 ...any) (
 }
 
 // Query indicates an expected call of Query.
-func (mr *MockConnectionMockRecorder) Query(arg0, arg1 any, arg2 ...any) *MockConnectionQueryCall {
+func (mr *MockConnectionMockRecorder) Query(ctx, stmt any, args ...any) *MockConnectionQueryCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, stmt}, args...)
 	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockConnection)(nil).Query), varargs...)
 	return &MockConnectionQueryCall{Call: call}
 }
@@ -590,10 +592,10 @@ func (c *MockConnectionQueryCall) DoAndReturn(f func(context.Context, string, ..
 }
 
 // QueryRow mocks base method.
-func (m *MockConnection) QueryRow(arg0 context.Context, arg1 string, arg2 ...any) database.Row {
+func (m *MockConnection) QueryRow(ctx context.Context, stmt string, args ...any) database.Row {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, stmt}
+	for _, a := range args {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "QueryRow", varargs...)
@@ -602,9 +604,9 @@ func (m *MockConnection) QueryRow(arg0 context.Context, arg1 string, arg2 ...any
 }
 
 // QueryRow indicates an expected call of QueryRow.
-func (mr *MockConnectionMockRecorder) QueryRow(arg0, arg1 any, arg2 ...any) *MockConnectionQueryRowCall {
+func (mr *MockConnectionMockRecorder) QueryRow(ctx, stmt any, args ...any) *MockConnectionQueryRowCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, stmt}, args...)
 	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRow", reflect.TypeOf((*MockConnection)(nil).QueryRow), varargs...)
 	return &MockConnectionQueryRowCall{Call: call}
 }
@@ -633,17 +635,17 @@ func (c *MockConnectionQueryRowCall) DoAndReturn(f func(context.Context, string,
 }
 
 // Release mocks base method.
-func (m *MockConnection) Release(arg0 context.Context) error {
+func (m *MockConnection) Release(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Release", arg0)
+	ret := m.ctrl.Call(m, "Release", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Release indicates an expected call of Release.
-func (mr *MockConnectionMockRecorder) Release(arg0 any) *MockConnectionReleaseCall {
+func (mr *MockConnectionMockRecorder) Release(ctx any) *MockConnectionReleaseCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Release", reflect.TypeOf((*MockConnection)(nil).Release), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Release", reflect.TypeOf((*MockConnection)(nil).Release), ctx)
 	return &MockConnectionReleaseCall{Call: call}
 }
 
@@ -674,6 +676,7 @@ func (c *MockConnectionReleaseCall) DoAndReturn(f func(context.Context) error) *
 type MockRow struct {
 	ctrl     *gomock.Controller
 	recorder *MockRowMockRecorder
+	isgomock struct{}
 }
 
 // MockRowMockRecorder is the mock recorder for MockRow.
@@ -694,10 +697,10 @@ func (m *MockRow) EXPECT() *MockRowMockRecorder {
 }
 
 // Scan mocks base method.
-func (m *MockRow) Scan(arg0 ...any) error {
+func (m *MockRow) Scan(dest ...any) error {
 	m.ctrl.T.Helper()
 	varargs := []any{}
-	for _, a := range arg0 {
+	for _, a := range dest {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Scan", varargs...)
@@ -706,9 +709,9 @@ func (m *MockRow) Scan(arg0 ...any) error {
 }
 
 // Scan indicates an expected call of Scan.
-func (mr *MockRowMockRecorder) Scan(arg0 ...any) *MockRowScanCall {
+func (mr *MockRowMockRecorder) Scan(dest ...any) *MockRowScanCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockRow)(nil).Scan), arg0...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockRow)(nil).Scan), dest...)
 	return &MockRowScanCall{Call: call}
 }
 
@@ -739,6 +742,7 @@ func (c *MockRowScanCall) DoAndReturn(f func(...any) error) *MockRowScanCall {
 type MockRows struct {
 	ctrl     *gomock.Controller
 	recorder *MockRowsMockRecorder
+	isgomock struct{}
 }
 
 // MockRowsMockRecorder is the mock recorder for MockRows.
@@ -873,10 +877,10 @@ func (c *MockRowsNextCall) DoAndReturn(f func() bool) *MockRowsNextCall {
 }
 
 // Scan mocks base method.
-func (m *MockRows) Scan(arg0 ...any) error {
+func (m *MockRows) Scan(dest ...any) error {
 	m.ctrl.T.Helper()
 	varargs := []any{}
-	for _, a := range arg0 {
+	for _, a := range dest {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Scan", varargs...)
@@ -885,9 +889,9 @@ func (m *MockRows) Scan(arg0 ...any) error {
 }
 
 // Scan indicates an expected call of Scan.
-func (mr *MockRowsMockRecorder) Scan(arg0 ...any) *MockRowsScanCall {
+func (mr *MockRowsMockRecorder) Scan(dest ...any) *MockRowsScanCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockRows)(nil).Scan), arg0...)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockRows)(nil).Scan), dest...)
 	return &MockRowsScanCall{Call: call}
 }
 
@@ -918,6 +922,7 @@ func (c *MockRowsScanCall) DoAndReturn(f func(...any) error) *MockRowsScanCall {
 type MockTransaction struct {
 	ctrl     *gomock.Controller
 	recorder *MockTransactionMockRecorder
+	isgomock struct{}
 }
 
 // MockTransactionMockRecorder is the mock recorder for MockTransaction.
@@ -938,18 +943,18 @@ func (m *MockTransaction) EXPECT() *MockTransactionMockRecorder {
 }
 
 // Begin mocks base method.
-func (m *MockTransaction) Begin(arg0 context.Context) (database.Transaction, error) {
+func (m *MockTransaction) Begin(ctx context.Context) (database.Transaction, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Begin", arg0)
+	ret := m.ctrl.Call(m, "Begin", ctx)
 	ret0, _ := ret[0].(database.Transaction)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Begin indicates an expected call of Begin.
-func (mr *MockTransactionMockRecorder) Begin(arg0 any) *MockTransactionBeginCall {
+func (mr *MockTransactionMockRecorder) Begin(ctx any) *MockTransactionBeginCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockTransaction)(nil).Begin), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockTransaction)(nil).Begin), ctx)
 	return &MockTransactionBeginCall{Call: call}
 }
 
@@ -977,17 +982,17 @@ func (c *MockTransactionBeginCall) DoAndReturn(f func(context.Context) (database
 }
 
 // Commit mocks base method.
-func (m *MockTransaction) Commit(arg0 context.Context) error {
+func (m *MockTransaction) Commit(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Commit", arg0)
+	ret := m.ctrl.Call(m, "Commit", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Commit indicates an expected call of Commit.
-func (mr *MockTransactionMockRecorder) Commit(arg0 any) *MockTransactionCommitCall {
+func (mr *MockTransactionMockRecorder) Commit(ctx any) *MockTransactionCommitCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockTransaction)(nil).Commit), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockTransaction)(nil).Commit), ctx)
 	return &MockTransactionCommitCall{Call: call}
 }
 
@@ -1015,17 +1020,17 @@ func (c *MockTransactionCommitCall) DoAndReturn(f func(context.Context) error) *
 }
 
 // End mocks base method.
-func (m *MockTransaction) End(arg0 context.Context, arg1 error) error {
+func (m *MockTransaction) End(ctx context.Context, err error) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "End", arg0, arg1)
+	ret := m.ctrl.Call(m, "End", ctx, err)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // End indicates an expected call of End.
-func (mr *MockTransactionMockRecorder) End(arg0, arg1 any) *MockTransactionEndCall {
+func (mr *MockTransactionMockRecorder) End(ctx, err any) *MockTransactionEndCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "End", reflect.TypeOf((*MockTransaction)(nil).End), arg0, arg1)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "End", reflect.TypeOf((*MockTransaction)(nil).End), ctx, err)
 	return &MockTransactionEndCall{Call: call}
 }
 
@@ -1053,10 +1058,10 @@ func (c *MockTransactionEndCall) DoAndReturn(f func(context.Context, error) erro
 }
 
 // Exec mocks base method.
-func (m *MockTransaction) Exec(arg0 context.Context, arg1 string, arg2 ...any) (int64, error) {
+func (m *MockTransaction) Exec(ctx context.Context, stmt string, args ...any) (int64, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, stmt}
+	for _, a := range args {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Exec", varargs...)
@@ -1066,9 +1071,9 @@ func (m *MockTransaction) Exec(arg0 context.Context, arg1 string, arg2 ...any) (
 }
 
 // Exec indicates an expected call of Exec.
-func (mr *MockTransactionMockRecorder) Exec(arg0, arg1 any, arg2 ...any) *MockTransactionExecCall {
+func (mr *MockTransactionMockRecorder) Exec(ctx, stmt any, args ...any) *MockTransactionExecCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, stmt}, args...)
 	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockTransaction)(nil).Exec), varargs...)
 	return &MockTransactionExecCall{Call: call}
 }
@@ -1097,10 +1102,10 @@ func (c *MockTransactionExecCall) DoAndReturn(f func(context.Context, string, ..
 }
 
 // Query mocks base method.
-func (m *MockTransaction) Query(arg0 context.Context, arg1 string, arg2 ...any) (database.Rows, error) {
+func (m *MockTransaction) Query(ctx context.Context, stmt string, args ...any) (database.Rows, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, stmt}
+	for _, a := range args {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Query", varargs...)
@@ -1110,9 +1115,9 @@ func (m *MockTransaction) Query(arg0 context.Context, arg1 string, arg2 ...any)
 }
 
 // Query indicates an expected call of Query.
-func (mr *MockTransactionMockRecorder) Query(arg0, arg1 any, arg2 ...any) *MockTransactionQueryCall {
+func (mr *MockTransactionMockRecorder) Query(ctx, stmt any, args ...any) *MockTransactionQueryCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, stmt}, args...)
 	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockTransaction)(nil).Query), varargs...)
 	return &MockTransactionQueryCall{Call: call}
 }
@@ -1141,10 +1146,10 @@ func (c *MockTransactionQueryCall) DoAndReturn(f func(context.Context, string, .
 }
 
 // QueryRow mocks base method.
-func (m *MockTransaction) QueryRow(arg0 context.Context, arg1 string, arg2 ...any) database.Row {
+func (m *MockTransaction) QueryRow(ctx context.Context, stmt string, args ...any) database.Row {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, stmt}
+	for _, a := range args {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "QueryRow", varargs...)
@@ -1153,9 +1158,9 @@ func (m *MockTransaction) QueryRow(arg0 context.Context, arg1 string, arg2 ...an
 }
 
 // QueryRow indicates an expected call of QueryRow.
-func (mr *MockTransactionMockRecorder) QueryRow(arg0, arg1 any, arg2 ...any) *MockTransactionQueryRowCall {
+func (mr *MockTransactionMockRecorder) QueryRow(ctx, stmt any, args ...any) *MockTransactionQueryRowCall {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, stmt}, args...)
 	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRow", reflect.TypeOf((*MockTransaction)(nil).QueryRow), varargs...)
 	return &MockTransactionQueryRowCall{Call: call}
 }
@@ -1184,17 +1189,17 @@ func (c *MockTransactionQueryRowCall) DoAndReturn(f func(context.Context, string
 }
 
 // Rollback mocks base method.
-func (m *MockTransaction) Rollback(arg0 context.Context) error {
+func (m *MockTransaction) Rollback(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Rollback", arg0)
+	ret := m.ctrl.Call(m, "Rollback", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Rollback indicates an expected call of Rollback.
-func (mr *MockTransactionMockRecorder) Rollback(arg0 any) *MockTransactionRollbackCall {
+func (mr *MockTransactionMockRecorder) Rollback(ctx any) *MockTransactionRollbackCall {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockTransaction)(nil).Rollback), arg0)
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockTransaction)(nil).Rollback), ctx)
 	return &MockTransactionRollbackCall{Call: call}
 }