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

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

// MockNotificationSettingsRepository is a mock of NotificationSettingsRepository interface.
type MockNotificationSettingsRepository struct {
	ctrl     *gomock.Controller
	recorder *MockNotificationSettingsRepositoryMockRecorder
	isgomock struct{}
}

// MockNotificationSettingsRepositoryMockRecorder is the mock recorder for MockNotificationSettingsRepository.
type MockNotificationSettingsRepositoryMockRecorder struct {
	mock *MockNotificationSettingsRepository
}

// NewMockNotificationSettingsRepository creates a new mock instance.
func NewMockNotificationSettingsRepository(ctrl *gomock.Controller) *MockNotificationSettingsRepository {
	mock := &MockNotificationSettingsRepository{ctrl: ctrl}
	mock.recorder = &MockNotificationSettingsRepositoryMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetPasswordChange indicates an expected call of SetPasswordChange.
func (mr *MockNotificationSettingsRepositoryMockRecorder) SetPasswordChange(value any) *MockNotificationSettingsRepositorySetPasswordChangeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasswordChange", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).SetPasswordChange), value)
	return &MockNotificationSettingsRepositorySetPasswordChangeCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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