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

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

// 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"
)

// MockSecuritySettingsRepository is a mock of SecuritySettingsRepository interface.
type MockSecuritySettingsRepository struct {
	ctrl     *gomock.Controller
	recorder *MockSecuritySettingsRepositoryMockRecorder
	isgomock struct{}
}

// MockSecuritySettingsRepositoryMockRecorder is the mock recorder for MockSecuritySettingsRepository.
type MockSecuritySettingsRepositoryMockRecorder struct {
	mock *MockSecuritySettingsRepository
}

// NewMockSecuritySettingsRepository creates a new mock instance.
func NewMockSecuritySettingsRepository(ctrl *gomock.Controller) *MockSecuritySettingsRepository {
	mock := &MockSecuritySettingsRepository{ctrl: ctrl}
	mock.recorder = &MockSecuritySettingsRepositoryMockRecorder{mock}
	return mock
}

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

// CreatedAtColumn mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) CreatedAtColumn() *MockSecuritySettingsRepositoryCreatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).CreatedAtColumn))
	return &MockSecuritySettingsRepositoryCreatedAtColumnCall{Call: call}
}

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

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

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

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

// Delete mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockSecuritySettingsRepositoryDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).Delete), ctx, client, condition)
	return &MockSecuritySettingsRepositoryDeleteCall{Call: call}
}

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

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

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

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

// Get mocks base method.
func (m *MockSecuritySettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.SecuritySettings, 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.SecuritySettings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// IDColumn mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) IDColumn() *MockSecuritySettingsRepositoryIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).IDColumn))
	return &MockSecuritySettingsRepositoryIDColumnCall{Call: call}
}

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

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

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

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

// IDCondition mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) IDCondition(id any) *MockSecuritySettingsRepositoryIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).IDCondition), id)
	return &MockSecuritySettingsRepositoryIDConditionCall{Call: call}
}

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

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

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

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

// InstanceIDColumn mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) InstanceIDColumn() *MockSecuritySettingsRepositoryInstanceIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).InstanceIDColumn))
	return &MockSecuritySettingsRepositoryInstanceIDColumnCall{Call: call}
}

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

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

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

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

// InstanceIDCondition mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockSecuritySettingsRepositoryInstanceIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).InstanceIDCondition), id)
	return &MockSecuritySettingsRepositoryInstanceIDConditionCall{Call: call}
}

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

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

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

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

// List mocks base method.
func (m *MockSecuritySettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.SecuritySettings, 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.SecuritySettings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// OrganizationIDColumn mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) OrganizationIDColumn() *MockSecuritySettingsRepositoryOrganizationIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).OrganizationIDColumn))
	return &MockSecuritySettingsRepositoryOrganizationIDColumnCall{Call: call}
}

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

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

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

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

// OrganizationIDCondition mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockSecuritySettingsRepositoryOrganizationIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).OrganizationIDCondition), id)
	return &MockSecuritySettingsRepositoryOrganizationIDConditionCall{Call: call}
}

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

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

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

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

// PrimaryKeyColumns mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).PrimaryKeyColumns))
	return &MockSecuritySettingsRepositoryPrimaryKeyColumnsCall{Call: call}
}

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

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

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

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

// PrimaryKeyCondition mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockSecuritySettingsRepositoryPrimaryKeyConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).PrimaryKeyCondition), instanceID, id)
	return &MockSecuritySettingsRepositoryPrimaryKeyConditionCall{Call: call}
}

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

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

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

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

// Set mocks base method.
func (m *MockSecuritySettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.SecuritySettings) 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 *MockSecuritySettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockSecuritySettingsRepositorySetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).Set), ctx, client, settings)
	return &MockSecuritySettingsRepositorySetCall{Call: call}
}

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

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

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

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

// SetAllowedOrigins mocks base method.
func (m *MockSecuritySettingsRepository) SetAllowedOrigins(values []string) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAllowedOrigins", values)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetAllowedOrigins indicates an expected call of SetAllowedOrigins.
func (mr *MockSecuritySettingsRepositoryMockRecorder) SetAllowedOrigins(values any) *MockSecuritySettingsRepositorySetAllowedOriginsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowedOrigins", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetAllowedOrigins), values)
	return &MockSecuritySettingsRepositorySetAllowedOriginsCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockSecuritySettingsRepositorySetAllowedOriginsCall) Do(f func([]string) json.JsonUpdate) *MockSecuritySettingsRepositorySetAllowedOriginsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecuritySettingsRepositorySetAllowedOriginsCall) DoAndReturn(f func([]string) json.JsonUpdate) *MockSecuritySettingsRepositorySetAllowedOriginsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetEnableIframeEmbedding indicates an expected call of SetEnableIframeEmbedding.
func (mr *MockSecuritySettingsRepositoryMockRecorder) SetEnableIframeEmbedding(value any) *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEnableIframeEmbedding", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetEnableIframeEmbedding), value)
	return &MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall) Do(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetEnableImpersonation indicates an expected call of SetEnableImpersonation.
func (mr *MockSecuritySettingsRepositoryMockRecorder) SetEnableImpersonation(value any) *MockSecuritySettingsRepositorySetEnableImpersonationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEnableImpersonation", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetEnableImpersonation), value)
	return &MockSecuritySettingsRepositorySetEnableImpersonationCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockSecuritySettingsRepositorySetEnableImpersonationCall) Do(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableImpersonationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSecuritySettingsRepositorySetEnableImpersonationCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableImpersonationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetSettingFields mocks base method.
func (m *MockSecuritySettingsRepository) SetSettingFields(value domain.SecuritySettingsAttributes) 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 *MockSecuritySettingsRepositoryMockRecorder) SetSettingFields(value any) *MockSecuritySettingsRepositorySetSettingFieldsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetSettingFields), value)
	return &MockSecuritySettingsRepositorySetSettingFieldsCall{Call: call}
}

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

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

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

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

// SetUpdatedAt mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockSecuritySettingsRepositorySetUpdatedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetUpdatedAt), updatedAt)
	return &MockSecuritySettingsRepositorySetUpdatedAtCall{Call: call}
}

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

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

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

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

// SettingsColumn mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) SettingsColumn() *MockSecuritySettingsRepositorySettingsColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SettingsColumn))
	return &MockSecuritySettingsRepositorySettingsColumnCall{Call: call}
}

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

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

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

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

// StateColumn mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) StateColumn() *MockSecuritySettingsRepositoryStateColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).StateColumn))
	return &MockSecuritySettingsRepositoryStateColumnCall{Call: call}
}

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

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

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

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

// TypeColumn mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) TypeColumn() *MockSecuritySettingsRepositoryTypeColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).TypeColumn))
	return &MockSecuritySettingsRepositoryTypeColumnCall{Call: call}
}

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

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

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

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

// UniqueColumns mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) UniqueColumns() *MockSecuritySettingsRepositoryUniqueColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).UniqueColumns))
	return &MockSecuritySettingsRepositoryUniqueColumnsCall{Call: call}
}

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

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

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

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

// UniqueCondition mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockSecuritySettingsRepositoryUniqueConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state)
	return &MockSecuritySettingsRepositoryUniqueConditionCall{Call: call}
}

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

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

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

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

// UpdatedAtColumn mocks base method.
func (m *MockSecuritySettingsRepository) 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 *MockSecuritySettingsRepositoryMockRecorder) UpdatedAtColumn() *MockSecuritySettingsRepositoryUpdatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).UpdatedAtColumn))
	return &MockSecuritySettingsRepositoryUpdatedAtColumnCall{Call: call}
}

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

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

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

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