// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/cloudwan/gohan/extension/goext (interfaces: ICore,ILogger,ISchemas,ISync,IDatabase,ITransaction,IHTTP,IAuth,IConfig,IUtil,ISchema)

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

import (
	context "context"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
	time "time"
)

// MockICore is a mock of ICore interface
type MockICore struct {
	ctrl     *gomock.Controller
	recorder *MockICoreMockRecorder
}

// MockICoreMockRecorder is the mock recorder for MockICore
type MockICoreMockRecorder struct {
	mock *MockICore
}

// NewMockICore creates a new mock instance
func NewMockICore(ctrl *gomock.Controller) *MockICore {
	mock := &MockICore{ctrl: ctrl}
	mock.recorder = &MockICoreMockRecorder{mock}
	return mock
}

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

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

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

// RegisterEventHandler mocks base method
func (m *MockICore) RegisterEventHandler(arg0 string, arg1 Handler, arg2 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterEventHandler", arg0, arg1, arg2)
}

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

// RegisterSchemaEventHandler mocks base method
func (m *MockICore) RegisterSchemaEventHandler(arg0 SchemaID, arg1 string, arg2 SchemaHandler, arg3 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterSchemaEventHandler", arg0, arg1, arg2, arg3)
}

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

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

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

// MockILogger is a mock of ILogger interface
type MockILogger struct {
	ctrl     *gomock.Controller
	recorder *MockILoggerMockRecorder
}

// MockILoggerMockRecorder is the mock recorder for MockILogger
type MockILoggerMockRecorder struct {
	mock *MockILogger
}

// NewMockILogger creates a new mock instance
func NewMockILogger(ctrl *gomock.Controller) *MockILogger {
	mock := &MockILogger{ctrl: ctrl}
	mock.recorder = &MockILoggerMockRecorder{mock}
	return mock
}

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

// Critical mocks base method
func (m *MockILogger) Critical(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Critical", arg0)
}

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

// Criticalf mocks base method
func (m *MockILogger) Criticalf(arg0 string, arg1 ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Criticalf", varargs...)
}

// Criticalf indicates an expected call of Criticalf
func (mr *MockILoggerMockRecorder) Criticalf(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Criticalf", reflect.TypeOf((*MockILogger)(nil).Criticalf), varargs...)
}

// Debug mocks base method
func (m *MockILogger) Debug(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Debug", arg0)
}

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

// Debugf mocks base method
func (m *MockILogger) Debugf(arg0 string, arg1 ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Debugf", varargs...)
}

// Debugf indicates an expected call of Debugf
func (mr *MockILoggerMockRecorder) Debugf(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debugf", reflect.TypeOf((*MockILogger)(nil).Debugf), varargs...)
}

// Error mocks base method
func (m *MockILogger) Error(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Error", arg0)
}

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

// Errorf mocks base method
func (m *MockILogger) Errorf(arg0 string, arg1 ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Errorf", varargs...)
}

// Errorf indicates an expected call of Errorf
func (mr *MockILoggerMockRecorder) Errorf(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Errorf", reflect.TypeOf((*MockILogger)(nil).Errorf), varargs...)
}

// Info mocks base method
func (m *MockILogger) Info(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Info", arg0)
}

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

// Infof mocks base method
func (m *MockILogger) Infof(arg0 string, arg1 ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Infof", varargs...)
}

// Infof indicates an expected call of Infof
func (mr *MockILoggerMockRecorder) Infof(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Infof", reflect.TypeOf((*MockILogger)(nil).Infof), varargs...)
}

// Notice mocks base method
func (m *MockILogger) Notice(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Notice", arg0)
}

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

// Noticef mocks base method
func (m *MockILogger) Noticef(arg0 string, arg1 ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Noticef", varargs...)
}

// Noticef indicates an expected call of Noticef
func (mr *MockILoggerMockRecorder) Noticef(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Noticef", reflect.TypeOf((*MockILogger)(nil).Noticef), varargs...)
}

// Warning mocks base method
func (m *MockILogger) Warning(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Warning", arg0)
}

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

// Warningf mocks base method
func (m *MockILogger) Warningf(arg0 string, arg1 ...interface{}) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Warningf", varargs...)
}

// Warningf indicates an expected call of Warningf
func (mr *MockILoggerMockRecorder) Warningf(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warningf", reflect.TypeOf((*MockILogger)(nil).Warningf), varargs...)
}

// MockISchemas is a mock of ISchemas interface
type MockISchemas struct {
	ctrl     *gomock.Controller
	recorder *MockISchemasMockRecorder
}

// MockISchemasMockRecorder is the mock recorder for MockISchemas
type MockISchemasMockRecorder struct {
	mock *MockISchemas
}

// NewMockISchemas creates a new mock instance
func NewMockISchemas(ctrl *gomock.Controller) *MockISchemas {
	mock := &MockISchemas{ctrl: ctrl}
	mock.recorder = &MockISchemasMockRecorder{mock}
	return mock
}

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

// Find mocks base method
func (m *MockISchemas) Find(arg0 SchemaID) ISchema {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Find", arg0)
	ret0, _ := ret[0].(ISchema)
	return ret0
}

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

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

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

// Relations mocks base method
func (m *MockISchemas) Relations(arg0 SchemaID) []SchemaRelationInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Relations", arg0)
	ret0, _ := ret[0].([]SchemaRelationInfo)
	return ret0
}

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

// MockISync is a mock of ISync interface
type MockISync struct {
	ctrl     *gomock.Controller
	recorder *MockISyncMockRecorder
}

// MockISyncMockRecorder is the mock recorder for MockISync
type MockISyncMockRecorder struct {
	mock *MockISync
}

// NewMockISync creates a new mock instance
func NewMockISync(ctrl *gomock.Controller) *MockISync {
	mock := &MockISync{ctrl: ctrl}
	mock.recorder = &MockISyncMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// Watch mocks base method
func (m *MockISync) Watch(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 int64) ([]*Event, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Watch", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*Event)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockIDatabase is a mock of IDatabase interface
type MockIDatabase struct {
	ctrl     *gomock.Controller
	recorder *MockIDatabaseMockRecorder
}

// MockIDatabaseMockRecorder is the mock recorder for MockIDatabase
type MockIDatabaseMockRecorder struct {
	mock *MockIDatabase
}

// NewMockIDatabase creates a new mock instance
func NewMockIDatabase(ctrl *gomock.Controller) *MockIDatabase {
	mock := &MockIDatabase{ctrl: ctrl}
	mock.recorder = &MockIDatabaseMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// WithinTx mocks base method
func (m *MockIDatabase) WithinTx(arg0 Context, arg1 *TxOptions, arg2 func(ITransaction) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithinTx", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockITransaction is a mock of ITransaction interface
type MockITransaction struct {
	ctrl     *gomock.Controller
	recorder *MockITransactionMockRecorder
}

// MockITransactionMockRecorder is the mock recorder for MockITransaction
type MockITransactionMockRecorder struct {
	mock *MockITransaction
}

// NewMockITransaction creates a new mock instance
func NewMockITransaction(ctrl *gomock.Controller) *MockITransaction {
	mock := &MockITransaction{ctrl: ctrl}
	mock.recorder = &MockITransactionMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// Count mocks base method
func (m *MockITransaction) Count(arg0 context.Context, arg1 ISchema, arg2 Filter) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Count", arg0, arg1, arg2)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Create mocks base method
func (m *MockITransaction) Create(arg0 context.Context, arg1 ISchema, arg2 map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Delete mocks base method
func (m *MockITransaction) Delete(arg0 context.Context, arg1 ISchema, arg2 interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteFilter mocks base method
func (m *MockITransaction) DeleteFilter(arg0 context.Context, arg1 ISchema, arg2 Filter) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFilter", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Exec mocks base method
func (m *MockITransaction) Exec(arg0 context.Context, arg1 string, arg2 ...interface{}) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Exec", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Exec indicates an expected call of Exec
func (mr *MockITransactionMockRecorder) Exec(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockITransaction)(nil).Exec), varargs...)
}

// Fetch mocks base method
func (m *MockITransaction) Fetch(arg0 context.Context, arg1 ISchema, arg2 Filter) (map[string]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fetch", arg0, arg1, arg2)
	ret0, _ := ret[0].(map[string]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// List mocks base method
func (m *MockITransaction) List(arg0 context.Context, arg1 ISchema, arg2 Filter, arg3 *ListOptions, arg4 *Paginator) ([]map[string]interface{}, uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]map[string]interface{})
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// LockFetch mocks base method
func (m *MockITransaction) LockFetch(arg0 context.Context, arg1 ISchema, arg2 Filter, arg3 LockPolicy) (map[string]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockFetch", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(map[string]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LockList mocks base method
func (m *MockITransaction) LockList(arg0 context.Context, arg1 ISchema, arg2 Filter, arg3 *ListOptions, arg4 *Paginator, arg5 LockPolicy) ([]map[string]interface{}, uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockList", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].([]map[string]interface{})
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// Query mocks base method
func (m *MockITransaction) Query(arg0 context.Context, arg1 ISchema, arg2 string, arg3 []interface{}) ([]map[string]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Query", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]map[string]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// StateFetch mocks base method
func (m *MockITransaction) StateFetch(arg0 context.Context, arg1 ISchema, arg2 Filter) (ResourceState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateFetch", arg0, arg1, arg2)
	ret0, _ := ret[0].(ResourceState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StateList mocks base method
func (m *MockITransaction) StateList(arg0 context.Context, arg1 ISchema, arg2 Filter) ([]ResourceState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateList", arg0, arg1, arg2)
	ret0, _ := ret[0].([]ResourceState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StateUpdate mocks base method
func (m *MockITransaction) StateUpdate(arg0 context.Context, arg1 ISchema, arg2 map[string]interface{}, arg3 *ResourceState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateUpdate", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Update mocks base method
func (m *MockITransaction) Update(arg0 context.Context, arg1 ISchema, arg2 map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockIHTTP is a mock of IHTTP interface
type MockIHTTP struct {
	ctrl     *gomock.Controller
	recorder *MockIHTTPMockRecorder
}

// MockIHTTPMockRecorder is the mock recorder for MockIHTTP
type MockIHTTPMockRecorder struct {
	mock *MockIHTTP
}

// NewMockIHTTP creates a new mock instance
func NewMockIHTTP(ctrl *gomock.Controller) *MockIHTTP {
	mock := &MockIHTTP{ctrl: ctrl}
	mock.recorder = &MockIHTTPMockRecorder{mock}
	return mock
}

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

// Request mocks base method
func (m *MockIHTTP) Request(arg0 context.Context, arg1, arg2 string, arg3 map[string]interface{}, arg4 interface{}, arg5 bool) (*Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Request", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RequestRaw mocks base method
func (m *MockIHTTP) RequestRaw(arg0 context.Context, arg1, arg2 string, arg3 map[string]string, arg4 string) (*Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestRaw", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockIAuth is a mock of IAuth interface
type MockIAuth struct {
	ctrl     *gomock.Controller
	recorder *MockIAuthMockRecorder
}

// MockIAuthMockRecorder is the mock recorder for MockIAuth
type MockIAuthMockRecorder struct {
	mock *MockIAuth
}

// NewMockIAuth creates a new mock instance
func NewMockIAuth(ctrl *gomock.Controller) *MockIAuth {
	mock := &MockIAuth{ctrl: ctrl}
	mock.recorder = &MockIAuthMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockIConfig is a mock of IConfig interface
type MockIConfig struct {
	ctrl     *gomock.Controller
	recorder *MockIConfigMockRecorder
}

// MockIConfigMockRecorder is the mock recorder for MockIConfig
type MockIConfigMockRecorder struct {
	mock *MockIConfig
}

// NewMockIConfig creates a new mock instance
func NewMockIConfig(ctrl *gomock.Controller) *MockIConfig {
	mock := &MockIConfig{ctrl: ctrl}
	mock.recorder = &MockIConfigMockRecorder{mock}
	return mock
}

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

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

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

// MockIUtil is a mock of IUtil interface
type MockIUtil struct {
	ctrl     *gomock.Controller
	recorder *MockIUtilMockRecorder
}

// MockIUtilMockRecorder is the mock recorder for MockIUtil
type MockIUtilMockRecorder struct {
	mock *MockIUtil
}

// NewMockIUtil creates a new mock instance
func NewMockIUtil(ctrl *gomock.Controller) *MockIUtil {
	mock := &MockIUtil{ctrl: ctrl}
	mock.recorder = &MockIUtilMockRecorder{mock}
	return mock
}

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

// GetTransaction mocks base method
func (m *MockIUtil) GetTransaction(arg0 Context) (ITransaction, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTransaction", arg0)
	ret0, _ := ret[0].(ITransaction)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

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

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

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

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

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

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

// MockISchema is a mock of ISchema interface
type MockISchema struct {
	ctrl     *gomock.Controller
	recorder *MockISchemaMockRecorder
}

// MockISchemaMockRecorder is the mock recorder for MockISchema
type MockISchemaMockRecorder struct {
	mock *MockISchema
}

// NewMockISchema creates a new mock instance
func NewMockISchema(ctrl *gomock.Controller) *MockISchema {
	mock := &MockISchema{ctrl: ctrl}
	mock.recorder = &MockISchemaMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// DbStateUpdateRaw mocks base method
func (m *MockISchema) DbStateUpdateRaw(arg0 interface{}, arg1 Context, arg2 *ResourceState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DbStateUpdateRaw", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// List mocks base method
func (m *MockISchema) List(arg0 Filter, arg1 *Paginator, arg2 Context) ([]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", arg0, arg1, arg2)
	ret0, _ := ret[0].([]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListRaw mocks base method
func (m *MockISchema) ListRaw(arg0 Filter, arg1 *Paginator, arg2 Context) ([]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRaw", arg0, arg1, arg2)
	ret0, _ := ret[0].([]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// LockFetchFilter mocks base method
func (m *MockISchema) LockFetchFilter(arg0 Filter, arg1 Context, arg2 LockPolicy) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockFetchFilter", arg0, arg1, arg2)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LockFetchFilterRaw mocks base method
func (m *MockISchema) LockFetchFilterRaw(arg0 Filter, arg1 Context, arg2 LockPolicy) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockFetchFilterRaw", arg0, arg1, arg2)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// LockList mocks base method
func (m *MockISchema) LockList(arg0 Filter, arg1 *Paginator, arg2 Context, arg3 LockPolicy) ([]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockList", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LockListRaw mocks base method
func (m *MockISchema) LockListRaw(arg0 Filter, arg1 *Paginator, arg2 Context, arg3 LockPolicy) ([]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockListRaw", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Metadata mocks base method
func (m *MockISchema) Metadata() map[string]interface{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Metadata")
	ret0, _ := ret[0].(map[string]interface{})
	return ret0
}

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

// Properties mocks base method
func (m *MockISchema) Properties() map[string]Property {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Properties")
	ret0, _ := ret[0].(map[string]Property)
	return ret0
}

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

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

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

// RegisterCustomEventHandler mocks base method
func (m *MockISchema) RegisterCustomEventHandler(arg0 CustomEvent, arg1 Handler, arg2 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterCustomEventHandler", arg0, arg1, arg2)
}

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

// RegisterRawType mocks base method
func (m *MockISchema) RegisterRawType(arg0 interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterRawType", arg0)
}

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

// RegisterResourceEventHandler mocks base method
func (m *MockISchema) RegisterResourceEventHandler(arg0 ResourceEvent, arg1 SchemaHandler, arg2 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterResourceEventHandler", arg0, arg1, arg2)
}

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

// RegisterType mocks base method
func (m *MockISchema) RegisterType(arg0 IResourceBase) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterType", arg0)
}

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

// RegisterTypes mocks base method
func (m *MockISchema) RegisterTypes(arg0 interface{}, arg1 IResourceBase) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterTypes", arg0, arg1)
}

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

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

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

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

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

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

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

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

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