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

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

// MockOrganizationSettingsRepository is a mock of OrganizationSettingsRepository interface.
type MockOrganizationSettingsRepository struct {
	ctrl     *gomock.Controller
	recorder *MockOrganizationSettingsRepositoryMockRecorder
	isgomock struct{}
}

// MockOrganizationSettingsRepositoryMockRecorder is the mock recorder for MockOrganizationSettingsRepository.
type MockOrganizationSettingsRepositoryMockRecorder struct {
	mock *MockOrganizationSettingsRepository
}

// NewMockOrganizationSettingsRepository creates a new mock instance.
func NewMockOrganizationSettingsRepository(ctrl *gomock.Controller) *MockOrganizationSettingsRepository {
	mock := &MockOrganizationSettingsRepository{ctrl: ctrl}
	mock.recorder = &MockOrganizationSettingsRepositoryMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetOrganizationScopedUsernames indicates an expected call of SetOrganizationScopedUsernames.
func (mr *MockOrganizationSettingsRepositoryMockRecorder) SetOrganizationScopedUsernames(value any) *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOrganizationScopedUsernames", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).SetOrganizationScopedUsernames), value)
	return &MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// TypeCondition mocks base method.
func (m *MockOrganizationSettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TypeCondition", typ)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// TypeCondition indicates an expected call of TypeCondition.
func (mr *MockOrganizationSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockOrganizationSettingsRepositoryTypeConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).TypeCondition), typ)
	return &MockOrganizationSettingsRepositoryTypeConditionCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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