storage_db.go

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

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

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

// MockDBStorage is a mock of DBStorage interface
type MockDBStorage struct {
	ctrl     *gomock.Controller
	recorder *MockDBStorageMockRecorder
}

// MockDBStorageMockRecorder is the mock recorder for MockDBStorage
type MockDBStorageMockRecorder struct {
	mock *MockDBStorage
}

// NewMockDBStorage creates a new mock instance
func NewMockDBStorage(ctrl *gomock.Controller) *MockDBStorage {
	mock := &MockDBStorage{ctrl: ctrl}
	mock.recorder = &MockDBStorageMockRecorder{mock}
	return mock
}

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

// Close mocks base method
func (m *MockDBStorage) 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 *MockDBStorageMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDBStorage)(nil).Close))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// CreateApplication mocks base method
func (m *MockDBStorage) CreateApplication(arg0 *v1.Application) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateApplication", arg0)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateApplicationWithTx mocks base method
func (m *MockDBStorage) CreateApplicationWithTx(arg0 *sqlx.Tx, arg1 *v1.Application) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateApplicationWithTx", arg0, arg1)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// CreateBatchTx mocks base method
func (m *MockDBStorage) CreateBatchTx(arg0 *sqlx.Tx, arg1 *models.Batch) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBatchTx", arg0, arg1)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// CreateCallbackTx mocks base method
func (m *MockDBStorage) CreateCallbackTx(arg0 *sqlx.Tx, arg1 *models.Callback) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCallbackTx", arg0, arg1)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateIndex mocks base method
func (m *MockDBStorage) CreateIndex(arg0 string, arg1, arg2 common.Resource, arg3, arg4 string) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIndex", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIndex indicates an expected call of CreateIndex
func (mr *MockDBStorageMockRecorder) CreateIndex(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIndex", reflect.TypeOf((*MockDBStorage)(nil).CreateIndex), arg0, arg1, arg2, arg3, arg4)
}

// CreateIndexTx mocks base method
func (m *MockDBStorage) CreateIndexTx(arg0 *sqlx.Tx, arg1 string, arg2, arg3 common.Resource, arg4, arg5 string) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIndexTx", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIndexTx indicates an expected call of CreateIndexTx
func (mr *MockDBStorageMockRecorder) CreateIndexTx(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIndexTx", reflect.TypeOf((*MockDBStorage)(nil).CreateIndexTx), arg0, arg1, arg2, arg3, arg4, arg5)
}

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

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

// CreateRecordTx mocks base method
func (m *MockDBStorage) CreateRecordTx(arg0 *sqlx.Tx, arg1 []models.Record) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRecordTx", arg0, arg1)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// CreateTaskTx mocks base method
func (m *MockDBStorage) CreateTaskTx(arg0 *sqlx.Tx, arg1 *models.Task) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTaskTx", arg0, arg1)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DeleteIndex mocks base method
func (m *MockDBStorage) DeleteIndex(arg0 string, arg1, arg2 common.Resource, arg3 string) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIndex", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteIndexTx mocks base method
func (m *MockDBStorage) DeleteIndexTx(arg0 *sqlx.Tx, arg1 string, arg2, arg3 common.Resource, arg4 string) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIndexTx", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteIndexTx indicates an expected call of DeleteIndexTx
func (mr *MockDBStorageMockRecorder) DeleteIndexTx(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIndexTx", reflect.TypeOf((*MockDBStorage)(nil).DeleteIndexTx), arg0, arg1, arg2, arg3, arg4)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ListApplication mocks base method
func (m *MockDBStorage) ListApplication(arg0, arg1 string, arg2, arg3 int) ([]v1.Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListApplication", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]v1.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBatch mocks base method
func (m *MockDBStorage) ListBatch(arg0, arg1 string, arg2, arg3 int) ([]models.Batch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBatch", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]models.Batch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// ListBatchTx indicates an expected call of ListBatchTx
func (mr *MockDBStorageMockRecorder) ListBatchTx(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBatchTx", reflect.TypeOf((*MockDBStorage)(nil).ListBatchTx), arg0, arg1, arg2, arg3, arg4)
}

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

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

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

// ListIndexTx indicates an expected call of ListIndexTx
func (mr *MockDBStorageMockRecorder) ListIndexTx(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIndexTx", reflect.TypeOf((*MockDBStorage)(nil).ListIndexTx), arg0, arg1, arg2, arg3, arg4)
}

// ListRecord mocks base method
func (m *MockDBStorage) ListRecord(arg0, arg1, arg2 string, arg3, arg4 int) ([]models.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRecord", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]models.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRecord indicates an expected call of ListRecord
func (mr *MockDBStorageMockRecorder) ListRecord(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRecord", reflect.TypeOf((*MockDBStorage)(nil).ListRecord), arg0, arg1, arg2, arg3, arg4)
}

// ListRecordTx mocks base method
func (m *MockDBStorage) ListRecordTx(arg0 *sqlx.Tx, arg1, arg2, arg3 string, arg4, arg5 int) ([]models.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRecordTx", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].([]models.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRecordTx indicates an expected call of ListRecordTx
func (mr *MockDBStorageMockRecorder) ListRecordTx(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRecordTx", reflect.TypeOf((*MockDBStorage)(nil).ListRecordTx), arg0, arg1, arg2, arg3, arg4, arg5)
}

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

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

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

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

// RefreshIndex mocks base method
func (m *MockDBStorage) RefreshIndex(arg0 string, arg1, arg2 common.Resource, arg3 string, arg4 []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshIndex", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// RefreshIndex indicates an expected call of RefreshIndex
func (mr *MockDBStorageMockRecorder) RefreshIndex(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshIndex", reflect.TypeOf((*MockDBStorage)(nil).RefreshIndex), arg0, arg1, arg2, arg3, arg4)
}

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

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

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

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

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

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

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

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

// UpdateBatchTx mocks base method
func (m *MockDBStorage) UpdateBatchTx(arg0 *sqlx.Tx, arg1 *models.Batch) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBatchTx", arg0, arg1)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// UpdateCallbackTx mocks base method
func (m *MockDBStorage) UpdateCallbackTx(arg0 *sqlx.Tx, arg1 *models.Callback) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCallbackTx", arg0, arg1)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// UpdateRecordTx mocks base method
func (m *MockDBStorage) UpdateRecordTx(arg0 *sqlx.Tx, arg1 *models.Record) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRecordTx", arg0, arg1)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// UpdateTaskTx mocks base method
func (m *MockDBStorage) UpdateTaskTx(arg0 *sqlx.Tx, arg1 *models.Task) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskTx", arg0, arg1)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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