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

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

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

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

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

// MockSecretGeneratorSettingsRepository is a mock of SecretGeneratorSettingsRepository interface.
type MockSecretGeneratorSettingsRepository struct {
	ctrl     *gomock.Controller
	recorder *MockSecretGeneratorSettingsRepositoryMockRecorder
	isgomock struct{}
}

// MockSecretGeneratorSettingsRepositoryMockRecorder is the mock recorder for MockSecretGeneratorSettingsRepository.
type MockSecretGeneratorSettingsRepositoryMockRecorder struct {
	mock *MockSecretGeneratorSettingsRepository
}

// NewMockSecretGeneratorSettingsRepository creates a new mock instance.
func NewMockSecretGeneratorSettingsRepository(ctrl *gomock.Controller) *MockSecretGeneratorSettingsRepository {
	mock := &MockSecretGeneratorSettingsRepository{ctrl: ctrl}
	mock.recorder = &MockSecretGeneratorSettingsRepositoryMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// IDCondition indicates an expected call of IDCondition.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) IDCondition(id any) *MockSecretGeneratorSettingsRepositoryIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).IDCondition), id)
	return &MockSecretGeneratorSettingsRepositoryIDConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockSecretGeneratorSettingsRepositoryInstanceIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).InstanceIDCondition), id)
	return &MockSecretGeneratorSettingsRepositoryInstanceIDConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// OrganizationIDColumn indicates an expected call of OrganizationIDColumn.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockSecretGeneratorSettingsRepositoryOrganizationIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).OrganizationIDColumn))
	return &MockSecretGeneratorSettingsRepositoryOrganizationIDColumnCall{Call: call}
}

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

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

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

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

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

// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockSecretGeneratorSettingsRepositoryOrganizationIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).OrganizationIDCondition), id)
	return &MockSecretGeneratorSettingsRepositoryOrganizationIDConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Set indicates an expected call of Set.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockSecretGeneratorSettingsRepositorySetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).Set), ctx, client, settings)
	return &MockSecretGeneratorSettingsRepositorySetCall{Call: call}
}

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

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

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

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

// SetClientSecret mocks base method.
func (m *MockSecretGeneratorSettingsRepository) SetClientSecret(value domain.ClientSecretAttributes) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetClientSecret", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetClientSecret indicates an expected call of SetClientSecret.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) SetClientSecret(value any) *MockSecretGeneratorSettingsRepositorySetClientSecretCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetClientSecret", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).SetClientSecret), value)
	return &MockSecretGeneratorSettingsRepositorySetClientSecretCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockSecretGeneratorSettingsRepositorySetClientSecretCall) Return(arg0 json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetClientSecretCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSecretGeneratorSettingsRepositorySetClientSecretCall) Do(f func(domain.ClientSecretAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetClientSecretCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecretGeneratorSettingsRepositorySetClientSecretCall) DoAndReturn(f func(domain.ClientSecretAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetClientSecretCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetDomainVerification mocks base method.
func (m *MockSecretGeneratorSettingsRepository) SetDomainVerification(value domain.DomainVerificationAttributes) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDomainVerification", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetDomainVerification indicates an expected call of SetDomainVerification.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) SetDomainVerification(value any) *MockSecretGeneratorSettingsRepositorySetDomainVerificationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDomainVerification", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).SetDomainVerification), value)
	return &MockSecretGeneratorSettingsRepositorySetDomainVerificationCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockSecretGeneratorSettingsRepositorySetDomainVerificationCall) Return(arg0 json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetDomainVerificationCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSecretGeneratorSettingsRepositorySetDomainVerificationCall) Do(f func(domain.DomainVerificationAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetDomainVerificationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecretGeneratorSettingsRepositorySetDomainVerificationCall) DoAndReturn(f func(domain.DomainVerificationAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetDomainVerificationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetEmailVerificationCode mocks base method.
func (m *MockSecretGeneratorSettingsRepository) SetEmailVerificationCode(value domain.EmailVerificationCodeAttributes) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetEmailVerificationCode", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetEmailVerificationCode indicates an expected call of SetEmailVerificationCode.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) SetEmailVerificationCode(value any) *MockSecretGeneratorSettingsRepositorySetEmailVerificationCodeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEmailVerificationCode", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).SetEmailVerificationCode), value)
	return &MockSecretGeneratorSettingsRepositorySetEmailVerificationCodeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockSecretGeneratorSettingsRepositorySetEmailVerificationCodeCall) Return(arg0 json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetEmailVerificationCodeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSecretGeneratorSettingsRepositorySetEmailVerificationCodeCall) Do(f func(domain.EmailVerificationCodeAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetEmailVerificationCodeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecretGeneratorSettingsRepositorySetEmailVerificationCodeCall) DoAndReturn(f func(domain.EmailVerificationCodeAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetEmailVerificationCodeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetInitializeUserCode mocks base method.
func (m *MockSecretGeneratorSettingsRepository) SetInitializeUserCode(value domain.InitializeUserCodeAttributes) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInitializeUserCode", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetInitializeUserCode indicates an expected call of SetInitializeUserCode.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) SetInitializeUserCode(value any) *MockSecretGeneratorSettingsRepositorySetInitializeUserCodeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInitializeUserCode", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).SetInitializeUserCode), value)
	return &MockSecretGeneratorSettingsRepositorySetInitializeUserCodeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockSecretGeneratorSettingsRepositorySetInitializeUserCodeCall) Return(arg0 json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetInitializeUserCodeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSecretGeneratorSettingsRepositorySetInitializeUserCodeCall) Do(f func(domain.InitializeUserCodeAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetInitializeUserCodeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecretGeneratorSettingsRepositorySetInitializeUserCodeCall) DoAndReturn(f func(domain.InitializeUserCodeAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetInitializeUserCodeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetOTPEmail mocks base method.
func (m *MockSecretGeneratorSettingsRepository) SetOTPEmail(value domain.OTPEmailAttributes) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOTPEmail", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetOTPEmail indicates an expected call of SetOTPEmail.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) SetOTPEmail(value any) *MockSecretGeneratorSettingsRepositorySetOTPEmailCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOTPEmail", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).SetOTPEmail), value)
	return &MockSecretGeneratorSettingsRepositorySetOTPEmailCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockSecretGeneratorSettingsRepositorySetOTPEmailCall) Return(arg0 json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetOTPEmailCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSecretGeneratorSettingsRepositorySetOTPEmailCall) Do(f func(domain.OTPEmailAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetOTPEmailCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecretGeneratorSettingsRepositorySetOTPEmailCall) DoAndReturn(f func(domain.OTPEmailAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetOTPEmailCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetOTPSMS mocks base method.
func (m *MockSecretGeneratorSettingsRepository) SetOTPSMS(value domain.OTPSMSAttributes) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOTPSMS", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetOTPSMS indicates an expected call of SetOTPSMS.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) SetOTPSMS(value any) *MockSecretGeneratorSettingsRepositorySetOTPSMSCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOTPSMS", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).SetOTPSMS), value)
	return &MockSecretGeneratorSettingsRepositorySetOTPSMSCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockSecretGeneratorSettingsRepositorySetOTPSMSCall) Return(arg0 json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetOTPSMSCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSecretGeneratorSettingsRepositorySetOTPSMSCall) Do(f func(domain.OTPSMSAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetOTPSMSCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecretGeneratorSettingsRepositorySetOTPSMSCall) DoAndReturn(f func(domain.OTPSMSAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetOTPSMSCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPasswordVerificationCode mocks base method.
func (m *MockSecretGeneratorSettingsRepository) SetPasswordVerificationCode(value domain.PasswordVerificationCodeAttributes) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasswordVerificationCode", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetPasswordVerificationCode indicates an expected call of SetPasswordVerificationCode.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) SetPasswordVerificationCode(value any) *MockSecretGeneratorSettingsRepositorySetPasswordVerificationCodeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasswordVerificationCode", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).SetPasswordVerificationCode), value)
	return &MockSecretGeneratorSettingsRepositorySetPasswordVerificationCodeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockSecretGeneratorSettingsRepositorySetPasswordVerificationCodeCall) Return(arg0 json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetPasswordVerificationCodeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSecretGeneratorSettingsRepositorySetPasswordVerificationCodeCall) Do(f func(domain.PasswordVerificationCodeAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetPasswordVerificationCodeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecretGeneratorSettingsRepositorySetPasswordVerificationCodeCall) DoAndReturn(f func(domain.PasswordVerificationCodeAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetPasswordVerificationCodeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPasswordlessInitCode mocks base method.
func (m *MockSecretGeneratorSettingsRepository) SetPasswordlessInitCode(value domain.PasswordlessInitCodeAttributes) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPasswordlessInitCode", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetPasswordlessInitCode indicates an expected call of SetPasswordlessInitCode.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) SetPasswordlessInitCode(value any) *MockSecretGeneratorSettingsRepositorySetPasswordlessInitCodeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasswordlessInitCode", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).SetPasswordlessInitCode), value)
	return &MockSecretGeneratorSettingsRepositorySetPasswordlessInitCodeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockSecretGeneratorSettingsRepositorySetPasswordlessInitCodeCall) Return(arg0 json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetPasswordlessInitCodeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSecretGeneratorSettingsRepositorySetPasswordlessInitCodeCall) Do(f func(domain.PasswordlessInitCodeAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetPasswordlessInitCodeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecretGeneratorSettingsRepositorySetPasswordlessInitCodeCall) DoAndReturn(f func(domain.PasswordlessInitCodeAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetPasswordlessInitCodeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPhoneVerificationCode mocks base method.
func (m *MockSecretGeneratorSettingsRepository) SetPhoneVerificationCode(value domain.PhoneVerificationCodeAttributes) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPhoneVerificationCode", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetPhoneVerificationCode indicates an expected call of SetPhoneVerificationCode.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) SetPhoneVerificationCode(value any) *MockSecretGeneratorSettingsRepositorySetPhoneVerificationCodeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPhoneVerificationCode", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).SetPhoneVerificationCode), value)
	return &MockSecretGeneratorSettingsRepositorySetPhoneVerificationCodeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockSecretGeneratorSettingsRepositorySetPhoneVerificationCodeCall) Return(arg0 json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetPhoneVerificationCodeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSecretGeneratorSettingsRepositorySetPhoneVerificationCodeCall) Do(f func(domain.PhoneVerificationCodeAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetPhoneVerificationCodeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecretGeneratorSettingsRepositorySetPhoneVerificationCodeCall) DoAndReturn(f func(domain.PhoneVerificationCodeAttributes) json.JsonUpdate) *MockSecretGeneratorSettingsRepositorySetPhoneVerificationCodeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetSettingFields mocks base method.
func (m *MockSecretGeneratorSettingsRepository) SetSettingFields(value domain.SecretGeneratorSettingsAttributes) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSettingFields", value)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetSettingFields indicates an expected call of SetSettingFields.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockSecretGeneratorSettingsRepositorySetSettingFieldsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).SetSettingFields), value)
	return &MockSecretGeneratorSettingsRepositorySetSettingFieldsCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// SettingsColumn indicates an expected call of SettingsColumn.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) SettingsColumn() *MockSecretGeneratorSettingsRepositorySettingsColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).SettingsColumn))
	return &MockSecretGeneratorSettingsRepositorySettingsColumnCall{Call: call}
}

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

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

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

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

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

// StateColumn indicates an expected call of StateColumn.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) StateColumn() *MockSecretGeneratorSettingsRepositoryStateColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).StateColumn))
	return &MockSecretGeneratorSettingsRepositoryStateColumnCall{Call: call}
}

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

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

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

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

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

// TypeColumn indicates an expected call of TypeColumn.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) TypeColumn() *MockSecretGeneratorSettingsRepositoryTypeColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).TypeColumn))
	return &MockSecretGeneratorSettingsRepositoryTypeColumnCall{Call: call}
}

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

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

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

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

// TypeCondition mocks base method.
func (m *MockSecretGeneratorSettingsRepository) 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 *MockSecretGeneratorSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockSecretGeneratorSettingsRepositoryTypeConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).TypeCondition), typ)
	return &MockSecretGeneratorSettingsRepositoryTypeConditionCall{Call: call}
}

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

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

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

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

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

// UniqueColumns indicates an expected call of UniqueColumns.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) UniqueColumns() *MockSecretGeneratorSettingsRepositoryUniqueColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).UniqueColumns))
	return &MockSecretGeneratorSettingsRepositoryUniqueColumnsCall{Call: call}
}

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

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

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

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

// UniqueCondition mocks base method.
func (m *MockSecretGeneratorSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// UniqueCondition indicates an expected call of UniqueCondition.
func (mr *MockSecretGeneratorSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockSecretGeneratorSettingsRepositoryUniqueConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockSecretGeneratorSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state)
	return &MockSecretGeneratorSettingsRepositoryUniqueConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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