// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/baetyl/baetyl-cloud/v2/plugin (interfaces: Module)

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

import (
	common "github.com/baetyl/baetyl-cloud/v2/common"
	models "github.com/baetyl/baetyl-cloud/v2/models"
	gomock "github.com/golang/mock/gomock"
	sqlx "github.com/jmoiron/sqlx"
	reflect "reflect"
)

// MockModule is a mock of Module interface
type MockModule struct {
	ctrl     *gomock.Controller
	recorder *MockModuleMockRecorder
}

// MockModuleMockRecorder is the mock recorder for MockModule
type MockModuleMockRecorder struct {
	mock *MockModule
}

// NewMockModule creates a new mock instance
func NewMockModule(ctrl *gomock.Controller) *MockModule {
	mock := &MockModule{ctrl: ctrl}
	mock.recorder = &MockModuleMockRecorder{mock}
	return mock
}

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

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

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

// CreateModule mocks base method
func (m *MockModule) CreateModule(arg0 *models.Module) (*models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModule", arg0)
	ret0, _ := ret[0].(*models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateModule indicates an expected call of CreateModule
func (mr *MockModuleMockRecorder) CreateModule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateModule", reflect.TypeOf((*MockModule)(nil).CreateModule), arg0)
}

// CreateModuleTx mocks base method
func (m *MockModule) CreateModuleTx(arg0 *sqlx.Tx, arg1 *models.Module) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateModuleTx", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateModuleTx indicates an expected call of CreateModuleTx
func (mr *MockModuleMockRecorder) CreateModuleTx(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateModuleTx", reflect.TypeOf((*MockModule)(nil).CreateModuleTx), arg0, arg1)
}

// DeleteModuleByVersion mocks base method
func (m *MockModule) DeleteModuleByVersion(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModuleByVersion", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteModuleByVersion indicates an expected call of DeleteModuleByVersion
func (mr *MockModuleMockRecorder) DeleteModuleByVersion(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteModuleByVersion", reflect.TypeOf((*MockModule)(nil).DeleteModuleByVersion), arg0, arg1)
}

// DeleteModuleByVersionTx mocks base method
func (m *MockModule) DeleteModuleByVersionTx(arg0 *sqlx.Tx, arg1, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModuleByVersionTx", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteModuleByVersionTx indicates an expected call of DeleteModuleByVersionTx
func (mr *MockModuleMockRecorder) DeleteModuleByVersionTx(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteModuleByVersionTx", reflect.TypeOf((*MockModule)(nil).DeleteModuleByVersionTx), arg0, arg1, arg2)
}

// DeleteModules mocks base method
func (m *MockModule) DeleteModules(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModules", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteModules indicates an expected call of DeleteModules
func (mr *MockModuleMockRecorder) DeleteModules(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteModules", reflect.TypeOf((*MockModule)(nil).DeleteModules), arg0)
}

// DeleteModulesTx mocks base method
func (m *MockModule) DeleteModulesTx(arg0 *sqlx.Tx, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteModulesTx", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteModulesTx indicates an expected call of DeleteModulesTx
func (mr *MockModuleMockRecorder) DeleteModulesTx(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteModulesTx", reflect.TypeOf((*MockModule)(nil).DeleteModulesTx), arg0, arg1)
}

// GetLatestModule mocks base method
func (m *MockModule) GetLatestModule(arg0 string) (*models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestModule", arg0)
	ret0, _ := ret[0].(*models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestModule indicates an expected call of GetLatestModule
func (mr *MockModuleMockRecorder) GetLatestModule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestModule", reflect.TypeOf((*MockModule)(nil).GetLatestModule), arg0)
}

// GetLatestModuleImage mocks base method
func (m *MockModule) GetLatestModuleImage(arg0 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestModuleImage", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestModuleImage indicates an expected call of GetLatestModuleImage
func (mr *MockModuleMockRecorder) GetLatestModuleImage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestModuleImage", reflect.TypeOf((*MockModule)(nil).GetLatestModuleImage), arg0)
}

// GetLatestModuleImageTx mocks base method
func (m *MockModule) GetLatestModuleImageTx(arg0 *sqlx.Tx, arg1 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestModuleImageTx", arg0, arg1)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestModuleImageTx indicates an expected call of GetLatestModuleImageTx
func (mr *MockModuleMockRecorder) GetLatestModuleImageTx(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestModuleImageTx", reflect.TypeOf((*MockModule)(nil).GetLatestModuleImageTx), arg0, arg1)
}

// GetLatestModuleProgram mocks base method
func (m *MockModule) GetLatestModuleProgram(arg0, arg1 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestModuleProgram", arg0, arg1)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestModuleProgram indicates an expected call of GetLatestModuleProgram
func (mr *MockModuleMockRecorder) GetLatestModuleProgram(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestModuleProgram", reflect.TypeOf((*MockModule)(nil).GetLatestModuleProgram), arg0, arg1)
}

// GetLatestModuleProgramTx mocks base method
func (m *MockModule) GetLatestModuleProgramTx(arg0 *sqlx.Tx, arg1, arg2 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestModuleProgramTx", arg0, arg1, arg2)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestModuleProgramTx indicates an expected call of GetLatestModuleProgramTx
func (mr *MockModuleMockRecorder) GetLatestModuleProgramTx(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestModuleProgramTx", reflect.TypeOf((*MockModule)(nil).GetLatestModuleProgramTx), arg0, arg1, arg2)
}

// GetLatestModuleTx mocks base method
func (m *MockModule) GetLatestModuleTx(arg0 *sqlx.Tx, arg1 string) (*models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestModuleTx", arg0, arg1)
	ret0, _ := ret[0].(*models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestModuleTx indicates an expected call of GetLatestModuleTx
func (mr *MockModuleMockRecorder) GetLatestModuleTx(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestModuleTx", reflect.TypeOf((*MockModule)(nil).GetLatestModuleTx), arg0, arg1)
}

// GetModuleByImage mocks base method
func (m *MockModule) GetModuleByImage(arg0, arg1 string) (*models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModuleByImage", arg0, arg1)
	ret0, _ := ret[0].(*models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetModuleByImage indicates an expected call of GetModuleByImage
func (mr *MockModuleMockRecorder) GetModuleByImage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleByImage", reflect.TypeOf((*MockModule)(nil).GetModuleByImage), arg0, arg1)
}

// GetModuleByImageTx mocks base method
func (m *MockModule) GetModuleByImageTx(arg0 *sqlx.Tx, arg1, arg2 string) (*models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModuleByImageTx", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetModuleByImageTx indicates an expected call of GetModuleByImageTx
func (mr *MockModuleMockRecorder) GetModuleByImageTx(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleByImageTx", reflect.TypeOf((*MockModule)(nil).GetModuleByImageTx), arg0, arg1, arg2)
}

// GetModuleByVersion mocks base method
func (m *MockModule) GetModuleByVersion(arg0, arg1 string) (*models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModuleByVersion", arg0, arg1)
	ret0, _ := ret[0].(*models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetModuleByVersion indicates an expected call of GetModuleByVersion
func (mr *MockModuleMockRecorder) GetModuleByVersion(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleByVersion", reflect.TypeOf((*MockModule)(nil).GetModuleByVersion), arg0, arg1)
}

// GetModuleByVersionTx mocks base method
func (m *MockModule) GetModuleByVersionTx(arg0 *sqlx.Tx, arg1, arg2 string) (*models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModuleByVersionTx", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetModuleByVersionTx indicates an expected call of GetModuleByVersionTx
func (mr *MockModuleMockRecorder) GetModuleByVersionTx(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleByVersionTx", reflect.TypeOf((*MockModule)(nil).GetModuleByVersionTx), arg0, arg1, arg2)
}

// GetModuleTx mocks base method
func (m *MockModule) GetModuleTx(arg0 *sqlx.Tx, arg1 string) ([]models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModuleTx", arg0, arg1)
	ret0, _ := ret[0].([]models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetModuleTx indicates an expected call of GetModuleTx
func (mr *MockModuleMockRecorder) GetModuleTx(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleTx", reflect.TypeOf((*MockModule)(nil).GetModuleTx), arg0, arg1)
}

// GetModules mocks base method
func (m *MockModule) GetModules(arg0 string) ([]models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModules", arg0)
	ret0, _ := ret[0].([]models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetModules indicates an expected call of GetModules
func (mr *MockModuleMockRecorder) GetModules(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModules", reflect.TypeOf((*MockModule)(nil).GetModules), arg0)
}

// ListModules mocks base method
func (m *MockModule) ListModules(arg0 *models.Filter, arg1 common.ModuleType) ([]models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModules", arg0, arg1)
	ret0, _ := ret[0].([]models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModules indicates an expected call of ListModules
func (mr *MockModuleMockRecorder) ListModules(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModules", reflect.TypeOf((*MockModule)(nil).ListModules), arg0, arg1)
}

// ListModulesTx mocks base method
func (m *MockModule) ListModulesTx(arg0 *sqlx.Tx, arg1 *models.Filter) ([]models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListModulesTx", arg0, arg1)
	ret0, _ := ret[0].([]models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListModulesTx indicates an expected call of ListModulesTx
func (mr *MockModuleMockRecorder) ListModulesTx(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListModulesTx", reflect.TypeOf((*MockModule)(nil).ListModulesTx), arg0, arg1)
}

// UpdateModuleByVersion mocks base method
func (m *MockModule) UpdateModuleByVersion(arg0 *models.Module) (*models.Module, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateModuleByVersion", arg0)
	ret0, _ := ret[0].(*models.Module)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateModuleByVersion indicates an expected call of UpdateModuleByVersion
func (mr *MockModuleMockRecorder) UpdateModuleByVersion(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateModuleByVersion", reflect.TypeOf((*MockModule)(nil).UpdateModuleByVersion), arg0)
}

// UpdateModuleByVersionTx mocks base method
func (m *MockModule) UpdateModuleByVersionTx(arg0 *sqlx.Tx, arg1 *models.Module) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateModuleByVersionTx", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateModuleByVersionTx indicates an expected call of UpdateModuleByVersionTx
func (mr *MockModuleMockRecorder) UpdateModuleByVersionTx(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateModuleByVersionTx", reflect.TypeOf((*MockModule)(nil).UpdateModuleByVersionTx), arg0, arg1)
}
