From fbb6a406c8a3d34791eb5787d6fb628770f4d494 Mon Sep 17 00:00:00 2001
From: Livio Spring <9405495+livio-a@users.noreply.github.com>
Date: Wed, 8 Apr 2026 08:48:05 +0200
Subject: [PATCH] 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
---
 apps/api/project.json                         |  24 +-
 .../v3/domain/mock/branding_settings.mock.go  |  38 ++
 .../v3/domain/mock/domain_settings.mock.go    |  38 ++
 .../mock/legal_and_support_settings.mock.go   |  38 ++
 .../v3/domain/mock/lockout_settings.mock.go   |  38 ++
 backend/v3/domain/mock/login_settings.mock.go |  38 ++
 .../domain/mock/notification_settings.mock.go |  38 ++
 .../domain/mock/organization_settings.mock.go |  38 ++
 .../mock/password_complexity_settings.mock.go |  38 ++
 .../mock/password_expiry_settings.mock.go     |  38 ++
 .../v3/domain/mock/security_settings.mock.go  |  38 ++
 backend/v3/domain/mock/session.mock.go        | 199 ++++-----
 .../storage/database/dbmock/database.mock.go  | 215 +++++-----
 .../repository/mock/repository.mock.go        |  57 +--
 internal/command/mock_login_paths.go          |  33 +-
 internal/crypto/code.go                       |   2 +
 internal/crypto/generate.go                   |   4 -
 internal/domain/deviceauthstate_string.go     |   5 +-
 internal/eventstore/mock/queue.mock.go        |  11 +-
 .../repository/mock/repository.mock.go        |  52 +--
 internal/id/mock/generator.mock.go            |   1 +
 .../channels/mock/channel.mock.go             |   9 +-
 .../channels/mock/message.mock.go             |   1 +
 .../handlers/mock/commands.mock.go            | 402 ++----------------
 .../senders/mock/code_generator.mock.go       |   9 +-
 internal/serviceping/mock/queries.mock.go     |  17 +-
 internal/serviceping/mock/queue.mock.go       |  11 +-
 internal/serviceping/mock/telemetry.mock.go   |  21 +-
 internal/static/mock/storage_mock.go          |   1 +
 pkg/grpc/protoc/v2/options.pb.go              |  90 ++--
 30 files changed, 790 insertions(+), 754 deletions(-)
 delete mode 100644 internal/crypto/generate.go

diff --git a/apps/api/project.json b/apps/api/project.json
index 3592ed6df..6ec1c00bb 100644
--- a/apps/api/project.json
+++ b/apps/api/project.json
@@ -280,18 +280,18 @@
             "executor": "nx:run-commands",
             "options": {
                 "commands": [
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/daixiang0/gci@v0.11.2",
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/dmarkham/enumer@v1.5.11",
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install go.uber.org/mock/mockgen@v0.4.0",
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install golang.org/x/tools/cmd/stringer@v0.36.0",
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/rakyll/statik@v0.1.7",
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/bufbuild/buf/cmd/buf@v1.45.0",
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.35.1",
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.5.1",
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway@v2.22.0",
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2@v2.22.0",
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/envoyproxy/protoc-gen-validate@v1.1.0",
-                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install connectrpc.com/connect/cmd/protoc-gen-connect-go@v1.18.1",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/daixiang0/gci@v0.14.0",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/dmarkham/enumer@v1.6.3",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install go.uber.org/mock/mockgen@v0.6.0",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install golang.org/x/tools/cmd/stringer@v0.43.0",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/rakyll/statik@v0.1.8",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/bufbuild/buf/cmd/buf@v1.67.0",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.36.11",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.6.1",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway@v2.28.0",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2@v2.28.0",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install github.com/envoyproxy/protoc-gen-validate@v1.3.3",
+                    "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install connectrpc.com/connect/cmd/protoc-gen-connect-go@v1.19.1",
                     "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install ./internal/protoc/protoc-gen-authoption",
                     "GOBIN=${PWD}/.artifacts/bin/$(go env GOOS)/$(go env GOARCH) go install ./internal/protoc/protoc-gen-zitadel"
                 ]
diff --git a/backend/v3/domain/mock/branding_settings.mock.go b/backend/v3/domain/mock/branding_settings.mock.go
index 9f4c2df9e..1f2d57175 100644
--- a/backend/v3/domain/mock/branding_settings.mock.go
+++ b/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()
diff --git a/backend/v3/domain/mock/domain_settings.mock.go b/backend/v3/domain/mock/domain_settings.mock.go
index 771bc9ecc..07b7585fb 100644
--- a/backend/v3/domain/mock/domain_settings.mock.go
+++ b/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()
diff --git a/backend/v3/domain/mock/legal_and_support_settings.mock.go b/backend/v3/domain/mock/legal_and_support_settings.mock.go
index afcf006c1..0d121781e 100644
--- a/backend/v3/domain/mock/legal_and_support_settings.mock.go
+++ b/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()
diff --git a/backend/v3/domain/mock/lockout_settings.mock.go b/backend/v3/domain/mock/lockout_settings.mock.go
index 5b7bedaf3..86e6c7255 100644
--- a/backend/v3/domain/mock/lockout_settings.mock.go
+++ b/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()
diff --git a/backend/v3/domain/mock/login_settings.mock.go b/backend/v3/domain/mock/login_settings.mock.go
index f5c3a66f1..ac04bcfb1 100644
--- a/backend/v3/domain/mock/login_settings.mock.go
+++ b/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()
diff --git a/backend/v3/domain/mock/notification_settings.mock.go b/backend/v3/domain/mock/notification_settings.mock.go
index b7447f669..6f63b6df3 100644
--- a/backend/v3/domain/mock/notification_settings.mock.go
+++ b/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()
diff --git a/backend/v3/domain/mock/organization_settings.mock.go b/backend/v3/domain/mock/organization_settings.mock.go
index 6a5953fa9..f4d8a7bb6 100644
--- a/backend/v3/domain/mock/organization_settings.mock.go
+++ b/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()
diff --git a/backend/v3/domain/mock/password_complexity_settings.mock.go b/backend/v3/domain/mock/password_complexity_settings.mock.go
index 16f00b748..2a427bc16 100644
--- a/backend/v3/domain/mock/password_complexity_settings.mock.go
+++ b/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()
diff --git a/backend/v3/domain/mock/password_expiry_settings.mock.go b/backend/v3/domain/mock/password_expiry_settings.mock.go
index 50c94d76c..94eeb9cac 100644
--- a/backend/v3/domain/mock/password_expiry_settings.mock.go
+++ b/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()
diff --git a/backend/v3/domain/mock/security_settings.mock.go b/backend/v3/domain/mock/security_settings.mock.go
index 1102d3992..b63e1cb6e 100644
--- a/backend/v3/domain/mock/security_settings.mock.go
+++ b/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()
diff --git a/backend/v3/domain/mock/session.mock.go b/backend/v3/domain/mock/session.mock.go
index 799a4b495..ff2e8e626 100644
--- a/backend/v3/domain/mock/session.mock.go
+++ b/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}
 }
 
diff --git a/backend/v3/storage/database/dbmock/database.mock.go b/backend/v3/storage/database/dbmock/database.mock.go
index e44019c86..2c8b176b7 100644
--- a/backend/v3/storage/database/dbmock/database.mock.go
+++ b/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}
 }
 
diff --git a/internal/auth_request/repository/mock/repository.mock.go b/internal/auth_request/repository/mock/repository.mock.go
index c05e5010f..b5dfe7f28 100644
--- a/internal/auth_request/repository/mock/repository.mock.go
+++ b/internal/auth_request/repository/mock/repository.mock.go
@@ -21,6 +21,7 @@ import (
 type MockAuthRequestCache struct {
 	ctrl     *gomock.Controller
 	recorder *MockAuthRequestCacheMockRecorder
+	isgomock struct{}
 }
 
 // MockAuthRequestCacheMockRecorder is the mock recorder for MockAuthRequestCache.
@@ -41,99 +42,99 @@ func (m *MockAuthRequestCache) EXPECT() *MockAuthRequestCacheMockRecorder {
 }
 
 // CacheAuthRequest mocks base method.
-func (m *MockAuthRequestCache) CacheAuthRequest(arg0 context.Context, arg1 *domain.AuthRequest) {
+func (m *MockAuthRequestCache) CacheAuthRequest(ctx context.Context, request *domain.AuthRequest) {
 	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "CacheAuthRequest", arg0, arg1)
+	m.ctrl.Call(m, "CacheAuthRequest", ctx, request)
 }
 
 // CacheAuthRequest indicates an expected call of CacheAuthRequest.
-func (mr *MockAuthRequestCacheMockRecorder) CacheAuthRequest(arg0, arg1 any) *gomock.Call {
+func (mr *MockAuthRequestCacheMockRecorder) CacheAuthRequest(ctx, request any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CacheAuthRequest", reflect.TypeOf((*MockAuthRequestCache)(nil).CacheAuthRequest), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CacheAuthRequest", reflect.TypeOf((*MockAuthRequestCache)(nil).CacheAuthRequest), ctx, request)
 }
 
 // DeleteAuthRequest mocks base method.
-func (m *MockAuthRequestCache) DeleteAuthRequest(arg0 context.Context, arg1 string) error {
+func (m *MockAuthRequestCache) DeleteAuthRequest(ctx context.Context, id string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteAuthRequest", arg0, arg1)
+	ret := m.ctrl.Call(m, "DeleteAuthRequest", ctx, id)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // DeleteAuthRequest indicates an expected call of DeleteAuthRequest.
-func (mr *MockAuthRequestCacheMockRecorder) DeleteAuthRequest(arg0, arg1 any) *gomock.Call {
+func (mr *MockAuthRequestCacheMockRecorder) DeleteAuthRequest(ctx, id any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAuthRequest", reflect.TypeOf((*MockAuthRequestCache)(nil).DeleteAuthRequest), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAuthRequest", reflect.TypeOf((*MockAuthRequestCache)(nil).DeleteAuthRequest), ctx, id)
 }
 
 // GetAuthRequestByCode mocks base method.
-func (m *MockAuthRequestCache) GetAuthRequestByCode(arg0 context.Context, arg1 string) (*domain.AuthRequest, error) {
+func (m *MockAuthRequestCache) GetAuthRequestByCode(ctx context.Context, code string) (*domain.AuthRequest, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetAuthRequestByCode", arg0, arg1)
+	ret := m.ctrl.Call(m, "GetAuthRequestByCode", ctx, code)
 	ret0, _ := ret[0].(*domain.AuthRequest)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // GetAuthRequestByCode indicates an expected call of GetAuthRequestByCode.
-func (mr *MockAuthRequestCacheMockRecorder) GetAuthRequestByCode(arg0, arg1 any) *gomock.Call {
+func (mr *MockAuthRequestCacheMockRecorder) GetAuthRequestByCode(ctx, code any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthRequestByCode", reflect.TypeOf((*MockAuthRequestCache)(nil).GetAuthRequestByCode), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthRequestByCode", reflect.TypeOf((*MockAuthRequestCache)(nil).GetAuthRequestByCode), ctx, code)
 }
 
 // GetAuthRequestByID mocks base method.
-func (m *MockAuthRequestCache) GetAuthRequestByID(arg0 context.Context, arg1 string) (*domain.AuthRequest, error) {
+func (m *MockAuthRequestCache) GetAuthRequestByID(ctx context.Context, id string) (*domain.AuthRequest, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetAuthRequestByID", arg0, arg1)
+	ret := m.ctrl.Call(m, "GetAuthRequestByID", ctx, id)
 	ret0, _ := ret[0].(*domain.AuthRequest)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // GetAuthRequestByID indicates an expected call of GetAuthRequestByID.
-func (mr *MockAuthRequestCacheMockRecorder) GetAuthRequestByID(arg0, arg1 any) *gomock.Call {
+func (mr *MockAuthRequestCacheMockRecorder) GetAuthRequestByID(ctx, id any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthRequestByID", reflect.TypeOf((*MockAuthRequestCache)(nil).GetAuthRequestByID), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthRequestByID", reflect.TypeOf((*MockAuthRequestCache)(nil).GetAuthRequestByID), ctx, id)
 }
 
 // Health mocks base method.
-func (m *MockAuthRequestCache) Health(arg0 context.Context) error {
+func (m *MockAuthRequestCache) Health(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Health", arg0)
+	ret := m.ctrl.Call(m, "Health", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Health indicates an expected call of Health.
-func (mr *MockAuthRequestCacheMockRecorder) Health(arg0 any) *gomock.Call {
+func (mr *MockAuthRequestCacheMockRecorder) Health(ctx any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockAuthRequestCache)(nil).Health), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockAuthRequestCache)(nil).Health), ctx)
 }
 
 // SaveAuthRequest mocks base method.
-func (m *MockAuthRequestCache) SaveAuthRequest(arg0 context.Context, arg1 *domain.AuthRequest) error {
+func (m *MockAuthRequestCache) SaveAuthRequest(ctx context.Context, request *domain.AuthRequest) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SaveAuthRequest", arg0, arg1)
+	ret := m.ctrl.Call(m, "SaveAuthRequest", ctx, request)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // SaveAuthRequest indicates an expected call of SaveAuthRequest.
-func (mr *MockAuthRequestCacheMockRecorder) SaveAuthRequest(arg0, arg1 any) *gomock.Call {
+func (mr *MockAuthRequestCacheMockRecorder) SaveAuthRequest(ctx, request any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAuthRequest", reflect.TypeOf((*MockAuthRequestCache)(nil).SaveAuthRequest), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAuthRequest", reflect.TypeOf((*MockAuthRequestCache)(nil).SaveAuthRequest), ctx, request)
 }
 
 // UpdateAuthRequest mocks base method.
-func (m *MockAuthRequestCache) UpdateAuthRequest(arg0 context.Context, arg1 *domain.AuthRequest) error {
+func (m *MockAuthRequestCache) UpdateAuthRequest(ctx context.Context, request *domain.AuthRequest) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpdateAuthRequest", arg0, arg1)
+	ret := m.ctrl.Call(m, "UpdateAuthRequest", ctx, request)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // UpdateAuthRequest indicates an expected call of UpdateAuthRequest.
-func (mr *MockAuthRequestCacheMockRecorder) UpdateAuthRequest(arg0, arg1 any) *gomock.Call {
+func (mr *MockAuthRequestCacheMockRecorder) UpdateAuthRequest(ctx, request any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuthRequest", reflect.TypeOf((*MockAuthRequestCache)(nil).UpdateAuthRequest), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuthRequest", reflect.TypeOf((*MockAuthRequestCache)(nil).UpdateAuthRequest), ctx, request)
 }
diff --git a/internal/command/mock_login_paths.go b/internal/command/mock_login_paths.go
index 718eed270..13da5e0cf 100644
--- a/internal/command/mock_login_paths.go
+++ b/internal/command/mock_login_paths.go
@@ -20,6 +20,7 @@ import (
 type MockLoginPaths struct {
 	ctrl     *gomock.Controller
 	recorder *MockLoginPathsMockRecorder
+	isgomock struct{}
 }
 
 // MockLoginPathsMockRecorder is the mock recorder for MockLoginPaths.
@@ -40,57 +41,57 @@ func (m *MockLoginPaths) EXPECT() *MockLoginPathsMockRecorder {
 }
 
 // DefaultDomainClaimedURLTemplate mocks base method.
-func (m *MockLoginPaths) DefaultDomainClaimedURLTemplate(arg0 context.Context) string {
+func (m *MockLoginPaths) DefaultDomainClaimedURLTemplate(ctx context.Context) string {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DefaultDomainClaimedURLTemplate", arg0)
+	ret := m.ctrl.Call(m, "DefaultDomainClaimedURLTemplate", ctx)
 	ret0, _ := ret[0].(string)
 	return ret0
 }
 
 // DefaultDomainClaimedURLTemplate indicates an expected call of DefaultDomainClaimedURLTemplate.
-func (mr *MockLoginPathsMockRecorder) DefaultDomainClaimedURLTemplate(arg0 any) *gomock.Call {
+func (mr *MockLoginPathsMockRecorder) DefaultDomainClaimedURLTemplate(ctx any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultDomainClaimedURLTemplate", reflect.TypeOf((*MockLoginPaths)(nil).DefaultDomainClaimedURLTemplate), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultDomainClaimedURLTemplate", reflect.TypeOf((*MockLoginPaths)(nil).DefaultDomainClaimedURLTemplate), ctx)
 }
 
 // DefaultEmailCodeURLTemplate mocks base method.
-func (m *MockLoginPaths) DefaultEmailCodeURLTemplate(arg0 context.Context) string {
+func (m *MockLoginPaths) DefaultEmailCodeURLTemplate(ctx context.Context) string {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DefaultEmailCodeURLTemplate", arg0)
+	ret := m.ctrl.Call(m, "DefaultEmailCodeURLTemplate", ctx)
 	ret0, _ := ret[0].(string)
 	return ret0
 }
 
 // DefaultEmailCodeURLTemplate indicates an expected call of DefaultEmailCodeURLTemplate.
-func (mr *MockLoginPathsMockRecorder) DefaultEmailCodeURLTemplate(arg0 any) *gomock.Call {
+func (mr *MockLoginPathsMockRecorder) DefaultEmailCodeURLTemplate(ctx any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultEmailCodeURLTemplate", reflect.TypeOf((*MockLoginPaths)(nil).DefaultEmailCodeURLTemplate), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultEmailCodeURLTemplate", reflect.TypeOf((*MockLoginPaths)(nil).DefaultEmailCodeURLTemplate), ctx)
 }
 
 // DefaultPasskeySetURLTemplate mocks base method.
-func (m *MockLoginPaths) DefaultPasskeySetURLTemplate(arg0 context.Context) string {
+func (m *MockLoginPaths) DefaultPasskeySetURLTemplate(ctx context.Context) string {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DefaultPasskeySetURLTemplate", arg0)
+	ret := m.ctrl.Call(m, "DefaultPasskeySetURLTemplate", ctx)
 	ret0, _ := ret[0].(string)
 	return ret0
 }
 
 // DefaultPasskeySetURLTemplate indicates an expected call of DefaultPasskeySetURLTemplate.
-func (mr *MockLoginPathsMockRecorder) DefaultPasskeySetURLTemplate(arg0 any) *gomock.Call {
+func (mr *MockLoginPathsMockRecorder) DefaultPasskeySetURLTemplate(ctx any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultPasskeySetURLTemplate", reflect.TypeOf((*MockLoginPaths)(nil).DefaultPasskeySetURLTemplate), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultPasskeySetURLTemplate", reflect.TypeOf((*MockLoginPaths)(nil).DefaultPasskeySetURLTemplate), ctx)
 }
 
 // DefaultPasswordSetURLTemplate mocks base method.
-func (m *MockLoginPaths) DefaultPasswordSetURLTemplate(arg0 context.Context) string {
+func (m *MockLoginPaths) DefaultPasswordSetURLTemplate(ctx context.Context) string {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DefaultPasswordSetURLTemplate", arg0)
+	ret := m.ctrl.Call(m, "DefaultPasswordSetURLTemplate", ctx)
 	ret0, _ := ret[0].(string)
 	return ret0
 }
 
 // DefaultPasswordSetURLTemplate indicates an expected call of DefaultPasswordSetURLTemplate.
-func (mr *MockLoginPathsMockRecorder) DefaultPasswordSetURLTemplate(arg0 any) *gomock.Call {
+func (mr *MockLoginPathsMockRecorder) DefaultPasswordSetURLTemplate(ctx any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultPasswordSetURLTemplate", reflect.TypeOf((*MockLoginPaths)(nil).DefaultPasswordSetURLTemplate), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultPasswordSetURLTemplate", reflect.TypeOf((*MockLoginPaths)(nil).DefaultPasswordSetURLTemplate), ctx)
 }
diff --git a/internal/crypto/code.go b/internal/crypto/code.go
index d017a974f..34123e790 100644
--- a/internal/crypto/code.go
+++ b/internal/crypto/code.go
@@ -23,6 +23,8 @@ type GeneratorConfig struct {
 	IncludeSymbols      bool
 }
 
+//go:generate mockgen -source code.go -destination ./code_mock.go -package crypto
+
 type Generator interface {
 	Length() uint
 	Expiry() time.Duration
diff --git a/internal/crypto/generate.go b/internal/crypto/generate.go
deleted file mode 100644
index fd3de9f75..000000000
--- a/internal/crypto/generate.go
+++ /dev/null
@@ -1,4 +0,0 @@
-package crypto
-
-//go:generate mockgen -source crypto.go -destination ./crypto_mock.go -package crypto
-//go:generate mockgen -source code.go -destination ./code_mock.go -package crypto
diff --git a/internal/domain/deviceauthstate_string.go b/internal/domain/deviceauthstate_string.go
index df61b82bb..35eb66955 100644
--- a/internal/domain/deviceauthstate_string.go
+++ b/internal/domain/deviceauthstate_string.go
@@ -22,8 +22,9 @@ const _DeviceAuthState_name = "undefinedinitiatedapproveddeniedexpireddoneinvali
 var _DeviceAuthState_index = [...]uint8{0, 9, 18, 26, 32, 39, 43, 50}
 
 func (i DeviceAuthState) String() string {
-	if i >= DeviceAuthState(len(_DeviceAuthState_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_DeviceAuthState_index)-1 {
 		return "DeviceAuthState(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _DeviceAuthState_name[_DeviceAuthState_index[i]:_DeviceAuthState_index[i+1]]
+	return _DeviceAuthState_name[_DeviceAuthState_index[idx]:_DeviceAuthState_index[idx+1]]
 }
diff --git a/internal/eventstore/mock/queue.mock.go b/internal/eventstore/mock/queue.mock.go
index 403a60ad4..5c4596597 100644
--- a/internal/eventstore/mock/queue.mock.go
+++ b/internal/eventstore/mock/queue.mock.go
@@ -23,6 +23,7 @@ import (
 type MockExecutionQueue struct {
 	ctrl     *gomock.Controller
 	recorder *MockExecutionQueueMockRecorder
+	isgomock struct{}
 }
 
 // MockExecutionQueueMockRecorder is the mock recorder for MockExecutionQueue.
@@ -43,10 +44,10 @@ func (m *MockExecutionQueue) EXPECT() *MockExecutionQueueMockRecorder {
 }
 
 // InsertManyFastTx mocks base method.
-func (m *MockExecutionQueue) InsertManyFastTx(arg0 context.Context, arg1 *sql.Tx, arg2 []river.JobArgs, arg3 ...queue.InsertOpt) error {
+func (m *MockExecutionQueue) InsertManyFastTx(ctx context.Context, tx *sql.Tx, args []river.JobArgs, opts ...queue.InsertOpt) error {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1, arg2}
-	for _, a := range arg3 {
+	varargs := []any{ctx, tx, args}
+	for _, a := range opts {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "InsertManyFastTx", varargs...)
@@ -55,8 +56,8 @@ func (m *MockExecutionQueue) InsertManyFastTx(arg0 context.Context, arg1 *sql.Tx
 }
 
 // InsertManyFastTx indicates an expected call of InsertManyFastTx.
-func (mr *MockExecutionQueueMockRecorder) InsertManyFastTx(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
+func (mr *MockExecutionQueueMockRecorder) InsertManyFastTx(ctx, tx, args any, opts ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1, arg2}, arg3...)
+	varargs := append([]any{ctx, tx, args}, opts...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertManyFastTx", reflect.TypeOf((*MockExecutionQueue)(nil).InsertManyFastTx), varargs...)
 }
diff --git a/internal/eventstore/repository/mock/repository.mock.go b/internal/eventstore/repository/mock/repository.mock.go
index 43c006c7b..6f1a79507 100644
--- a/internal/eventstore/repository/mock/repository.mock.go
+++ b/internal/eventstore/repository/mock/repository.mock.go
@@ -24,6 +24,7 @@ import (
 type MockQuerier struct {
 	ctrl     *gomock.Controller
 	recorder *MockQuerierMockRecorder
+	isgomock struct{}
 }
 
 // MockQuerierMockRecorder is the mock recorder for MockQuerier.
@@ -58,67 +59,68 @@ func (mr *MockQuerierMockRecorder) Client() *gomock.Call {
 }
 
 // FilterToReducer mocks base method.
-func (m *MockQuerier) FilterToReducer(arg0 context.Context, arg1 *eventstore.SearchQueryBuilder, arg2 eventstore.Reducer) error {
+func (m *MockQuerier) FilterToReducer(ctx context.Context, searchQuery *eventstore.SearchQueryBuilder, r eventstore.Reducer) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "FilterToReducer", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "FilterToReducer", ctx, searchQuery, r)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // FilterToReducer indicates an expected call of FilterToReducer.
-func (mr *MockQuerierMockRecorder) FilterToReducer(arg0, arg1, arg2 any) *gomock.Call {
+func (mr *MockQuerierMockRecorder) FilterToReducer(ctx, searchQuery, r any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterToReducer", reflect.TypeOf((*MockQuerier)(nil).FilterToReducer), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterToReducer", reflect.TypeOf((*MockQuerier)(nil).FilterToReducer), ctx, searchQuery, r)
 }
 
 // Health mocks base method.
-func (m *MockQuerier) Health(arg0 context.Context) error {
+func (m *MockQuerier) Health(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Health", arg0)
+	ret := m.ctrl.Call(m, "Health", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Health indicates an expected call of Health.
-func (mr *MockQuerierMockRecorder) Health(arg0 any) *gomock.Call {
+func (mr *MockQuerierMockRecorder) Health(ctx any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockQuerier)(nil).Health), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockQuerier)(nil).Health), ctx)
 }
 
 // InstanceIDs mocks base method.
-func (m *MockQuerier) InstanceIDs(arg0 context.Context, arg1 *eventstore.SearchQueryBuilder) ([]string, error) {
+func (m *MockQuerier) InstanceIDs(ctx context.Context, queryFactory *eventstore.SearchQueryBuilder) ([]string, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "InstanceIDs", arg0, arg1)
+	ret := m.ctrl.Call(m, "InstanceIDs", ctx, queryFactory)
 	ret0, _ := ret[0].([]string)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // InstanceIDs indicates an expected call of InstanceIDs.
-func (mr *MockQuerierMockRecorder) InstanceIDs(arg0, arg1 any) *gomock.Call {
+func (mr *MockQuerierMockRecorder) InstanceIDs(ctx, queryFactory any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDs", reflect.TypeOf((*MockQuerier)(nil).InstanceIDs), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDs", reflect.TypeOf((*MockQuerier)(nil).InstanceIDs), ctx, queryFactory)
 }
 
 // LatestPosition mocks base method.
-func (m *MockQuerier) LatestPosition(arg0 context.Context, arg1 *eventstore.SearchQueryBuilder) (decimal.Decimal, error) {
+func (m *MockQuerier) LatestPosition(ctx context.Context, queryFactory *eventstore.SearchQueryBuilder) (decimal.Decimal, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LatestPosition", arg0, arg1)
+	ret := m.ctrl.Call(m, "LatestPosition", ctx, queryFactory)
 	ret0, _ := ret[0].(decimal.Decimal)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // LatestPosition indicates an expected call of LatestPosition.
-func (mr *MockQuerierMockRecorder) LatestPosition(arg0, arg1 any) *gomock.Call {
+func (mr *MockQuerierMockRecorder) LatestPosition(ctx, queryFactory any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestPosition", reflect.TypeOf((*MockQuerier)(nil).LatestPosition), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestPosition", reflect.TypeOf((*MockQuerier)(nil).LatestPosition), ctx, queryFactory)
 }
 
 // MockPusher is a mock of Pusher interface.
 type MockPusher struct {
 	ctrl     *gomock.Controller
 	recorder *MockPusherMockRecorder
+	isgomock struct{}
 }
 
 // MockPusherMockRecorder is the mock recorder for MockPusher.
@@ -139,24 +141,24 @@ func (m *MockPusher) EXPECT() *MockPusherMockRecorder {
 }
 
 // Health mocks base method.
-func (m *MockPusher) Health(arg0 context.Context) error {
+func (m *MockPusher) Health(ctx context.Context) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Health", arg0)
+	ret := m.ctrl.Call(m, "Health", ctx)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Health indicates an expected call of Health.
-func (mr *MockPusherMockRecorder) Health(arg0 any) *gomock.Call {
+func (mr *MockPusherMockRecorder) Health(ctx any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockPusher)(nil).Health), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockPusher)(nil).Health), ctx)
 }
 
 // Push mocks base method.
-func (m *MockPusher) Push(arg0 context.Context, arg1 database.QueryExecutor, arg2 ...eventstore.Command) ([]eventstore.Event, error) {
+func (m *MockPusher) Push(ctx context.Context, client database.QueryExecutor, commands ...eventstore.Command) ([]eventstore.Event, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, client}
+	for _, a := range commands {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Push", varargs...)
@@ -166,8 +168,8 @@ func (m *MockPusher) Push(arg0 context.Context, arg1 database.QueryExecutor, arg
 }
 
 // Push indicates an expected call of Push.
-func (mr *MockPusherMockRecorder) Push(arg0, arg1 any, arg2 ...any) *gomock.Call {
+func (mr *MockPusherMockRecorder) Push(ctx, client any, commands ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, client}, commands...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockPusher)(nil).Push), varargs...)
 }
diff --git a/internal/id/mock/generator.mock.go b/internal/id/mock/generator.mock.go
index 9fce9d958..188797487 100644
--- a/internal/id/mock/generator.mock.go
+++ b/internal/id/mock/generator.mock.go
@@ -19,6 +19,7 @@ import (
 type MockGenerator struct {
 	ctrl     *gomock.Controller
 	recorder *MockGeneratorMockRecorder
+	isgomock struct{}
 }
 
 // MockGeneratorMockRecorder is the mock recorder for MockGenerator.
diff --git a/internal/notification/channels/mock/channel.mock.go b/internal/notification/channels/mock/channel.mock.go
index 3594178a4..e49886b2c 100644
--- a/internal/notification/channels/mock/channel.mock.go
+++ b/internal/notification/channels/mock/channel.mock.go
@@ -20,6 +20,7 @@ import (
 type MockNotificationChannel struct {
 	ctrl     *gomock.Controller
 	recorder *MockNotificationChannelMockRecorder
+	isgomock struct{}
 }
 
 // MockNotificationChannelMockRecorder is the mock recorder for MockNotificationChannel.
@@ -40,15 +41,15 @@ func (m *MockNotificationChannel) EXPECT() *MockNotificationChannelMockRecorder
 }
 
 // HandleMessage mocks base method.
-func (m *MockNotificationChannel) HandleMessage(arg0 channels.Message) error {
+func (m *MockNotificationChannel) HandleMessage(message channels.Message) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HandleMessage", arg0)
+	ret := m.ctrl.Call(m, "HandleMessage", message)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // HandleMessage indicates an expected call of HandleMessage.
-func (mr *MockNotificationChannelMockRecorder) HandleMessage(arg0 any) *gomock.Call {
+func (mr *MockNotificationChannelMockRecorder) HandleMessage(message any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockNotificationChannel)(nil).HandleMessage), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockNotificationChannel)(nil).HandleMessage), message)
 }
diff --git a/internal/notification/channels/mock/message.mock.go b/internal/notification/channels/mock/message.mock.go
index d05dc0ff9..6d2ae76e4 100644
--- a/internal/notification/channels/mock/message.mock.go
+++ b/internal/notification/channels/mock/message.mock.go
@@ -20,6 +20,7 @@ import (
 type MockMessage struct {
 	ctrl     *gomock.Controller
 	recorder *MockMessageMockRecorder
+	isgomock struct{}
 }
 
 // MockMessageMockRecorder is the mock recorder for MockMessage.
diff --git a/internal/notification/handlers/mock/commands.mock.go b/internal/notification/handlers/mock/commands.mock.go
index 8cb525fa1..270b2b225 100644
--- a/internal/notification/handlers/mock/commands.mock.go
+++ b/internal/notification/handlers/mock/commands.mock.go
@@ -3,7 +3,7 @@
 //
 // Generated by this command:
 //
-//	mockgen -typed -package mock -destination ./mock/commands.mock.go . Commands
+//	mockgen -package mock -destination ./mock/commands.mock.go github.com/zitadel/zitadel/internal/notification/handlers Commands
 //
 
 // Package mock is a generated GoMock package.
@@ -44,17 +44,17 @@ func (m *MockCommands) EXPECT() *MockCommandsMockRecorder {
 }
 
 // BackChannelLogoutSent mocks base method.
-func (m *MockCommands) BackChannelLogoutSent(arg0 context.Context, arg1, arg2, arg3 string) error {
+func (m *MockCommands) BackChannelLogoutSent(ctx context.Context, id, oidcSessionID, instanceID string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BackChannelLogoutSent", arg0, arg1, arg2, arg3)
+	ret := m.ctrl.Call(m, "BackChannelLogoutSent", ctx, id, oidcSessionID, instanceID)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // BackChannelLogoutSent indicates an expected call of BackChannelLogoutSent.
-func (mr *MockCommandsMockRecorder) BackChannelLogoutSent(arg0, arg1, arg2, arg3 any) *gomock.Call {
+func (mr *MockCommandsMockRecorder) BackChannelLogoutSent(ctx, id, oidcSessionID, instanceID any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackChannelLogoutSent", reflect.TypeOf((*MockCommands)(nil).BackChannelLogoutSent), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackChannelLogoutSent", reflect.TypeOf((*MockCommands)(nil).BackChannelLogoutSent), ctx, id, oidcSessionID, instanceID)
 }
 
 // HumanEmailVerificationCodeSent mocks base method.
@@ -66,33 +66,9 @@ func (m *MockCommands) HumanEmailVerificationCodeSent(ctx context.Context, orgID
 }
 
 // HumanEmailVerificationCodeSent indicates an expected call of HumanEmailVerificationCodeSent.
-func (mr *MockCommandsMockRecorder) HumanEmailVerificationCodeSent(ctx, orgID, userID any) *MockCommandsHumanEmailVerificationCodeSentCall {
+func (mr *MockCommandsMockRecorder) HumanEmailVerificationCodeSent(ctx, orgID, userID any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanEmailVerificationCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanEmailVerificationCodeSent), ctx, orgID, userID)
-	return &MockCommandsHumanEmailVerificationCodeSentCall{Call: call}
-}
-
-// MockCommandsHumanEmailVerificationCodeSentCall wrap *gomock.Call
-type MockCommandsHumanEmailVerificationCodeSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsHumanEmailVerificationCodeSentCall) Return(arg0 error) *MockCommandsHumanEmailVerificationCodeSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsHumanEmailVerificationCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsHumanEmailVerificationCodeSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsHumanEmailVerificationCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsHumanEmailVerificationCodeSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanEmailVerificationCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanEmailVerificationCodeSent), ctx, orgID, userID)
 }
 
 // HumanInitCodeSent mocks base method.
@@ -104,33 +80,9 @@ func (m *MockCommands) HumanInitCodeSent(ctx context.Context, orgID, userID stri
 }
 
 // HumanInitCodeSent indicates an expected call of HumanInitCodeSent.
-func (mr *MockCommandsMockRecorder) HumanInitCodeSent(ctx, orgID, userID any) *MockCommandsHumanInitCodeSentCall {
+func (mr *MockCommandsMockRecorder) HumanInitCodeSent(ctx, orgID, userID any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanInitCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanInitCodeSent), ctx, orgID, userID)
-	return &MockCommandsHumanInitCodeSentCall{Call: call}
-}
-
-// MockCommandsHumanInitCodeSentCall wrap *gomock.Call
-type MockCommandsHumanInitCodeSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsHumanInitCodeSentCall) Return(arg0 error) *MockCommandsHumanInitCodeSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsHumanInitCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsHumanInitCodeSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsHumanInitCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsHumanInitCodeSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanInitCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanInitCodeSent), ctx, orgID, userID)
 }
 
 // HumanOTPEmailCodeSent mocks base method.
@@ -142,33 +94,9 @@ func (m *MockCommands) HumanOTPEmailCodeSent(ctx context.Context, userID, resour
 }
 
 // HumanOTPEmailCodeSent indicates an expected call of HumanOTPEmailCodeSent.
-func (mr *MockCommandsMockRecorder) HumanOTPEmailCodeSent(ctx, userID, resourceOwner any) *MockCommandsHumanOTPEmailCodeSentCall {
+func (mr *MockCommandsMockRecorder) HumanOTPEmailCodeSent(ctx, userID, resourceOwner any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanOTPEmailCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanOTPEmailCodeSent), ctx, userID, resourceOwner)
-	return &MockCommandsHumanOTPEmailCodeSentCall{Call: call}
-}
-
-// MockCommandsHumanOTPEmailCodeSentCall wrap *gomock.Call
-type MockCommandsHumanOTPEmailCodeSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsHumanOTPEmailCodeSentCall) Return(arg0 error) *MockCommandsHumanOTPEmailCodeSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsHumanOTPEmailCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsHumanOTPEmailCodeSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsHumanOTPEmailCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsHumanOTPEmailCodeSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanOTPEmailCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanOTPEmailCodeSent), ctx, userID, resourceOwner)
 }
 
 // HumanOTPSMSCodeSent mocks base method.
@@ -180,33 +108,9 @@ func (m *MockCommands) HumanOTPSMSCodeSent(ctx context.Context, userID, resource
 }
 
 // HumanOTPSMSCodeSent indicates an expected call of HumanOTPSMSCodeSent.
-func (mr *MockCommandsMockRecorder) HumanOTPSMSCodeSent(ctx, userID, resourceOwner, generatorInfo any) *MockCommandsHumanOTPSMSCodeSentCall {
+func (mr *MockCommandsMockRecorder) HumanOTPSMSCodeSent(ctx, userID, resourceOwner, generatorInfo any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanOTPSMSCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanOTPSMSCodeSent), ctx, userID, resourceOwner, generatorInfo)
-	return &MockCommandsHumanOTPSMSCodeSentCall{Call: call}
-}
-
-// MockCommandsHumanOTPSMSCodeSentCall wrap *gomock.Call
-type MockCommandsHumanOTPSMSCodeSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsHumanOTPSMSCodeSentCall) Return(arg0 error) *MockCommandsHumanOTPSMSCodeSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsHumanOTPSMSCodeSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanOTPSMSCodeSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsHumanOTPSMSCodeSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanOTPSMSCodeSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanOTPSMSCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanOTPSMSCodeSent), ctx, userID, resourceOwner, generatorInfo)
 }
 
 // HumanPasswordlessInitCodeSent mocks base method.
@@ -218,33 +122,9 @@ func (m *MockCommands) HumanPasswordlessInitCodeSent(ctx context.Context, userID
 }
 
 // HumanPasswordlessInitCodeSent indicates an expected call of HumanPasswordlessInitCodeSent.
-func (mr *MockCommandsMockRecorder) HumanPasswordlessInitCodeSent(ctx, userID, resourceOwner, codeID any) *MockCommandsHumanPasswordlessInitCodeSentCall {
+func (mr *MockCommandsMockRecorder) HumanPasswordlessInitCodeSent(ctx, userID, resourceOwner, codeID any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanPasswordlessInitCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanPasswordlessInitCodeSent), ctx, userID, resourceOwner, codeID)
-	return &MockCommandsHumanPasswordlessInitCodeSentCall{Call: call}
-}
-
-// MockCommandsHumanPasswordlessInitCodeSentCall wrap *gomock.Call
-type MockCommandsHumanPasswordlessInitCodeSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsHumanPasswordlessInitCodeSentCall) Return(arg0 error) *MockCommandsHumanPasswordlessInitCodeSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsHumanPasswordlessInitCodeSentCall) Do(f func(context.Context, string, string, string) error) *MockCommandsHumanPasswordlessInitCodeSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsHumanPasswordlessInitCodeSentCall) DoAndReturn(f func(context.Context, string, string, string) error) *MockCommandsHumanPasswordlessInitCodeSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanPasswordlessInitCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanPasswordlessInitCodeSent), ctx, userID, resourceOwner, codeID)
 }
 
 // HumanPhoneVerificationCodeSent mocks base method.
@@ -256,33 +136,9 @@ func (m *MockCommands) HumanPhoneVerificationCodeSent(ctx context.Context, orgID
 }
 
 // HumanPhoneVerificationCodeSent indicates an expected call of HumanPhoneVerificationCodeSent.
-func (mr *MockCommandsMockRecorder) HumanPhoneVerificationCodeSent(ctx, orgID, userID, generatorInfo any) *MockCommandsHumanPhoneVerificationCodeSentCall {
+func (mr *MockCommandsMockRecorder) HumanPhoneVerificationCodeSent(ctx, orgID, userID, generatorInfo any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanPhoneVerificationCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanPhoneVerificationCodeSent), ctx, orgID, userID, generatorInfo)
-	return &MockCommandsHumanPhoneVerificationCodeSentCall{Call: call}
-}
-
-// MockCommandsHumanPhoneVerificationCodeSentCall wrap *gomock.Call
-type MockCommandsHumanPhoneVerificationCodeSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsHumanPhoneVerificationCodeSentCall) Return(arg0 error) *MockCommandsHumanPhoneVerificationCodeSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsHumanPhoneVerificationCodeSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanPhoneVerificationCodeSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsHumanPhoneVerificationCodeSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanPhoneVerificationCodeSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanPhoneVerificationCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanPhoneVerificationCodeSent), ctx, orgID, userID, generatorInfo)
 }
 
 // InviteCodeSent mocks base method.
@@ -294,33 +150,9 @@ func (m *MockCommands) InviteCodeSent(ctx context.Context, orgID, userID string)
 }
 
 // InviteCodeSent indicates an expected call of InviteCodeSent.
-func (mr *MockCommandsMockRecorder) InviteCodeSent(ctx, orgID, userID any) *MockCommandsInviteCodeSentCall {
+func (mr *MockCommandsMockRecorder) InviteCodeSent(ctx, orgID, userID any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InviteCodeSent", reflect.TypeOf((*MockCommands)(nil).InviteCodeSent), ctx, orgID, userID)
-	return &MockCommandsInviteCodeSentCall{Call: call}
-}
-
-// MockCommandsInviteCodeSentCall wrap *gomock.Call
-type MockCommandsInviteCodeSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsInviteCodeSentCall) Return(arg0 error) *MockCommandsInviteCodeSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsInviteCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsInviteCodeSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsInviteCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsInviteCodeSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InviteCodeSent", reflect.TypeOf((*MockCommands)(nil).InviteCodeSent), ctx, orgID, userID)
 }
 
 // MilestonePushed mocks base method.
@@ -332,33 +164,9 @@ func (m *MockCommands) MilestonePushed(ctx context.Context, instanceID string, m
 }
 
 // MilestonePushed indicates an expected call of MilestonePushed.
-func (mr *MockCommandsMockRecorder) MilestonePushed(ctx, instanceID, msType, endpoints any) *MockCommandsMilestonePushedCall {
+func (mr *MockCommandsMockRecorder) MilestonePushed(ctx, instanceID, msType, endpoints any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MilestonePushed", reflect.TypeOf((*MockCommands)(nil).MilestonePushed), ctx, instanceID, msType, endpoints)
-	return &MockCommandsMilestonePushedCall{Call: call}
-}
-
-// MockCommandsMilestonePushedCall wrap *gomock.Call
-type MockCommandsMilestonePushedCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsMilestonePushedCall) Return(arg0 error) *MockCommandsMilestonePushedCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsMilestonePushedCall) Do(f func(context.Context, string, milestone.Type, []string) error) *MockCommandsMilestonePushedCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsMilestonePushedCall) DoAndReturn(f func(context.Context, string, milestone.Type, []string) error) *MockCommandsMilestonePushedCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MilestonePushed", reflect.TypeOf((*MockCommands)(nil).MilestonePushed), ctx, instanceID, msType, endpoints)
 }
 
 // OTPEmailSent mocks base method.
@@ -370,33 +178,9 @@ func (m *MockCommands) OTPEmailSent(ctx context.Context, sessionID, resourceOwne
 }
 
 // OTPEmailSent indicates an expected call of OTPEmailSent.
-func (mr *MockCommandsMockRecorder) OTPEmailSent(ctx, sessionID, resourceOwner any) *MockCommandsOTPEmailSentCall {
+func (mr *MockCommandsMockRecorder) OTPEmailSent(ctx, sessionID, resourceOwner any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OTPEmailSent", reflect.TypeOf((*MockCommands)(nil).OTPEmailSent), ctx, sessionID, resourceOwner)
-	return &MockCommandsOTPEmailSentCall{Call: call}
-}
-
-// MockCommandsOTPEmailSentCall wrap *gomock.Call
-type MockCommandsOTPEmailSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsOTPEmailSentCall) Return(arg0 error) *MockCommandsOTPEmailSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsOTPEmailSentCall) Do(f func(context.Context, string, string) error) *MockCommandsOTPEmailSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsOTPEmailSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsOTPEmailSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OTPEmailSent", reflect.TypeOf((*MockCommands)(nil).OTPEmailSent), ctx, sessionID, resourceOwner)
 }
 
 // OTPSMSSent mocks base method.
@@ -408,33 +192,9 @@ func (m *MockCommands) OTPSMSSent(ctx context.Context, sessionID, resourceOwner
 }
 
 // OTPSMSSent indicates an expected call of OTPSMSSent.
-func (mr *MockCommandsMockRecorder) OTPSMSSent(ctx, sessionID, resourceOwner, generatorInfo any) *MockCommandsOTPSMSSentCall {
+func (mr *MockCommandsMockRecorder) OTPSMSSent(ctx, sessionID, resourceOwner, generatorInfo any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OTPSMSSent", reflect.TypeOf((*MockCommands)(nil).OTPSMSSent), ctx, sessionID, resourceOwner, generatorInfo)
-	return &MockCommandsOTPSMSSentCall{Call: call}
-}
-
-// MockCommandsOTPSMSSentCall wrap *gomock.Call
-type MockCommandsOTPSMSSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsOTPSMSSentCall) Return(arg0 error) *MockCommandsOTPSMSSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsOTPSMSSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsOTPSMSSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsOTPSMSSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsOTPSMSSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OTPSMSSent", reflect.TypeOf((*MockCommands)(nil).OTPSMSSent), ctx, sessionID, resourceOwner, generatorInfo)
 }
 
 // PasswordChangeSent mocks base method.
@@ -446,33 +206,9 @@ func (m *MockCommands) PasswordChangeSent(ctx context.Context, orgID, userID str
 }
 
 // PasswordChangeSent indicates an expected call of PasswordChangeSent.
-func (mr *MockCommandsMockRecorder) PasswordChangeSent(ctx, orgID, userID any) *MockCommandsPasswordChangeSentCall {
+func (mr *MockCommandsMockRecorder) PasswordChangeSent(ctx, orgID, userID any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PasswordChangeSent", reflect.TypeOf((*MockCommands)(nil).PasswordChangeSent), ctx, orgID, userID)
-	return &MockCommandsPasswordChangeSentCall{Call: call}
-}
-
-// MockCommandsPasswordChangeSentCall wrap *gomock.Call
-type MockCommandsPasswordChangeSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsPasswordChangeSentCall) Return(arg0 error) *MockCommandsPasswordChangeSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsPasswordChangeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsPasswordChangeSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsPasswordChangeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsPasswordChangeSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PasswordChangeSent", reflect.TypeOf((*MockCommands)(nil).PasswordChangeSent), ctx, orgID, userID)
 }
 
 // PasswordCodeSent mocks base method.
@@ -484,33 +220,9 @@ func (m *MockCommands) PasswordCodeSent(ctx context.Context, orgID, userID strin
 }
 
 // PasswordCodeSent indicates an expected call of PasswordCodeSent.
-func (mr *MockCommandsMockRecorder) PasswordCodeSent(ctx, orgID, userID, generatorInfo any) *MockCommandsPasswordCodeSentCall {
+func (mr *MockCommandsMockRecorder) PasswordCodeSent(ctx, orgID, userID, generatorInfo any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PasswordCodeSent", reflect.TypeOf((*MockCommands)(nil).PasswordCodeSent), ctx, orgID, userID, generatorInfo)
-	return &MockCommandsPasswordCodeSentCall{Call: call}
-}
-
-// MockCommandsPasswordCodeSentCall wrap *gomock.Call
-type MockCommandsPasswordCodeSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsPasswordCodeSentCall) Return(arg0 error) *MockCommandsPasswordCodeSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsPasswordCodeSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsPasswordCodeSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsPasswordCodeSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsPasswordCodeSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PasswordCodeSent", reflect.TypeOf((*MockCommands)(nil).PasswordCodeSent), ctx, orgID, userID, generatorInfo)
 }
 
 // UsageNotificationSent mocks base method.
@@ -522,33 +234,9 @@ func (m *MockCommands) UsageNotificationSent(ctx context.Context, dueEvent *quot
 }
 
 // UsageNotificationSent indicates an expected call of UsageNotificationSent.
-func (mr *MockCommandsMockRecorder) UsageNotificationSent(ctx, dueEvent any) *MockCommandsUsageNotificationSentCall {
+func (mr *MockCommandsMockRecorder) UsageNotificationSent(ctx, dueEvent any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UsageNotificationSent", reflect.TypeOf((*MockCommands)(nil).UsageNotificationSent), ctx, dueEvent)
-	return &MockCommandsUsageNotificationSentCall{Call: call}
-}
-
-// MockCommandsUsageNotificationSentCall wrap *gomock.Call
-type MockCommandsUsageNotificationSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsUsageNotificationSentCall) Return(arg0 error) *MockCommandsUsageNotificationSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsUsageNotificationSentCall) Do(f func(context.Context, *quota.NotificationDueEvent) error) *MockCommandsUsageNotificationSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsUsageNotificationSentCall) DoAndReturn(f func(context.Context, *quota.NotificationDueEvent) error) *MockCommandsUsageNotificationSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UsageNotificationSent", reflect.TypeOf((*MockCommands)(nil).UsageNotificationSent), ctx, dueEvent)
 }
 
 // UserDomainClaimedSent mocks base method.
@@ -560,31 +248,7 @@ func (m *MockCommands) UserDomainClaimedSent(ctx context.Context, orgID, userID
 }
 
 // UserDomainClaimedSent indicates an expected call of UserDomainClaimedSent.
-func (mr *MockCommandsMockRecorder) UserDomainClaimedSent(ctx, orgID, userID any) *MockCommandsUserDomainClaimedSentCall {
+func (mr *MockCommandsMockRecorder) UserDomainClaimedSent(ctx, orgID, userID any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserDomainClaimedSent", reflect.TypeOf((*MockCommands)(nil).UserDomainClaimedSent), ctx, orgID, userID)
-	return &MockCommandsUserDomainClaimedSentCall{Call: call}
-}
-
-// MockCommandsUserDomainClaimedSentCall wrap *gomock.Call
-type MockCommandsUserDomainClaimedSentCall struct {
-	*gomock.Call
-}
-
-// Return rewrite *gomock.Call.Return
-func (c *MockCommandsUserDomainClaimedSentCall) Return(arg0 error) *MockCommandsUserDomainClaimedSentCall {
-	c.Call = c.Call.Return(arg0)
-	return c
-}
-
-// Do rewrite *gomock.Call.Do
-func (c *MockCommandsUserDomainClaimedSentCall) Do(f func(context.Context, string, string) error) *MockCommandsUserDomainClaimedSentCall {
-	c.Call = c.Call.Do(f)
-	return c
-}
-
-// DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockCommandsUserDomainClaimedSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsUserDomainClaimedSentCall {
-	c.Call = c.Call.DoAndReturn(f)
-	return c
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserDomainClaimedSent", reflect.TypeOf((*MockCommands)(nil).UserDomainClaimedSent), ctx, orgID, userID)
 }
diff --git a/internal/notification/senders/mock/code_generator.mock.go b/internal/notification/senders/mock/code_generator.mock.go
index 15bdd2cc3..37969df29 100644
--- a/internal/notification/senders/mock/code_generator.mock.go
+++ b/internal/notification/senders/mock/code_generator.mock.go
@@ -19,6 +19,7 @@ import (
 type MockCodeGenerator struct {
 	ctrl     *gomock.Controller
 	recorder *MockCodeGeneratorMockRecorder
+	isgomock struct{}
 }
 
 // MockCodeGeneratorMockRecorder is the mock recorder for MockCodeGenerator.
@@ -39,15 +40,15 @@ func (m *MockCodeGenerator) EXPECT() *MockCodeGeneratorMockRecorder {
 }
 
 // VerifyCode mocks base method.
-func (m *MockCodeGenerator) VerifyCode(arg0, arg1 string) error {
+func (m *MockCodeGenerator) VerifyCode(verificationID, code string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "VerifyCode", arg0, arg1)
+	ret := m.ctrl.Call(m, "VerifyCode", verificationID, code)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // VerifyCode indicates an expected call of VerifyCode.
-func (mr *MockCodeGeneratorMockRecorder) VerifyCode(arg0, arg1 any) *gomock.Call {
+func (mr *MockCodeGeneratorMockRecorder) VerifyCode(verificationID, code any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyCode", reflect.TypeOf((*MockCodeGenerator)(nil).VerifyCode), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyCode", reflect.TypeOf((*MockCodeGenerator)(nil).VerifyCode), verificationID, code)
 }
diff --git a/internal/serviceping/mock/queries.mock.go b/internal/serviceping/mock/queries.mock.go
index a19484a38..593c4d5ff 100644
--- a/internal/serviceping/mock/queries.mock.go
+++ b/internal/serviceping/mock/queries.mock.go
@@ -21,6 +21,7 @@ import (
 type MockQueries struct {
 	ctrl     *gomock.Controller
 	recorder *MockQueriesMockRecorder
+	isgomock struct{}
 }
 
 // MockQueriesMockRecorder is the mock recorder for MockQueries.
@@ -41,31 +42,31 @@ func (m *MockQueries) EXPECT() *MockQueriesMockRecorder {
 }
 
 // ListResourceCounts mocks base method.
-func (m *MockQueries) ListResourceCounts(arg0 context.Context, arg1, arg2 int) ([]query.ResourceCount, error) {
+func (m *MockQueries) ListResourceCounts(ctx context.Context, lastID, size int) ([]query.ResourceCount, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListResourceCounts", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "ListResourceCounts", ctx, lastID, size)
 	ret0, _ := ret[0].([]query.ResourceCount)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // ListResourceCounts indicates an expected call of ListResourceCounts.
-func (mr *MockQueriesMockRecorder) ListResourceCounts(arg0, arg1, arg2 any) *gomock.Call {
+func (mr *MockQueriesMockRecorder) ListResourceCounts(ctx, lastID, size any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceCounts", reflect.TypeOf((*MockQueries)(nil).ListResourceCounts), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceCounts", reflect.TypeOf((*MockQueries)(nil).ListResourceCounts), ctx, lastID, size)
 }
 
 // SearchInstances mocks base method.
-func (m *MockQueries) SearchInstances(arg0 context.Context, arg1 *query.InstanceSearchQueries) (*query.Instances, error) {
+func (m *MockQueries) SearchInstances(ctx context.Context, queries *query.InstanceSearchQueries) (*query.Instances, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SearchInstances", arg0, arg1)
+	ret := m.ctrl.Call(m, "SearchInstances", ctx, queries)
 	ret0, _ := ret[0].(*query.Instances)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // SearchInstances indicates an expected call of SearchInstances.
-func (mr *MockQueriesMockRecorder) SearchInstances(arg0, arg1 any) *gomock.Call {
+func (mr *MockQueriesMockRecorder) SearchInstances(ctx, queries any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchInstances", reflect.TypeOf((*MockQueries)(nil).SearchInstances), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchInstances", reflect.TypeOf((*MockQueries)(nil).SearchInstances), ctx, queries)
 }
diff --git a/internal/serviceping/mock/queue.mock.go b/internal/serviceping/mock/queue.mock.go
index 0eb606bed..e984352a8 100644
--- a/internal/serviceping/mock/queue.mock.go
+++ b/internal/serviceping/mock/queue.mock.go
@@ -22,6 +22,7 @@ import (
 type MockQueue struct {
 	ctrl     *gomock.Controller
 	recorder *MockQueueMockRecorder
+	isgomock struct{}
 }
 
 // MockQueueMockRecorder is the mock recorder for MockQueue.
@@ -42,10 +43,10 @@ func (m *MockQueue) EXPECT() *MockQueueMockRecorder {
 }
 
 // Insert mocks base method.
-func (m *MockQueue) Insert(arg0 context.Context, arg1 river.JobArgs, arg2 ...queue.InsertOpt) error {
+func (m *MockQueue) Insert(ctx context.Context, args river.JobArgs, opts ...queue.InsertOpt) error {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, args}
+	for _, a := range opts {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "Insert", varargs...)
@@ -54,8 +55,8 @@ func (m *MockQueue) Insert(arg0 context.Context, arg1 river.JobArgs, arg2 ...que
 }
 
 // Insert indicates an expected call of Insert.
-func (mr *MockQueueMockRecorder) Insert(arg0, arg1 any, arg2 ...any) *gomock.Call {
+func (mr *MockQueueMockRecorder) Insert(ctx, args any, opts ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, args}, opts...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockQueue)(nil).Insert), varargs...)
 }
diff --git a/internal/serviceping/mock/telemetry.mock.go b/internal/serviceping/mock/telemetry.mock.go
index d7f0351a0..536bf3467 100644
--- a/internal/serviceping/mock/telemetry.mock.go
+++ b/internal/serviceping/mock/telemetry.mock.go
@@ -22,6 +22,7 @@ import (
 type MockTelemetryServiceClient struct {
 	ctrl     *gomock.Controller
 	recorder *MockTelemetryServiceClientMockRecorder
+	isgomock struct{}
 }
 
 // MockTelemetryServiceClientMockRecorder is the mock recorder for MockTelemetryServiceClient.
@@ -42,10 +43,10 @@ func (m *MockTelemetryServiceClient) EXPECT() *MockTelemetryServiceClientMockRec
 }
 
 // ReportBaseInformation mocks base method.
-func (m *MockTelemetryServiceClient) ReportBaseInformation(arg0 context.Context, arg1 *analytics.ReportBaseInformationRequest, arg2 ...grpc.CallOption) (*analytics.ReportBaseInformationResponse, error) {
+func (m *MockTelemetryServiceClient) ReportBaseInformation(ctx context.Context, in *analytics.ReportBaseInformationRequest, opts ...grpc.CallOption) (*analytics.ReportBaseInformationResponse, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, in}
+	for _, a := range opts {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "ReportBaseInformation", varargs...)
@@ -55,17 +56,17 @@ func (m *MockTelemetryServiceClient) ReportBaseInformation(arg0 context.Context,
 }
 
 // ReportBaseInformation indicates an expected call of ReportBaseInformation.
-func (mr *MockTelemetryServiceClientMockRecorder) ReportBaseInformation(arg0, arg1 any, arg2 ...any) *gomock.Call {
+func (mr *MockTelemetryServiceClientMockRecorder) ReportBaseInformation(ctx, in any, opts ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, in}, opts...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportBaseInformation", reflect.TypeOf((*MockTelemetryServiceClient)(nil).ReportBaseInformation), varargs...)
 }
 
 // ReportResourceCounts mocks base method.
-func (m *MockTelemetryServiceClient) ReportResourceCounts(arg0 context.Context, arg1 *analytics.ReportResourceCountsRequest, arg2 ...grpc.CallOption) (*analytics.ReportResourceCountsResponse, error) {
+func (m *MockTelemetryServiceClient) ReportResourceCounts(ctx context.Context, in *analytics.ReportResourceCountsRequest, opts ...grpc.CallOption) (*analytics.ReportResourceCountsResponse, error) {
 	m.ctrl.T.Helper()
-	varargs := []any{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{ctx, in}
+	for _, a := range opts {
 		varargs = append(varargs, a)
 	}
 	ret := m.ctrl.Call(m, "ReportResourceCounts", varargs...)
@@ -75,8 +76,8 @@ func (m *MockTelemetryServiceClient) ReportResourceCounts(arg0 context.Context,
 }
 
 // ReportResourceCounts indicates an expected call of ReportResourceCounts.
-func (mr *MockTelemetryServiceClientMockRecorder) ReportResourceCounts(arg0, arg1 any, arg2 ...any) *gomock.Call {
+func (mr *MockTelemetryServiceClientMockRecorder) ReportResourceCounts(ctx, in any, opts ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{arg0, arg1}, arg2...)
+	varargs := append([]any{ctx, in}, opts...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportResourceCounts", reflect.TypeOf((*MockTelemetryServiceClient)(nil).ReportResourceCounts), varargs...)
 }
diff --git a/internal/static/mock/storage_mock.go b/internal/static/mock/storage_mock.go
index 3ef02efa9..637bbd603 100644
--- a/internal/static/mock/storage_mock.go
+++ b/internal/static/mock/storage_mock.go
@@ -22,6 +22,7 @@ import (
 type MockStorage struct {
 	ctrl     *gomock.Controller
 	recorder *MockStorageMockRecorder
+	isgomock struct{}
 }
 
 // MockStorageMockRecorder is the mock recorder for MockStorage.
diff --git a/pkg/grpc/protoc/v2/options.pb.go b/pkg/grpc/protoc/v2/options.pb.go
index da7e038ee..3b744fedf 100644
--- a/pkg/grpc/protoc/v2/options.pb.go
+++ b/pkg/grpc/protoc/v2/options.pb.go
@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.35.1
+// 	protoc-gen-go v1.36.11
 // 	protoc        (unknown)
 // source: zitadel/protoc_gen_zitadel/v2/options.proto
 
@@ -12,6 +12,7 @@ import (
 	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
 	reflect "reflect"
 	sync "sync"
+	unsafe "unsafe"
 )
 
 const (
@@ -22,12 +23,11 @@ const (
 )
 
 type Options struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	AuthOption    *AuthOption            `protobuf:"bytes,1,opt,name=auth_option,json=authOption,proto3" json:"auth_option,omitempty"`
+	HttpResponse  *CustomHTTPResponse    `protobuf:"bytes,2,opt,name=http_response,json=httpResponse,proto3" json:"http_response,omitempty"`
 	unknownFields protoimpl.UnknownFields
-
-	AuthOption   *AuthOption         `protobuf:"bytes,1,opt,name=auth_option,json=authOption,proto3" json:"auth_option,omitempty"`
-	HttpResponse *CustomHTTPResponse `protobuf:"bytes,2,opt,name=http_response,json=httpResponse,proto3" json:"http_response,omitempty"`
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *Options) Reset() {
@@ -75,12 +75,11 @@ func (x *Options) GetHttpResponse() *CustomHTTPResponse {
 }
 
 type AuthOption struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Permission    string                 `protobuf:"bytes,1,opt,name=permission,proto3" json:"permission,omitempty"`
+	OrgField      string                 `protobuf:"bytes,3,opt,name=org_field,json=orgField,proto3" json:"org_field,omitempty"`
 	unknownFields protoimpl.UnknownFields
-
-	Permission string `protobuf:"bytes,1,opt,name=permission,proto3" json:"permission,omitempty"`
-	OrgField   string `protobuf:"bytes,3,opt,name=org_field,json=orgField,proto3" json:"org_field,omitempty"`
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *AuthOption) Reset() {
@@ -128,11 +127,10 @@ func (x *AuthOption) GetOrgField() string {
 }
 
 type CustomHTTPResponse struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	SuccessCode   int32                  `protobuf:"varint,1,opt,name=success_code,json=successCode,proto3" json:"success_code,omitempty"`
 	unknownFields protoimpl.UnknownFields
-
-	SuccessCode int32 `protobuf:"varint,1,opt,name=success_code,json=successCode,proto3" json:"success_code,omitempty"`
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *CustomHTTPResponse) Reset() {
@@ -191,54 +189,31 @@ var (
 
 var File_zitadel_protoc_gen_zitadel_v2_options_proto protoreflect.FileDescriptor
 
-var file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDesc = []byte{
-	0x0a, 0x2b, 0x7a, 0x69, 0x74, 0x61, 0x64, 0x65, 0x6c, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
-	0x5f, 0x67, 0x65, 0x6e, 0x5f, 0x7a, 0x69, 0x74, 0x61, 0x64, 0x65, 0x6c, 0x2f, 0x76, 0x32, 0x2f,
-	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1d, 0x7a,
-	0x69, 0x74, 0x61, 0x64, 0x65, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x5f, 0x67, 0x65,
-	0x6e, 0x5f, 0x7a, 0x69, 0x74, 0x61, 0x64, 0x65, 0x6c, 0x2e, 0x76, 0x32, 0x1a, 0x20, 0x67, 0x6f,
-	0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65,
-	0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xad,
-	0x01, 0x0a, 0x07, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x4a, 0x0a, 0x0b, 0x61, 0x75,
-	0x74, 0x68, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x29, 0x2e, 0x7a, 0x69, 0x74, 0x61, 0x64, 0x65, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
-	0x5f, 0x67, 0x65, 0x6e, 0x5f, 0x7a, 0x69, 0x74, 0x61, 0x64, 0x65, 0x6c, 0x2e, 0x76, 0x32, 0x2e,
-	0x41, 0x75, 0x74, 0x68, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x61, 0x75, 0x74, 0x68,
-	0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x56, 0x0a, 0x0d, 0x68, 0x74, 0x74, 0x70, 0x5f, 0x72,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e,
-	0x7a, 0x69, 0x74, 0x61, 0x64, 0x65, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x5f, 0x67,
-	0x65, 0x6e, 0x5f, 0x7a, 0x69, 0x74, 0x61, 0x64, 0x65, 0x6c, 0x2e, 0x76, 0x32, 0x2e, 0x43, 0x75,
-	0x73, 0x74, 0x6f, 0x6d, 0x48, 0x54, 0x54, 0x50, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x52, 0x0c, 0x68, 0x74, 0x74, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4f,
-	0x0a, 0x0a, 0x41, 0x75, 0x74, 0x68, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1e, 0x0a, 0x0a,
-	0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x0a, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x09,
-	0x6f, 0x72, 0x67, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x08, 0x6f, 0x72, 0x67, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x22,
-	0x37, 0x0a, 0x12, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x48, 0x54, 0x54, 0x50, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73,
-	0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x73, 0x75, 0x63,
-	0x63, 0x65, 0x73, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x3a, 0x62, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x12, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x18, 0xd1, 0x86, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x7a, 0x69,
-	0x74, 0x61, 0x64, 0x65, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x5f, 0x67, 0x65, 0x6e,
-	0x5f, 0x7a, 0x69, 0x74, 0x61, 0x64, 0x65, 0x6c, 0x2e, 0x76, 0x32, 0x2e, 0x4f, 0x70, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x36, 0x5a, 0x34,
-	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x7a, 0x69, 0x74, 0x61, 0x64,
-	0x65, 0x6c, 0x2f, 0x7a, 0x69, 0x74, 0x61, 0x64, 0x65, 0x6c, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x67,
-	0x72, 0x70, 0x63, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x2f, 0x76, 0x32, 0x3b, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
+const file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDesc = "" +
+	"\n" +
+	"+zitadel/protoc_gen_zitadel/v2/options.proto\x12\x1dzitadel.protoc_gen_zitadel.v2\x1a google/protobuf/descriptor.proto\"\xad\x01\n" +
+	"\aOptions\x12J\n" +
+	"\vauth_option\x18\x01 \x01(\v2).zitadel.protoc_gen_zitadel.v2.AuthOptionR\n" +
+	"authOption\x12V\n" +
+	"\rhttp_response\x18\x02 \x01(\v21.zitadel.protoc_gen_zitadel.v2.CustomHTTPResponseR\fhttpResponse\"O\n" +
+	"\n" +
+	"AuthOption\x12\x1e\n" +
+	"\n" +
+	"permission\x18\x01 \x01(\tR\n" +
+	"permission\x12\x1b\n" +
+	"\torg_field\x18\x03 \x01(\tR\borgFieldJ\x04\b\x02\x10\x03\"7\n" +
+	"\x12CustomHTTPResponse\x12!\n" +
+	"\fsuccess_code\x18\x01 \x01(\x05R\vsuccessCode:b\n" +
+	"\aoptions\x12\x1e.google.protobuf.MethodOptions\x18ц\x03 \x01(\v2&.zitadel.protoc_gen_zitadel.v2.OptionsR\aoptionsB6Z4github.com/zitadel/zitadel/pkg/grpc/protoc/v2;protocb\x06proto3"
 
 var (
 	file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDescOnce sync.Once
-	file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDescData = file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDesc
+	file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDescData []byte
 )
 
 func file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDescGZIP() []byte {
 	file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDescOnce.Do(func() {
-		file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDescData = protoimpl.X.CompressGZIP(file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDescData)
+		file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDesc), len(file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDesc)))
 	})
 	return file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDescData
 }
@@ -271,7 +246,7 @@ func file_zitadel_protoc_gen_zitadel_v2_options_proto_init() {
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDesc,
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDesc), len(file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDesc)),
 			NumEnums:      0,
 			NumMessages:   3,
 			NumExtensions: 1,
@@ -283,7 +258,6 @@ func file_zitadel_protoc_gen_zitadel_v2_options_proto_init() {
 		ExtensionInfos:    file_zitadel_protoc_gen_zitadel_v2_options_proto_extTypes,
 	}.Build()
 	File_zitadel_protoc_gen_zitadel_v2_options_proto = out.File
-	file_zitadel_protoc_gen_zitadel_v2_options_proto_rawDesc = nil
 	file_zitadel_protoc_gen_zitadel_v2_options_proto_goTypes = nil
 	file_zitadel_protoc_gen_zitadel_v2_options_proto_depIdxs = nil
 }