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

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

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

// MockPasswordComplexitySettingsRepository is a mock of PasswordComplexitySettingsRepository interface.
type MockPasswordComplexitySettingsRepository struct {
	ctrl     *gomock.Controller
	recorder *MockPasswordComplexitySettingsRepositoryMockRecorder
	isgomock struct{}
}

// MockPasswordComplexitySettingsRepositoryMockRecorder is the mock recorder for MockPasswordComplexitySettingsRepository.
type MockPasswordComplexitySettingsRepositoryMockRecorder struct {
	mock *MockPasswordComplexitySettingsRepository
}

// NewMockPasswordComplexitySettingsRepository creates a new mock instance.
func NewMockPasswordComplexitySettingsRepository(ctrl *gomock.Controller) *MockPasswordComplexitySettingsRepository {
	mock := &MockPasswordComplexitySettingsRepository{ctrl: ctrl}
	mock.recorder = &MockPasswordComplexitySettingsRepositoryMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetHasLowercase indicates an expected call of SetHasLowercase.
func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetHasLowercase(value any) *MockPasswordComplexitySettingsRepositorySetHasLowercaseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHasLowercase", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetHasLowercase), value)
	return &MockPasswordComplexitySettingsRepositorySetHasLowercaseCall{Call: call}
}

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

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

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

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

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

// SetHasNumber indicates an expected call of SetHasNumber.
func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetHasNumber(value any) *MockPasswordComplexitySettingsRepositorySetHasNumberCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHasNumber", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetHasNumber), value)
	return &MockPasswordComplexitySettingsRepositorySetHasNumberCall{Call: call}
}

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

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

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

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

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

// SetHasSymbol indicates an expected call of SetHasSymbol.
func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetHasSymbol(value any) *MockPasswordComplexitySettingsRepositorySetHasSymbolCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHasSymbol", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetHasSymbol), value)
	return &MockPasswordComplexitySettingsRepositorySetHasSymbolCall{Call: call}
}

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

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

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

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

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

// SetHasUppercase indicates an expected call of SetHasUppercase.
func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetHasUppercase(value any) *MockPasswordComplexitySettingsRepositorySetHasUppercaseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHasUppercase", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetHasUppercase), value)
	return &MockPasswordComplexitySettingsRepositorySetHasUppercaseCall{Call: call}
}

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

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

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

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

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

// SetMinLength indicates an expected call of SetMinLength.
func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetMinLength(value any) *MockPasswordComplexitySettingsRepositorySetMinLengthCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMinLength", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetMinLength), value)
	return &MockPasswordComplexitySettingsRepositorySetMinLengthCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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