// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/zcore/model/model.go
//
// Generated by this command:
//
//	mockgen -source pkg/zcore/model/model.go -destination pkg/zcore/model/mock_gen.go -package model
//

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

import (
	context "context"
	reflect "reflect"

	apigen "github.com/cloudcarver/anclax/pkg/zgen/apigen"
	querier "github.com/cloudcarver/anclax/pkg/zgen/querier"
	pgx "github.com/jackc/pgx/v5"
	gomock "go.uber.org/mock/gomock"
)

// MockModelInterface is a mock of ModelInterface interface.
type MockModelInterface struct {
	ctrl     *gomock.Controller
	recorder *MockModelInterfaceMockRecorder
	isgomock struct{}
}

// MockModelInterfaceMockRecorder is the mock recorder for MockModelInterface.
type MockModelInterfaceMockRecorder struct {
	mock *MockModelInterface
}

// NewMockModelInterface creates a new mock instance.
func NewMockModelInterface(ctrl *gomock.Controller) *MockModelInterface {
	mock := &MockModelInterface{ctrl: ctrl}
	mock.recorder = &MockModelInterfaceMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockModelInterface) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

// Close indicates an expected call of Close.
func (mr *MockModelInterfaceMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockModelInterface)(nil).Close))
}

// CreateKeyPair mocks base method.
func (m *MockModelInterface) CreateKeyPair(ctx context.Context, arg querier.CreateKeyPairParams) (*querier.AnclaxAccessKeyPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateKeyPair", ctx, arg)
	ret0, _ := ret[0].(*querier.AnclaxAccessKeyPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateKeyPair indicates an expected call of CreateKeyPair.
func (mr *MockModelInterfaceMockRecorder) CreateKeyPair(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPair", reflect.TypeOf((*MockModelInterface)(nil).CreateKeyPair), ctx, arg)
}

// CreateOpaqueKey mocks base method.
func (m *MockModelInterface) CreateOpaqueKey(ctx context.Context, arg querier.CreateOpaqueKeyParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOpaqueKey", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateOpaqueKey indicates an expected call of CreateOpaqueKey.
func (mr *MockModelInterfaceMockRecorder) CreateOpaqueKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpaqueKey", reflect.TypeOf((*MockModelInterface)(nil).CreateOpaqueKey), ctx, arg)
}

// CreateOrg mocks base method.
func (m *MockModelInterface) CreateOrg(ctx context.Context, name string) (*querier.AnclaxOrg, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOrg", ctx, name)
	ret0, _ := ret[0].(*querier.AnclaxOrg)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateOrg indicates an expected call of CreateOrg.
func (mr *MockModelInterfaceMockRecorder) CreateOrg(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrg", reflect.TypeOf((*MockModelInterface)(nil).CreateOrg), ctx, name)
}

// CreateTask mocks base method.
func (m *MockModelInterface) CreateTask(ctx context.Context, arg querier.CreateTaskParams) (*querier.AnclaxTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTask", ctx, arg)
	ret0, _ := ret[0].(*querier.AnclaxTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTask indicates an expected call of CreateTask.
func (mr *MockModelInterfaceMockRecorder) CreateTask(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTask", reflect.TypeOf((*MockModelInterface)(nil).CreateTask), ctx, arg)
}

// CreateUser mocks base method.
func (m *MockModelInterface) CreateUser(ctx context.Context, arg querier.CreateUserParams) (*querier.AnclaxUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUser", ctx, arg)
	ret0, _ := ret[0].(*querier.AnclaxUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateUser indicates an expected call of CreateUser.
func (mr *MockModelInterfaceMockRecorder) CreateUser(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUser", reflect.TypeOf((*MockModelInterface)(nil).CreateUser), ctx, arg)
}

// DeleteKeyPair mocks base method.
func (m *MockModelInterface) DeleteKeyPair(ctx context.Context, accessKey string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteKeyPair", ctx, accessKey)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteKeyPair indicates an expected call of DeleteKeyPair.
func (mr *MockModelInterfaceMockRecorder) DeleteKeyPair(ctx, accessKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPair", reflect.TypeOf((*MockModelInterface)(nil).DeleteKeyPair), ctx, accessKey)
}

// DeleteOpaqueKey mocks base method.
func (m *MockModelInterface) DeleteOpaqueKey(ctx context.Context, id int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOpaqueKey", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOpaqueKey indicates an expected call of DeleteOpaqueKey.
func (mr *MockModelInterfaceMockRecorder) DeleteOpaqueKey(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpaqueKey", reflect.TypeOf((*MockModelInterface)(nil).DeleteOpaqueKey), ctx, id)
}

// DeleteOpaqueKeys mocks base method.
func (m *MockModelInterface) DeleteOpaqueKeys(ctx context.Context, userID int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOpaqueKeys", ctx, userID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOpaqueKeys indicates an expected call of DeleteOpaqueKeys.
func (mr *MockModelInterfaceMockRecorder) DeleteOpaqueKeys(ctx, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpaqueKeys", reflect.TypeOf((*MockModelInterface)(nil).DeleteOpaqueKeys), ctx, userID)
}

// DeleteUserByName mocks base method.
func (m *MockModelInterface) DeleteUserByName(ctx context.Context, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserByName", ctx, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteUserByName indicates an expected call of DeleteUserByName.
func (mr *MockModelInterfaceMockRecorder) DeleteUserByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserByName", reflect.TypeOf((*MockModelInterface)(nil).DeleteUserByName), ctx, name)
}

// GetKeyPair mocks base method.
func (m *MockModelInterface) GetKeyPair(ctx context.Context, accessKey string) (*querier.AnclaxAccessKeyPair, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetKeyPair", ctx, accessKey)
	ret0, _ := ret[0].(*querier.AnclaxAccessKeyPair)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetKeyPair indicates an expected call of GetKeyPair.
func (mr *MockModelInterfaceMockRecorder) GetKeyPair(ctx, accessKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyPair", reflect.TypeOf((*MockModelInterface)(nil).GetKeyPair), ctx, accessKey)
}

// GetOpaqueKey mocks base method.
func (m *MockModelInterface) GetOpaqueKey(ctx context.Context, id int64) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOpaqueKey", ctx, id)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOpaqueKey indicates an expected call of GetOpaqueKey.
func (mr *MockModelInterfaceMockRecorder) GetOpaqueKey(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpaqueKey", reflect.TypeOf((*MockModelInterface)(nil).GetOpaqueKey), ctx, id)
}

// GetOrg mocks base method.
func (m *MockModelInterface) GetOrg(ctx context.Context, id int32) (*querier.AnclaxOrg, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrg", ctx, id)
	ret0, _ := ret[0].(*querier.AnclaxOrg)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrg indicates an expected call of GetOrg.
func (mr *MockModelInterfaceMockRecorder) GetOrg(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrg", reflect.TypeOf((*MockModelInterface)(nil).GetOrg), ctx, id)
}

// GetOrgByName mocks base method.
func (m *MockModelInterface) GetOrgByName(ctx context.Context, name string) (*querier.AnclaxOrg, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrgByName", ctx, name)
	ret0, _ := ret[0].(*querier.AnclaxOrg)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrgByName indicates an expected call of GetOrgByName.
func (mr *MockModelInterfaceMockRecorder) GetOrgByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgByName", reflect.TypeOf((*MockModelInterface)(nil).GetOrgByName), ctx, name)
}

// GetTaskByID mocks base method.
func (m *MockModelInterface) GetTaskByID(ctx context.Context, id int32) (*querier.AnclaxTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskByID", ctx, id)
	ret0, _ := ret[0].(*querier.AnclaxTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTaskByID indicates an expected call of GetTaskByID.
func (mr *MockModelInterfaceMockRecorder) GetTaskByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskByID", reflect.TypeOf((*MockModelInterface)(nil).GetTaskByID), ctx, id)
}

// GetTaskByUniqueTag mocks base method.
func (m *MockModelInterface) GetTaskByUniqueTag(ctx context.Context, uniqueTag *string) (*querier.AnclaxTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskByUniqueTag", ctx, uniqueTag)
	ret0, _ := ret[0].(*querier.AnclaxTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTaskByUniqueTag indicates an expected call of GetTaskByUniqueTag.
func (mr *MockModelInterfaceMockRecorder) GetTaskByUniqueTag(ctx, uniqueTag any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskByUniqueTag", reflect.TypeOf((*MockModelInterface)(nil).GetTaskByUniqueTag), ctx, uniqueTag)
}

// GetUser mocks base method.
func (m *MockModelInterface) GetUser(ctx context.Context, id int32) (*querier.AnclaxUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUser", ctx, id)
	ret0, _ := ret[0].(*querier.AnclaxUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUser indicates an expected call of GetUser.
func (mr *MockModelInterfaceMockRecorder) GetUser(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUser", reflect.TypeOf((*MockModelInterface)(nil).GetUser), ctx, id)
}

// GetUserByName mocks base method.
func (m *MockModelInterface) GetUserByName(ctx context.Context, name string) (*querier.AnclaxUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserByName", ctx, name)
	ret0, _ := ret[0].(*querier.AnclaxUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserByName indicates an expected call of GetUserByName.
func (mr *MockModelInterfaceMockRecorder) GetUserByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByName", reflect.TypeOf((*MockModelInterface)(nil).GetUserByName), ctx, name)
}

// GetUserDefaultOrg mocks base method.
func (m *MockModelInterface) GetUserDefaultOrg(ctx context.Context, userID int32) (int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserDefaultOrg", ctx, userID)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserDefaultOrg indicates an expected call of GetUserDefaultOrg.
func (mr *MockModelInterfaceMockRecorder) GetUserDefaultOrg(ctx, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserDefaultOrg", reflect.TypeOf((*MockModelInterface)(nil).GetUserDefaultOrg), ctx, userID)
}

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

// InTransaction indicates an expected call of InTransaction.
func (mr *MockModelInterfaceMockRecorder) InTransaction() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InTransaction", reflect.TypeOf((*MockModelInterface)(nil).InTransaction))
}

// IncrementAttempts mocks base method.
func (m *MockModelInterface) IncrementAttempts(ctx context.Context, id int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrementAttempts", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// IncrementAttempts indicates an expected call of IncrementAttempts.
func (mr *MockModelInterfaceMockRecorder) IncrementAttempts(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementAttempts", reflect.TypeOf((*MockModelInterface)(nil).IncrementAttempts), ctx, id)
}

// InsertEvent mocks base method.
func (m *MockModelInterface) InsertEvent(ctx context.Context, spec apigen.EventSpec) (*querier.AnclaxEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertEvent", ctx, spec)
	ret0, _ := ret[0].(*querier.AnclaxEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertEvent indicates an expected call of InsertEvent.
func (mr *MockModelInterfaceMockRecorder) InsertEvent(ctx, spec any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertEvent", reflect.TypeOf((*MockModelInterface)(nil).InsertEvent), ctx, spec)
}

// InsertOrgOwner mocks base method.
func (m *MockModelInterface) InsertOrgOwner(ctx context.Context, arg querier.InsertOrgOwnerParams) (*querier.AnclaxOrgOwner, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrgOwner", ctx, arg)
	ret0, _ := ret[0].(*querier.AnclaxOrgOwner)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertOrgOwner indicates an expected call of InsertOrgOwner.
func (mr *MockModelInterfaceMockRecorder) InsertOrgOwner(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOrgOwner", reflect.TypeOf((*MockModelInterface)(nil).InsertOrgOwner), ctx, arg)
}

// InsertOrgUser mocks base method.
func (m *MockModelInterface) InsertOrgUser(ctx context.Context, arg querier.InsertOrgUserParams) (*querier.AnclaxOrgUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrgUser", ctx, arg)
	ret0, _ := ret[0].(*querier.AnclaxOrgUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertOrgUser indicates an expected call of InsertOrgUser.
func (mr *MockModelInterfaceMockRecorder) InsertOrgUser(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOrgUser", reflect.TypeOf((*MockModelInterface)(nil).InsertOrgUser), ctx, arg)
}

// IsUsernameExists mocks base method.
func (m *MockModelInterface) IsUsernameExists(ctx context.Context, name string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsUsernameExists", ctx, name)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsUsernameExists indicates an expected call of IsUsernameExists.
func (mr *MockModelInterfaceMockRecorder) IsUsernameExists(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUsernameExists", reflect.TypeOf((*MockModelInterface)(nil).IsUsernameExists), ctx, name)
}

// ListAllPendingTasks mocks base method.
func (m *MockModelInterface) ListAllPendingTasks(ctx context.Context) ([]*querier.AnclaxTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllPendingTasks", ctx)
	ret0, _ := ret[0].([]*querier.AnclaxTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllPendingTasks indicates an expected call of ListAllPendingTasks.
func (mr *MockModelInterfaceMockRecorder) ListAllPendingTasks(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllPendingTasks", reflect.TypeOf((*MockModelInterface)(nil).ListAllPendingTasks), ctx)
}

// ListOrgs mocks base method.
func (m *MockModelInterface) ListOrgs(ctx context.Context, userID int32) ([]*querier.AnclaxOrg, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOrgs", ctx, userID)
	ret0, _ := ret[0].([]*querier.AnclaxOrg)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListOrgs indicates an expected call of ListOrgs.
func (mr *MockModelInterfaceMockRecorder) ListOrgs(ctx, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOrgs", reflect.TypeOf((*MockModelInterface)(nil).ListOrgs), ctx, userID)
}

// PullTask mocks base method.
func (m *MockModelInterface) PullTask(ctx context.Context) (*querier.AnclaxTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PullTask", ctx)
	ret0, _ := ret[0].(*querier.AnclaxTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PullTask indicates an expected call of PullTask.
func (mr *MockModelInterfaceMockRecorder) PullTask(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullTask", reflect.TypeOf((*MockModelInterface)(nil).PullTask), ctx)
}

// PullTaskByID mocks base method.
func (m *MockModelInterface) PullTaskByID(ctx context.Context, id int32) (*querier.AnclaxTask, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PullTaskByID", ctx, id)
	ret0, _ := ret[0].(*querier.AnclaxTask)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PullTaskByID indicates an expected call of PullTaskByID.
func (mr *MockModelInterfaceMockRecorder) PullTaskByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullTaskByID", reflect.TypeOf((*MockModelInterface)(nil).PullTaskByID), ctx, id)
}

// RestoreUserByName mocks base method.
func (m *MockModelInterface) RestoreUserByName(ctx context.Context, name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreUserByName", ctx, name)
	ret0, _ := ret[0].(error)
	return ret0
}

// RestoreUserByName indicates an expected call of RestoreUserByName.
func (mr *MockModelInterfaceMockRecorder) RestoreUserByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreUserByName", reflect.TypeOf((*MockModelInterface)(nil).RestoreUserByName), ctx, name)
}

// RunTransaction mocks base method.
func (m *MockModelInterface) RunTransaction(ctx context.Context, f func(ModelInterface) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunTransaction", ctx, f)
	ret0, _ := ret[0].(error)
	return ret0
}

// RunTransaction indicates an expected call of RunTransaction.
func (mr *MockModelInterfaceMockRecorder) RunTransaction(ctx, f any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTransaction", reflect.TypeOf((*MockModelInterface)(nil).RunTransaction), ctx, f)
}

// RunTransactionWithTx mocks base method.
func (m *MockModelInterface) RunTransactionWithTx(ctx context.Context, f func(pgx.Tx, ModelInterface) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunTransactionWithTx", ctx, f)
	ret0, _ := ret[0].(error)
	return ret0
}

// RunTransactionWithTx indicates an expected call of RunTransactionWithTx.
func (mr *MockModelInterfaceMockRecorder) RunTransactionWithTx(ctx, f any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunTransactionWithTx", reflect.TypeOf((*MockModelInterface)(nil).RunTransactionWithTx), ctx, f)
}

// SetUserDefaultOrg mocks base method.
func (m *MockModelInterface) SetUserDefaultOrg(ctx context.Context, arg querier.SetUserDefaultOrgParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetUserDefaultOrg", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetUserDefaultOrg indicates an expected call of SetUserDefaultOrg.
func (mr *MockModelInterfaceMockRecorder) SetUserDefaultOrg(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserDefaultOrg", reflect.TypeOf((*MockModelInterface)(nil).SetUserDefaultOrg), ctx, arg)
}

// SpawnWithTx mocks base method.
func (m *MockModelInterface) SpawnWithTx(tx pgx.Tx) ModelInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpawnWithTx", tx)
	ret0, _ := ret[0].(ModelInterface)
	return ret0
}

// SpawnWithTx indicates an expected call of SpawnWithTx.
func (mr *MockModelInterfaceMockRecorder) SpawnWithTx(tx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpawnWithTx", reflect.TypeOf((*MockModelInterface)(nil).SpawnWithTx), tx)
}

// UpdateTask mocks base method.
func (m *MockModelInterface) UpdateTask(ctx context.Context, arg querier.UpdateTaskParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTask", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTask indicates an expected call of UpdateTask.
func (mr *MockModelInterfaceMockRecorder) UpdateTask(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTask", reflect.TypeOf((*MockModelInterface)(nil).UpdateTask), ctx, arg)
}

// UpdateTaskStartedAt mocks base method.
func (m *MockModelInterface) UpdateTaskStartedAt(ctx context.Context, arg querier.UpdateTaskStartedAtParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskStartedAt", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTaskStartedAt indicates an expected call of UpdateTaskStartedAt.
func (mr *MockModelInterfaceMockRecorder) UpdateTaskStartedAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskStartedAt", reflect.TypeOf((*MockModelInterface)(nil).UpdateTaskStartedAt), ctx, arg)
}

// UpdateTaskStatus mocks base method.
func (m *MockModelInterface) UpdateTaskStatus(ctx context.Context, arg querier.UpdateTaskStatusParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskStatus", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTaskStatus indicates an expected call of UpdateTaskStatus.
func (mr *MockModelInterfaceMockRecorder) UpdateTaskStatus(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskStatus", reflect.TypeOf((*MockModelInterface)(nil).UpdateTaskStatus), ctx, arg)
}

// UpdateUserPassword mocks base method.
func (m *MockModelInterface) UpdateUserPassword(ctx context.Context, arg querier.UpdateUserPasswordParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserPassword", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateUserPassword indicates an expected call of UpdateUserPassword.
func (mr *MockModelInterfaceMockRecorder) UpdateUserPassword(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPassword", reflect.TypeOf((*MockModelInterface)(nil).UpdateUserPassword), ctx, arg)
}
