// Code generated by MockGen. DO NOT EDIT.
// Source: ./internel/dao/dbuser/db_user.go

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

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

	gomock "github.com/golang/mock/gomock"
	entity "github.com/tidbcloud/account/internel/dao/entity"
	gorm "gorm.io/gorm"
)

// MockDBUserDaoIface is a mock of DBUserDaoIface interface.
type MockDBUserDaoIface struct {
	ctrl     *gomock.Controller
	recorder *MockDBUserDaoIfaceMockRecorder
}

// MockDBUserDaoIfaceMockRecorder is the mock recorder for MockDBUserDaoIface.
type MockDBUserDaoIfaceMockRecorder struct {
	mock *MockDBUserDaoIface
}

// NewMockDBUserDaoIface creates a new mock instance.
func NewMockDBUserDaoIface(ctrl *gomock.Controller) *MockDBUserDaoIface {
	mock := &MockDBUserDaoIface{ctrl: ctrl}
	mock.recorder = &MockDBUserDaoIfaceMockRecorder{mock}
	return mock
}

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

// BatchCreateCommandDBUserCluster mocks base method.
func (m *MockDBUserDaoIface) BatchCreateCommandDBUserCluster(ctx context.Context, tx *gorm.DB, objs []entity.CommandDBUserCluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchCreateCommandDBUserCluster", ctx, tx, objs)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchCreateCommandDBUserCluster indicates an expected call of BatchCreateCommandDBUserCluster.
func (mr *MockDBUserDaoIfaceMockRecorder) BatchCreateCommandDBUserCluster(ctx, tx, objs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateCommandDBUserCluster", reflect.TypeOf((*MockDBUserDaoIface)(nil).BatchCreateCommandDBUserCluster), ctx, tx, objs)
}

// CreateCommandClusterKey mocks base method.
func (m *MockDBUserDaoIface) CreateCommandClusterKey(ctx context.Context, tx *gorm.DB, orgId, clusterId uint64, status entity.CommandStatus, action entity.CommandAction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCommandClusterKey", ctx, tx, orgId, clusterId, status, action)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCommandClusterKey indicates an expected call of CreateCommandClusterKey.
func (mr *MockDBUserDaoIfaceMockRecorder) CreateCommandClusterKey(ctx, tx, orgId, clusterId, status, action interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCommandClusterKey", reflect.TypeOf((*MockDBUserDaoIface)(nil).CreateCommandClusterKey), ctx, tx, orgId, clusterId, status, action)
}

// CreateCommandDBUserCluster mocks base method.
func (m *MockDBUserDaoIface) CreateCommandDBUserCluster(ctx context.Context, tx *gorm.DB, clusterId, orgId, operator, userId uint64, dbUser string, status entity.CommandStatus, action entity.CommandAction, targetType entity.ClusterUserTargetType, dbRole string, operatorType entity.ClusterUserTargetType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCommandDBUserCluster", ctx, tx, clusterId, orgId, operator, userId, dbUser, status, action, targetType, dbRole, operatorType)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCommandDBUserCluster indicates an expected call of CreateCommandDBUserCluster.
func (mr *MockDBUserDaoIfaceMockRecorder) CreateCommandDBUserCluster(ctx, tx, clusterId, orgId, operator, userId, dbUser, status, action, targetType, dbRole, operatorType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCommandDBUserCluster", reflect.TypeOf((*MockDBUserDaoIface)(nil).CreateCommandDBUserCluster), ctx, tx, clusterId, orgId, operator, userId, dbUser, status, action, targetType, dbRole, operatorType)
}

// CreateCommandDBUserClusterWithTime mocks base method.
func (m *MockDBUserDaoIface) CreateCommandDBUserClusterWithTime(ctx context.Context, tx *gorm.DB, clusterId, orgId, operator, userId uint64, dbUser string, status entity.CommandStatus, action entity.CommandAction, targetType entity.ClusterUserTargetType, createTime time.Time, dbRole string, operatorType entity.ClusterUserTargetType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCommandDBUserClusterWithTime", ctx, tx, clusterId, orgId, operator, userId, dbUser, status, action, targetType, createTime, dbRole, operatorType)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCommandDBUserClusterWithTime indicates an expected call of CreateCommandDBUserClusterWithTime.
func (mr *MockDBUserDaoIfaceMockRecorder) CreateCommandDBUserClusterWithTime(ctx, tx, clusterId, orgId, operator, userId, dbUser, status, action, targetType, createTime, dbRole, operatorType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCommandDBUserClusterWithTime", reflect.TypeOf((*MockDBUserDaoIface)(nil).CreateCommandDBUserClusterWithTime), ctx, tx, clusterId, orgId, operator, userId, dbUser, status, action, targetType, createTime, dbRole, operatorType)
}

// CreateCommandOrgKey mocks base method.
func (m *MockDBUserDaoIface) CreateCommandOrgKey(ctx context.Context, tx *gorm.DB, orgId uint64, status entity.CommandStatus, action entity.CommandAction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCommandOrgKey", ctx, tx, orgId, status, action)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCommandOrgKey indicates an expected call of CreateCommandOrgKey.
func (mr *MockDBUserDaoIfaceMockRecorder) CreateCommandOrgKey(ctx, tx, orgId, status, action interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCommandOrgKey", reflect.TypeOf((*MockDBUserDaoIface)(nil).CreateCommandOrgKey), ctx, tx, orgId, status, action)
}

// CreateCommandUserAction mocks base method.
func (m *MockDBUserDaoIface) CreateCommandUserAction(ctx context.Context, tx *gorm.DB, operator, userId uint64, email string, orgId, projectId uint64, status entity.CommandStatus, action entity.CommandAction, targetType, operatorType entity.TargetType) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCommandUserAction", ctx, tx, operator, userId, email, orgId, projectId, status, action, targetType, operatorType)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCommandUserAction indicates an expected call of CreateCommandUserAction.
func (mr *MockDBUserDaoIfaceMockRecorder) CreateCommandUserAction(ctx, tx, operator, userId, email, orgId, projectId, status, action, targetType, operatorType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCommandUserAction", reflect.TypeOf((*MockDBUserDaoIface)(nil).CreateCommandUserAction), ctx, tx, operator, userId, email, orgId, projectId, status, action, targetType, operatorType)
}

// CreateOrgKey mocks base method.
func (m *MockDBUserDaoIface) CreateOrgKey(ctx context.Context, tx *gorm.DB, orgId uint64, keyId string, status entity.OrgKeyStatus) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOrgKey", ctx, tx, orgId, keyId, status)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateOrgKey indicates an expected call of CreateOrgKey.
func (mr *MockDBUserDaoIfaceMockRecorder) CreateOrgKey(ctx, tx, orgId, keyId, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrgKey", reflect.TypeOf((*MockDBUserDaoIface)(nil).CreateOrgKey), ctx, tx, orgId, keyId, status)
}

// DeleteCommandClusterKey mocks base method.
func (m *MockDBUserDaoIface) DeleteCommandClusterKey(ctx context.Context, tx *gorm.DB, id uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCommandClusterKey", ctx, tx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCommandClusterKey indicates an expected call of DeleteCommandClusterKey.
func (mr *MockDBUserDaoIfaceMockRecorder) DeleteCommandClusterKey(ctx, tx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCommandClusterKey", reflect.TypeOf((*MockDBUserDaoIface)(nil).DeleteCommandClusterKey), ctx, tx, id)
}

// DeleteCommandOrgKey mocks base method.
func (m *MockDBUserDaoIface) DeleteCommandOrgKey(ctx context.Context, tx *gorm.DB, orgId uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCommandOrgKey", ctx, tx, orgId)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCommandOrgKey indicates an expected call of DeleteCommandOrgKey.
func (mr *MockDBUserDaoIfaceMockRecorder) DeleteCommandOrgKey(ctx, tx, orgId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCommandOrgKey", reflect.TypeOf((*MockDBUserDaoIface)(nil).DeleteCommandOrgKey), ctx, tx, orgId)
}

// DeleteOrgKey mocks base method.
func (m *MockDBUserDaoIface) DeleteOrgKey(ctx context.Context, tx *gorm.DB, orgId uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOrgKey", ctx, tx, orgId)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOrgKey indicates an expected call of DeleteOrgKey.
func (mr *MockDBUserDaoIfaceMockRecorder) DeleteOrgKey(ctx, tx, orgId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrgKey", reflect.TypeOf((*MockDBUserDaoIface)(nil).DeleteOrgKey), ctx, tx, orgId)
}

// ListCommandClusterKeys mocks base method.
func (m *MockDBUserDaoIface) ListCommandClusterKeys(ctx context.Context, tx *gorm.DB, filter CommandClusterKeyFilter) ([]entity.CommandClusterKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommandClusterKeys", ctx, tx, filter)
	ret0, _ := ret[0].([]entity.CommandClusterKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommandClusterKeys indicates an expected call of ListCommandClusterKeys.
func (mr *MockDBUserDaoIfaceMockRecorder) ListCommandClusterKeys(ctx, tx, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandClusterKeys", reflect.TypeOf((*MockDBUserDaoIface)(nil).ListCommandClusterKeys), ctx, tx, filter)
}

// ListCommandDBUserClusters mocks base method.
func (m *MockDBUserDaoIface) ListCommandDBUserClusters(ctx context.Context, tx *gorm.DB, filter CommandDBUserClusterFilter) ([]entity.CommandDBUserCluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommandDBUserClusters", ctx, tx, filter)
	ret0, _ := ret[0].([]entity.CommandDBUserCluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommandDBUserClusters indicates an expected call of ListCommandDBUserClusters.
func (mr *MockDBUserDaoIfaceMockRecorder) ListCommandDBUserClusters(ctx, tx, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandDBUserClusters", reflect.TypeOf((*MockDBUserDaoIface)(nil).ListCommandDBUserClusters), ctx, tx, filter)
}

// ListCommandOrgKeys mocks base method.
func (m *MockDBUserDaoIface) ListCommandOrgKeys(ctx context.Context, tx *gorm.DB, filter CommandOrgKeyFilter) ([]entity.CommandOrgKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommandOrgKeys", ctx, tx, filter)
	ret0, _ := ret[0].([]entity.CommandOrgKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommandOrgKeys indicates an expected call of ListCommandOrgKeys.
func (mr *MockDBUserDaoIfaceMockRecorder) ListCommandOrgKeys(ctx, tx, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandOrgKeys", reflect.TypeOf((*MockDBUserDaoIface)(nil).ListCommandOrgKeys), ctx, tx, filter)
}

// ListCommandUserActions mocks base method.
func (m *MockDBUserDaoIface) ListCommandUserActions(ctx context.Context, tx *gorm.DB, filter CommandUserActionFilter) ([]entity.CommandUserAction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommandUserActions", ctx, tx, filter)
	ret0, _ := ret[0].([]entity.CommandUserAction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommandUserActions indicates an expected call of ListCommandUserActions.
func (mr *MockDBUserDaoIfaceMockRecorder) ListCommandUserActions(ctx, tx, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommandUserActions", reflect.TypeOf((*MockDBUserDaoIface)(nil).ListCommandUserActions), ctx, tx, filter)
}

// ListOrgKeys mocks base method.
func (m *MockDBUserDaoIface) ListOrgKeys(ctx context.Context, tx *gorm.DB, filter OrgKeyFilter) ([]entity.OrgKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOrgKeys", ctx, tx, filter)
	ret0, _ := ret[0].([]entity.OrgKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListOrgKeys indicates an expected call of ListOrgKeys.
func (mr *MockDBUserDaoIfaceMockRecorder) ListOrgKeys(ctx, tx, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOrgKeys", reflect.TypeOf((*MockDBUserDaoIface)(nil).ListOrgKeys), ctx, tx, filter)
}

// UpdateCommandClusterKey mocks base method.
func (m *MockDBUserDaoIface) UpdateCommandClusterKey(ctx context.Context, tx *gorm.DB, e entity.CommandClusterKey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCommandClusterKey", ctx, tx, e)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCommandClusterKey indicates an expected call of UpdateCommandClusterKey.
func (mr *MockDBUserDaoIfaceMockRecorder) UpdateCommandClusterKey(ctx, tx, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCommandClusterKey", reflect.TypeOf((*MockDBUserDaoIface)(nil).UpdateCommandClusterKey), ctx, tx, e)
}

// UpdateCommandDBUserCluster mocks base method.
func (m *MockDBUserDaoIface) UpdateCommandDBUserCluster(ctx context.Context, tx *gorm.DB, c entity.CommandDBUserCluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCommandDBUserCluster", ctx, tx, c)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCommandDBUserCluster indicates an expected call of UpdateCommandDBUserCluster.
func (mr *MockDBUserDaoIfaceMockRecorder) UpdateCommandDBUserCluster(ctx, tx, c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCommandDBUserCluster", reflect.TypeOf((*MockDBUserDaoIface)(nil).UpdateCommandDBUserCluster), ctx, tx, c)
}

// UpdateCommandDBUserPushing mocks base method.
func (m *MockDBUserDaoIface) UpdateCommandDBUserPushing(ctx context.Context, tx *gorm.DB, id uint64, to uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCommandDBUserPushing", ctx, tx, id, to)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCommandDBUserPushing indicates an expected call of UpdateCommandDBUserPushing.
func (mr *MockDBUserDaoIfaceMockRecorder) UpdateCommandDBUserPushing(ctx, tx, id, to interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCommandDBUserPushing", reflect.TypeOf((*MockDBUserDaoIface)(nil).UpdateCommandDBUserPushing), ctx, tx, id, to)
}

// UpdateCommandDBUserPushingByFrom mocks base method.
func (m *MockDBUserDaoIface) UpdateCommandDBUserPushingByFrom(ctx context.Context, tx *gorm.DB, id uint64, from, to uint32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCommandDBUserPushingByFrom", ctx, tx, id, from, to)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCommandDBUserPushingByFrom indicates an expected call of UpdateCommandDBUserPushingByFrom.
func (mr *MockDBUserDaoIfaceMockRecorder) UpdateCommandDBUserPushingByFrom(ctx, tx, id, from, to interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCommandDBUserPushingByFrom", reflect.TypeOf((*MockDBUserDaoIface)(nil).UpdateCommandDBUserPushingByFrom), ctx, tx, id, from, to)
}

// UpdateCommandOrgKey mocks base method.
func (m *MockDBUserDaoIface) UpdateCommandOrgKey(ctx context.Context, tx *gorm.DB, orgId uint64, status entity.CommandStatus, action entity.CommandAction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCommandOrgKey", ctx, tx, orgId, status, action)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCommandOrgKey indicates an expected call of UpdateCommandOrgKey.
func (mr *MockDBUserDaoIfaceMockRecorder) UpdateCommandOrgKey(ctx, tx, orgId, status, action interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCommandOrgKey", reflect.TypeOf((*MockDBUserDaoIface)(nil).UpdateCommandOrgKey), ctx, tx, orgId, status, action)
}

// UpdateCommandUserAction mocks base method.
func (m *MockDBUserDaoIface) UpdateCommandUserAction(ctx context.Context, tx *gorm.DB, id, operator, userId, orgId, projectId uint64, status entity.CommandStatus, action entity.CommandAction) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCommandUserAction", ctx, tx, id, operator, userId, orgId, projectId, status, action)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCommandUserAction indicates an expected call of UpdateCommandUserAction.
func (mr *MockDBUserDaoIfaceMockRecorder) UpdateCommandUserAction(ctx, tx, id, operator, userId, orgId, projectId, status, action interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCommandUserAction", reflect.TypeOf((*MockDBUserDaoIface)(nil).UpdateCommandUserAction), ctx, tx, id, operator, userId, orgId, projectId, status, action)
}

// UpdateOrgKey mocks base method.
func (m *MockDBUserDaoIface) UpdateOrgKey(ctx context.Context, tx *gorm.DB, orgId uint64, keyId string, status entity.OrgKeyStatus) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOrgKey", ctx, tx, orgId, keyId, status)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateOrgKey indicates an expected call of UpdateOrgKey.
func (mr *MockDBUserDaoIfaceMockRecorder) UpdateOrgKey(ctx, tx, orgId, keyId, status interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrgKey", reflect.TypeOf((*MockDBUserDaoIface)(nil).UpdateOrgKey), ctx, tx, orgId, keyId, status)
}