gone/mock_test.go

// Code generated by MockGen. DO NOT EDIT.
// Source: interface.go
//
// Generated by this command:
//
//	mockgen -package=gone -self_package=github.com/gone-io/gone -source=interface.go -destination=mock_test.go
//

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

import (
	context "context"
	sql "database/sql"
	net "net"
	reflect "reflect"
	time "time"

	cmux "github.com/soheilhy/cmux"
	gomock "go.uber.org/mock/gomock"
	xorm "xorm.io/xorm"
	caches "xorm.io/xorm/caches"
	contexts "xorm.io/xorm/contexts"
	dialects "xorm.io/xorm/dialects"
	log "xorm.io/xorm/log"
	names "xorm.io/xorm/names"
	schemas "xorm.io/xorm/schemas"
)

// MockGoner is a mock of Goner interface.
type MockGoner struct {
	ctrl     *gomock.Controller
	recorder *MockGonerMockRecorder
	isgomock struct{}
}

// MockGonerMockRecorder is the mock recorder for MockGoner.
type MockGonerMockRecorder struct {
	mock *MockGoner
}

// NewMockGoner creates a new mock instance.
func NewMockGoner(ctrl *gomock.Controller) *MockGoner {
	mock := &MockGoner{ctrl: ctrl}
	mock.recorder = &MockGonerMockRecorder{mock}
	return mock
}

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

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

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

// MockGonerOption is a mock of GonerOption interface.
type MockGonerOption struct {
	ctrl     *gomock.Controller
	recorder *MockGonerOptionMockRecorder
	isgomock struct{}
}

// MockGonerOptionMockRecorder is the mock recorder for MockGonerOption.
type MockGonerOptionMockRecorder struct {
	mock *MockGonerOption
}

// NewMockGonerOption creates a new mock instance.
func NewMockGonerOption(ctrl *gomock.Controller) *MockGonerOption {
	mock := &MockGonerOption{ctrl: ctrl}
	mock.recorder = &MockGonerOptionMockRecorder{mock}
	return mock
}

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

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

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

// Mockidentity is a mock of identity interface.
type Mockidentity struct {
	ctrl     *gomock.Controller
	recorder *MockidentityMockRecorder
	isgomock struct{}
}

// MockidentityMockRecorder is the mock recorder for Mockidentity.
type MockidentityMockRecorder struct {
	mock *Mockidentity
}

// NewMockidentity creates a new mock instance.
func NewMockidentity(ctrl *gomock.Controller) *Mockidentity {
	mock := &Mockidentity{ctrl: ctrl}
	mock.recorder = &MockidentityMockRecorder{mock}
	return mock
}

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

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

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

// MockTomb is a mock of Tomb interface.
type MockTomb struct {
	ctrl     *gomock.Controller
	recorder *MockTombMockRecorder
	isgomock struct{}
}

// MockTombMockRecorder is the mock recorder for MockTomb.
type MockTombMockRecorder struct {
	mock *MockTomb
}

// NewMockTomb creates a new mock instance.
func NewMockTomb(ctrl *gomock.Controller) *MockTomb {
	mock := &MockTomb{ctrl: ctrl}
	mock.recorder = &MockTombMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// GonerIsRevive mocks base method.
func (m *MockTomb) GonerIsRevive(flags ...bool) bool {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range flags {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GonerIsRevive", varargs...)
	ret0, _ := ret[0].(bool)
	return ret0
}

// GonerIsRevive indicates an expected call of GonerIsRevive.
func (mr *MockTombMockRecorder) GonerIsRevive(flags ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GonerIsRevive", reflect.TypeOf((*MockTomb)(nil).GonerIsRevive), flags...)
}

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

// IsDefault indicates an expected call of IsDefault.
func (mr *MockTombMockRecorder) IsDefault(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDefault", reflect.TypeOf((*MockTomb)(nil).IsDefault), arg0)
}

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

// SetDefault indicates an expected call of SetDefault.
func (mr *MockTombMockRecorder) SetDefault(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefault", reflect.TypeOf((*MockTomb)(nil).SetDefault), arg0)
}

// SetId mocks base method.
func (m *MockTomb) SetId(arg0 GonerId) Tomb {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetId", arg0)
	ret0, _ := ret[0].(Tomb)
	return ret0
}

// SetId indicates an expected call of SetId.
func (mr *MockTombMockRecorder) SetId(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetId", reflect.TypeOf((*MockTomb)(nil).SetId), arg0)
}

// SetOrder mocks base method.
func (m *MockTomb) SetOrder(order Order) Tomb {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOrder", order)
	ret0, _ := ret[0].(Tomb)
	return ret0
}

// SetOrder indicates an expected call of SetOrder.
func (mr *MockTombMockRecorder) SetOrder(order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOrder", reflect.TypeOf((*MockTomb)(nil).SetOrder), order)
}

// MockCemetery is a mock of Cemetery interface.
type MockCemetery struct {
	ctrl     *gomock.Controller
	recorder *MockCemeteryMockRecorder
	isgomock struct{}
}

// MockCemeteryMockRecorder is the mock recorder for MockCemetery.
type MockCemeteryMockRecorder struct {
	mock *MockCemetery
}

// NewMockCemetery creates a new mock instance.
func NewMockCemetery(ctrl *gomock.Controller) *MockCemetery {
	mock := &MockCemetery{ctrl: ctrl}
	mock.recorder = &MockCemeteryMockRecorder{mock}
	return mock
}

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

// Bury mocks base method.
func (m *MockCemetery) Bury(arg0 Goner, arg1 ...GonerOption) Cemetery {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Bury", varargs...)
	ret0, _ := ret[0].(Cemetery)
	return ret0
}

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

// BuryOnce mocks base method.
func (m *MockCemetery) BuryOnce(goner Goner, options ...GonerOption) Cemetery {
	m.ctrl.T.Helper()
	varargs := []any{goner}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BuryOnce", varargs...)
	ret0, _ := ret[0].(Cemetery)
	return ret0
}

// BuryOnce indicates an expected call of BuryOnce.
func (mr *MockCemeteryMockRecorder) BuryOnce(goner any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{goner}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuryOnce", reflect.TypeOf((*MockCemetery)(nil).BuryOnce), varargs...)
}

// GetTomById mocks base method.
func (m *MockCemetery) GetTomById(arg0 GonerId) Tomb {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTomById", arg0)
	ret0, _ := ret[0].(Tomb)
	return ret0
}

// GetTomById indicates an expected call of GetTomById.
func (mr *MockCemeteryMockRecorder) GetTomById(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTomById", reflect.TypeOf((*MockCemetery)(nil).GetTomById), arg0)
}

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

// GetTomByType indicates an expected call of GetTomByType.
func (mr *MockCemeteryMockRecorder) GetTomByType(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTomByType", reflect.TypeOf((*MockCemetery)(nil).GetTomByType), arg0)
}

// InjectFuncParameters mocks base method.
func (m *MockCemetery) InjectFuncParameters(fn any, injectBefore func(reflect.Type, int) any, injectAfter func(reflect.Type, int)) ([]reflect.Value, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InjectFuncParameters", fn, injectBefore, injectAfter)
	ret0, _ := ret[0].([]reflect.Value)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InjectFuncParameters indicates an expected call of InjectFuncParameters.
func (mr *MockCemeteryMockRecorder) InjectFuncParameters(fn, injectBefore, injectAfter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InjectFuncParameters", reflect.TypeOf((*MockCemetery)(nil).InjectFuncParameters), fn, injectBefore, injectAfter)
}

// ReplaceBury mocks base method.
func (m *MockCemetery) ReplaceBury(goner Goner, options ...GonerOption) error {
	m.ctrl.T.Helper()
	varargs := []any{goner}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplaceBury", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReplaceBury indicates an expected call of ReplaceBury.
func (mr *MockCemeteryMockRecorder) ReplaceBury(goner any, options ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{goner}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceBury", reflect.TypeOf((*MockCemetery)(nil).ReplaceBury), varargs...)
}

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

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

// ReviveOne mocks base method.
func (m *MockCemetery) ReviveOne(goner any) ([]Tomb, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReviveOne", goner)
	ret0, _ := ret[0].([]Tomb)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReviveOne indicates an expected call of ReviveOne.
func (mr *MockCemeteryMockRecorder) ReviveOne(goner any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReviveOne", reflect.TypeOf((*MockCemetery)(nil).ReviveOne), goner)
}

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

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

// MockHeaven is a mock of Heaven interface.
type MockHeaven struct {
	ctrl     *gomock.Controller
	recorder *MockHeavenMockRecorder
	isgomock struct{}
}

// MockHeavenMockRecorder is the mock recorder for MockHeaven.
type MockHeavenMockRecorder struct {
	mock *MockHeaven
}

// NewMockHeaven creates a new mock instance.
func NewMockHeaven(ctrl *gomock.Controller) *MockHeaven {
	mock := &MockHeaven{ctrl: ctrl}
	mock.recorder = &MockHeavenMockRecorder{mock}
	return mock
}

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

// AfterStart mocks base method.
func (m *MockHeaven) AfterStart(arg0 Process) Heaven {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AfterStart", arg0)
	ret0, _ := ret[0].(Heaven)
	return ret0
}

// AfterStart indicates an expected call of AfterStart.
func (mr *MockHeavenMockRecorder) AfterStart(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AfterStart", reflect.TypeOf((*MockHeaven)(nil).AfterStart), arg0)
}

// AfterStop mocks base method.
func (m *MockHeaven) AfterStop(arg0 Process) Heaven {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AfterStop", arg0)
	ret0, _ := ret[0].(Heaven)
	return ret0
}

// AfterStop indicates an expected call of AfterStop.
func (mr *MockHeavenMockRecorder) AfterStop(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AfterStop", reflect.TypeOf((*MockHeaven)(nil).AfterStop), arg0)
}

// BeforeStart mocks base method.
func (m *MockHeaven) BeforeStart(arg0 Process) Heaven {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BeforeStart", arg0)
	ret0, _ := ret[0].(Heaven)
	return ret0
}

// BeforeStart indicates an expected call of BeforeStart.
func (mr *MockHeavenMockRecorder) BeforeStart(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeforeStart", reflect.TypeOf((*MockHeaven)(nil).BeforeStart), arg0)
}

// BeforeStop mocks base method.
func (m *MockHeaven) BeforeStop(arg0 Process) Heaven {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BeforeStop", arg0)
	ret0, _ := ret[0].(Heaven)
	return ret0
}

// BeforeStop indicates an expected call of BeforeStop.
func (mr *MockHeavenMockRecorder) BeforeStop(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeforeStop", reflect.TypeOf((*MockHeaven)(nil).BeforeStop), arg0)
}

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

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

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

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

// GetHeavenStopSignal mocks base method.
func (m *MockHeaven) GetHeavenStopSignal() <-chan struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeavenStopSignal")
	ret0, _ := ret[0].(<-chan struct{})
	return ret0
}

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

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

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

// SetAfterStopSignalWaitSecond mocks base method.
func (m *MockHeaven) SetAfterStopSignalWaitSecond(sec int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAfterStopSignalWaitSecond", sec)
}

// SetAfterStopSignalWaitSecond indicates an expected call of SetAfterStopSignalWaitSecond.
func (mr *MockHeavenMockRecorder) SetAfterStopSignalWaitSecond(sec any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAfterStopSignalWaitSecond", reflect.TypeOf((*MockHeaven)(nil).SetAfterStopSignalWaitSecond), sec)
}

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

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

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

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

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

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

// MockProphet is a mock of Prophet interface.
type MockProphet struct {
	ctrl     *gomock.Controller
	recorder *MockProphetMockRecorder
	isgomock struct{}
}

// MockProphetMockRecorder is the mock recorder for MockProphet.
type MockProphetMockRecorder struct {
	mock *MockProphet
}

// NewMockProphet creates a new mock instance.
func NewMockProphet(ctrl *gomock.Controller) *MockProphet {
	mock := &MockProphet{ctrl: ctrl}
	mock.recorder = &MockProphetMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockProphet2 is a mock of Prophet2 interface.
type MockProphet2 struct {
	ctrl     *gomock.Controller
	recorder *MockProphet2MockRecorder
	isgomock struct{}
}

// MockProphet2MockRecorder is the mock recorder for MockProphet2.
type MockProphet2MockRecorder struct {
	mock *MockProphet2
}

// NewMockProphet2 creates a new mock instance.
func NewMockProphet2(ctrl *gomock.Controller) *MockProphet2 {
	mock := &MockProphet2{ctrl: ctrl}
	mock.recorder = &MockProphet2MockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockAngel is a mock of Angel interface.
type MockAngel struct {
	ctrl     *gomock.Controller
	recorder *MockAngelMockRecorder
	isgomock struct{}
}

// MockAngelMockRecorder is the mock recorder for MockAngel.
type MockAngelMockRecorder struct {
	mock *MockAngel
}

// NewMockAngel creates a new mock instance.
func NewMockAngel(ctrl *gomock.Controller) *MockAngel {
	mock := &MockAngel{ctrl: ctrl}
	mock.recorder = &MockAngelMockRecorder{mock}
	return mock
}

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

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

// Start indicates an expected call of Start.
func (mr *MockAngelMockRecorder) Start(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockAngel)(nil).Start), arg0)
}

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

// Stop indicates an expected call of Stop.
func (mr *MockAngelMockRecorder) Stop(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockAngel)(nil).Stop), arg0)
}

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

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

// MockVampire is a mock of Vampire interface.
type MockVampire struct {
	ctrl     *gomock.Controller
	recorder *MockVampireMockRecorder
	isgomock struct{}
}

// MockVampireMockRecorder is the mock recorder for MockVampire.
type MockVampireMockRecorder struct {
	mock *MockVampire
}

// NewMockVampire creates a new mock instance.
func NewMockVampire(ctrl *gomock.Controller) *MockVampire {
	mock := &MockVampire{ctrl: ctrl}
	mock.recorder = &MockVampireMockRecorder{mock}
	return mock
}

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

// Suck mocks base method.
func (m *MockVampire) Suck(conf string, v reflect.Value) SuckError {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Suck", conf, v)
	ret0, _ := ret[0].(SuckError)
	return ret0
}

// Suck indicates an expected call of Suck.
func (mr *MockVampireMockRecorder) Suck(conf, v any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Suck", reflect.TypeOf((*MockVampire)(nil).Suck), conf, v)
}

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

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

// MockVampire2 is a mock of Vampire2 interface.
type MockVampire2 struct {
	ctrl     *gomock.Controller
	recorder *MockVampire2MockRecorder
	isgomock struct{}
}

// MockVampire2MockRecorder is the mock recorder for MockVampire2.
type MockVampire2MockRecorder struct {
	mock *MockVampire2
}

// NewMockVampire2 creates a new mock instance.
func NewMockVampire2(ctrl *gomock.Controller) *MockVampire2 {
	mock := &MockVampire2{ctrl: ctrl}
	mock.recorder = &MockVampire2MockRecorder{mock}
	return mock
}

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

// Suck mocks base method.
func (m *MockVampire2) Suck(conf string, v reflect.Value, field reflect.StructField) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Suck", conf, v, field)
	ret0, _ := ret[0].(error)
	return ret0
}

// Suck indicates an expected call of Suck.
func (mr *MockVampire2MockRecorder) Suck(conf, v, field any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Suck", reflect.TypeOf((*MockVampire2)(nil).Suck), conf, v, field)
}

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

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

// MockError is a mock of Error interface.
type MockError struct {
	ctrl     *gomock.Controller
	recorder *MockErrorMockRecorder
	isgomock struct{}
}

// MockErrorMockRecorder is the mock recorder for MockError.
type MockErrorMockRecorder struct {
	mock *MockError
}

// NewMockError creates a new mock instance.
func NewMockError(ctrl *gomock.Controller) *MockError {
	mock := &MockError{ctrl: ctrl}
	mock.recorder = &MockErrorMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockInnerError is a mock of InnerError interface.
type MockInnerError struct {
	ctrl     *gomock.Controller
	recorder *MockInnerErrorMockRecorder
	isgomock struct{}
}

// MockInnerErrorMockRecorder is the mock recorder for MockInnerError.
type MockInnerErrorMockRecorder struct {
	mock *MockInnerError
}

// NewMockInnerError creates a new mock instance.
func NewMockInnerError(ctrl *gomock.Controller) *MockInnerError {
	mock := &MockInnerError{ctrl: ctrl}
	mock.recorder = &MockInnerErrorMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockBusinessError is a mock of BusinessError interface.
type MockBusinessError struct {
	ctrl     *gomock.Controller
	recorder *MockBusinessErrorMockRecorder
	isgomock struct{}
}

// MockBusinessErrorMockRecorder is the mock recorder for MockBusinessError.
type MockBusinessErrorMockRecorder struct {
	mock *MockBusinessError
}

// NewMockBusinessError creates a new mock instance.
func NewMockBusinessError(ctrl *gomock.Controller) *MockBusinessError {
	mock := &MockBusinessError{ctrl: ctrl}
	mock.recorder = &MockBusinessErrorMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockLogger is a mock of Logger interface.
type MockLogger struct {
	ctrl     *gomock.Controller
	recorder *MockLoggerMockRecorder
	isgomock struct{}
}

// MockLoggerMockRecorder is the mock recorder for MockLogger.
type MockLoggerMockRecorder struct {
	mock *MockLogger
}

// NewMockLogger creates a new mock instance.
func NewMockLogger(ctrl *gomock.Controller) *MockLogger {
	mock := &MockLogger{ctrl: ctrl}
	mock.recorder = &MockLoggerMockRecorder{mock}
	return mock
}

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

// Debug mocks base method.
func (m *MockLogger) Debug(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Debug", varargs...)
}

// Debug indicates an expected call of Debug.
func (mr *MockLoggerMockRecorder) Debug(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), args...)
}

// Debugf mocks base method.
func (m *MockLogger) Debugf(format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Debugf", varargs...)
}

// Debugf indicates an expected call of Debugf.
func (mr *MockLoggerMockRecorder) Debugf(format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debugf", reflect.TypeOf((*MockLogger)(nil).Debugf), varargs...)
}

// Debugln mocks base method.
func (m *MockLogger) Debugln(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Debugln", varargs...)
}

// Debugln indicates an expected call of Debugln.
func (mr *MockLoggerMockRecorder) Debugln(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debugln", reflect.TypeOf((*MockLogger)(nil).Debugln), args...)
}

// Error mocks base method.
func (m *MockLogger) Error(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Error", varargs...)
}

// Error indicates an expected call of Error.
func (mr *MockLoggerMockRecorder) Error(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), args...)
}

// Errorf mocks base method.
func (m *MockLogger) Errorf(format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Errorf", varargs...)
}

// Errorf indicates an expected call of Errorf.
func (mr *MockLoggerMockRecorder) Errorf(format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Errorf", reflect.TypeOf((*MockLogger)(nil).Errorf), varargs...)
}

// Errorln mocks base method.
func (m *MockLogger) Errorln(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Errorln", varargs...)
}

// Errorln indicates an expected call of Errorln.
func (mr *MockLoggerMockRecorder) Errorln(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Errorln", reflect.TypeOf((*MockLogger)(nil).Errorln), args...)
}

// Fatal mocks base method.
func (m *MockLogger) Fatal(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Fatal", varargs...)
}

// Fatal indicates an expected call of Fatal.
func (mr *MockLoggerMockRecorder) Fatal(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fatal", reflect.TypeOf((*MockLogger)(nil).Fatal), args...)
}

// Fatalf mocks base method.
func (m *MockLogger) Fatalf(format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Fatalf", varargs...)
}

// Fatalf indicates an expected call of Fatalf.
func (mr *MockLoggerMockRecorder) Fatalf(format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fatalf", reflect.TypeOf((*MockLogger)(nil).Fatalf), varargs...)
}

// Fatalln mocks base method.
func (m *MockLogger) Fatalln(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Fatalln", varargs...)
}

// Fatalln indicates an expected call of Fatalln.
func (mr *MockLoggerMockRecorder) Fatalln(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fatalln", reflect.TypeOf((*MockLogger)(nil).Fatalln), args...)
}

// Info mocks base method.
func (m *MockLogger) Info(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Info", varargs...)
}

// Info indicates an expected call of Info.
func (mr *MockLoggerMockRecorder) Info(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), args...)
}

// Infof mocks base method.
func (m *MockLogger) Infof(format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Infof", varargs...)
}

// Infof indicates an expected call of Infof.
func (mr *MockLoggerMockRecorder) Infof(format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Infof", reflect.TypeOf((*MockLogger)(nil).Infof), varargs...)
}

// Infoln mocks base method.
func (m *MockLogger) Infoln(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Infoln", varargs...)
}

// Infoln indicates an expected call of Infoln.
func (mr *MockLoggerMockRecorder) Infoln(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Infoln", reflect.TypeOf((*MockLogger)(nil).Infoln), args...)
}

// Panic mocks base method.
func (m *MockLogger) Panic(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Panic", varargs...)
}

// Panic indicates an expected call of Panic.
func (mr *MockLoggerMockRecorder) Panic(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Panic", reflect.TypeOf((*MockLogger)(nil).Panic), args...)
}

// Panicf mocks base method.
func (m *MockLogger) Panicf(format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Panicf", varargs...)
}

// Panicf indicates an expected call of Panicf.
func (mr *MockLoggerMockRecorder) Panicf(format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Panicf", reflect.TypeOf((*MockLogger)(nil).Panicf), varargs...)
}

// Panicln mocks base method.
func (m *MockLogger) Panicln(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Panicln", varargs...)
}

// Panicln indicates an expected call of Panicln.
func (mr *MockLoggerMockRecorder) Panicln(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Panicln", reflect.TypeOf((*MockLogger)(nil).Panicln), args...)
}

// Print mocks base method.
func (m *MockLogger) Print(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Print", varargs...)
}

// Print indicates an expected call of Print.
func (mr *MockLoggerMockRecorder) Print(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Print", reflect.TypeOf((*MockLogger)(nil).Print), args...)
}

// Printf mocks base method.
func (m *MockLogger) Printf(format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Printf", varargs...)
}

// Printf indicates an expected call of Printf.
func (mr *MockLoggerMockRecorder) Printf(format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Printf", reflect.TypeOf((*MockLogger)(nil).Printf), varargs...)
}

// Println mocks base method.
func (m *MockLogger) Println(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Println", varargs...)
}

// Println indicates an expected call of Println.
func (mr *MockLoggerMockRecorder) Println(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Println", reflect.TypeOf((*MockLogger)(nil).Println), args...)
}

// Trace mocks base method.
func (m *MockLogger) Trace(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Trace", varargs...)
}

// Trace indicates an expected call of Trace.
func (mr *MockLoggerMockRecorder) Trace(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trace", reflect.TypeOf((*MockLogger)(nil).Trace), args...)
}

// Tracef mocks base method.
func (m *MockLogger) Tracef(format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Tracef", varargs...)
}

// Tracef indicates an expected call of Tracef.
func (mr *MockLoggerMockRecorder) Tracef(format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tracef", reflect.TypeOf((*MockLogger)(nil).Tracef), varargs...)
}

// Traceln mocks base method.
func (m *MockLogger) Traceln(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Traceln", varargs...)
}

// Traceln indicates an expected call of Traceln.
func (mr *MockLoggerMockRecorder) Traceln(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Traceln", reflect.TypeOf((*MockLogger)(nil).Traceln), args...)
}

// Warn mocks base method.
func (m *MockLogger) Warn(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Warn", varargs...)
}

// Warn indicates an expected call of Warn.
func (mr *MockLoggerMockRecorder) Warn(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warn", reflect.TypeOf((*MockLogger)(nil).Warn), args...)
}

// Warnf mocks base method.
func (m *MockLogger) Warnf(format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Warnf", varargs...)
}

// Warnf indicates an expected call of Warnf.
func (mr *MockLoggerMockRecorder) Warnf(format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warnf", reflect.TypeOf((*MockLogger)(nil).Warnf), varargs...)
}

// Warnln mocks base method.
func (m *MockLogger) Warnln(args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Warnln", varargs...)
}

// Warnln indicates an expected call of Warnln.
func (mr *MockLoggerMockRecorder) Warnln(args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warnln", reflect.TypeOf((*MockLogger)(nil).Warnln), args...)
}

// MockTracer is a mock of Tracer interface.
type MockTracer struct {
	ctrl     *gomock.Controller
	recorder *MockTracerMockRecorder
	isgomock struct{}
}

// MockTracerMockRecorder is the mock recorder for MockTracer.
type MockTracerMockRecorder struct {
	mock *MockTracer
}

// NewMockTracer creates a new mock instance.
func NewMockTracer(ctrl *gomock.Controller) *MockTracer {
	mock := &MockTracer{ctrl: ctrl}
	mock.recorder = &MockTracerMockRecorder{mock}
	return mock
}

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

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

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

// Go mocks base method.
func (m *MockTracer) Go(fn func()) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Go", fn)
}

// Go indicates an expected call of Go.
func (mr *MockTracerMockRecorder) Go(fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Go", reflect.TypeOf((*MockTracer)(nil).Go), fn)
}

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

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

// RecoverSetTraceId mocks base method.
func (m *MockTracer) RecoverSetTraceId(traceId string, fn func()) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecoverSetTraceId", traceId, fn)
}

// RecoverSetTraceId indicates an expected call of RecoverSetTraceId.
func (mr *MockTracerMockRecorder) RecoverSetTraceId(traceId, fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecoverSetTraceId", reflect.TypeOf((*MockTracer)(nil).RecoverSetTraceId), traceId, fn)
}

// SetTraceId mocks base method.
func (m *MockTracer) SetTraceId(traceId string, fn func()) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTraceId", traceId, fn)
}

// SetTraceId indicates an expected call of SetTraceId.
func (mr *MockTracerMockRecorder) SetTraceId(traceId, fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTraceId", reflect.TypeOf((*MockTracer)(nil).SetTraceId), traceId, fn)
}

// MockXormEngine is a mock of XormEngine interface.
type MockXormEngine struct {
	ctrl     *gomock.Controller
	recorder *MockXormEngineMockRecorder
	isgomock struct{}
}

// MockXormEngineMockRecorder is the mock recorder for MockXormEngine.
type MockXormEngineMockRecorder struct {
	mock *MockXormEngine
}

// NewMockXormEngine creates a new mock instance.
func NewMockXormEngine(ctrl *gomock.Controller) *MockXormEngine {
	mock := &MockXormEngine{ctrl: ctrl}
	mock.recorder = &MockXormEngineMockRecorder{mock}
	return mock
}

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

// AddHook mocks base method.
func (m *MockXormEngine) AddHook(hook contexts.Hook) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddHook", hook)
}

// AddHook indicates an expected call of AddHook.
func (mr *MockXormEngineMockRecorder) AddHook(hook any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHook", reflect.TypeOf((*MockXormEngine)(nil).AddHook), hook)
}

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

// Alias indicates an expected call of Alias.
func (mr *MockXormEngineMockRecorder) Alias(alias any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Alias", reflect.TypeOf((*MockXormEngine)(nil).Alias), alias)
}

// AllCols mocks base method.
func (m *MockXormEngine) AllCols() *xorm.Session {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllCols")
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

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

// Asc mocks base method.
func (m *MockXormEngine) Asc(colNames ...string) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range colNames {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Asc", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Asc indicates an expected call of Asc.
func (mr *MockXormEngineMockRecorder) Asc(colNames ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Asc", reflect.TypeOf((*MockXormEngine)(nil).Asc), colNames...)
}

// Before mocks base method.
func (m *MockXormEngine) Before(arg0 func(any)) *xorm.Session {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Before", arg0)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Before indicates an expected call of Before.
func (mr *MockXormEngineMockRecorder) Before(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Before", reflect.TypeOf((*MockXormEngine)(nil).Before), arg0)
}

// BufferSize mocks base method.
func (m *MockXormEngine) BufferSize(size int) *xorm.Session {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BufferSize", size)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// BufferSize indicates an expected call of BufferSize.
func (mr *MockXormEngineMockRecorder) BufferSize(size any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BufferSize", reflect.TypeOf((*MockXormEngine)(nil).BufferSize), size)
}

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

// Charset indicates an expected call of Charset.
func (mr *MockXormEngineMockRecorder) Charset(charset any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Charset", reflect.TypeOf((*MockXormEngine)(nil).Charset), charset)
}

// ClearCache mocks base method.
func (m *MockXormEngine) ClearCache(arg0 ...any) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ClearCache", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ClearCache indicates an expected call of ClearCache.
func (mr *MockXormEngineMockRecorder) ClearCache(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearCache", reflect.TypeOf((*MockXormEngine)(nil).ClearCache), arg0...)
}

// Cols mocks base method.
func (m *MockXormEngine) Cols(columns ...string) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range columns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Cols", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Cols indicates an expected call of Cols.
func (mr *MockXormEngineMockRecorder) Cols(columns ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cols", reflect.TypeOf((*MockXormEngine)(nil).Cols), columns...)
}

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

// Context indicates an expected call of Context.
func (mr *MockXormEngineMockRecorder) Context(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockXormEngine)(nil).Context), arg0)
}

// Count mocks base method.
func (m *MockXormEngine) Count(arg0 ...any) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Count", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// CreateIndexes indicates an expected call of CreateIndexes.
func (mr *MockXormEngineMockRecorder) CreateIndexes(bean any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIndexes", reflect.TypeOf((*MockXormEngine)(nil).CreateIndexes), bean)
}

// CreateTables mocks base method.
func (m *MockXormEngine) CreateTables(arg0 ...any) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTables", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateTables indicates an expected call of CreateTables.
func (mr *MockXormEngineMockRecorder) CreateTables(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTables", reflect.TypeOf((*MockXormEngine)(nil).CreateTables), arg0...)
}

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

// CreateUniques indicates an expected call of CreateUniques.
func (mr *MockXormEngineMockRecorder) CreateUniques(bean any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUniques", reflect.TypeOf((*MockXormEngine)(nil).CreateUniques), bean)
}

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

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

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

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

// Decr mocks base method.
func (m *MockXormEngine) Decr(column string, arg ...any) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{column}
	for _, a := range arg {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Decr", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Decr indicates an expected call of Decr.
func (mr *MockXormEngineMockRecorder) Decr(column any, arg ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{column}, arg...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decr", reflect.TypeOf((*MockXormEngine)(nil).Decr), varargs...)
}

// Delete mocks base method.
func (m *MockXormEngine) Delete(arg0 ...any) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Delete", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Desc mocks base method.
func (m *MockXormEngine) Desc(arg0 ...string) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Desc", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Desc indicates an expected call of Desc.
func (mr *MockXormEngineMockRecorder) Desc(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Desc", reflect.TypeOf((*MockXormEngine)(nil).Desc), arg0...)
}

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

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

// Distinct mocks base method.
func (m *MockXormEngine) Distinct(columns ...string) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range columns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Distinct", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Distinct indicates an expected call of Distinct.
func (mr *MockXormEngineMockRecorder) Distinct(columns ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Distinct", reflect.TypeOf((*MockXormEngine)(nil).Distinct), columns...)
}

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

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

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

// DropIndexes indicates an expected call of DropIndexes.
func (mr *MockXormEngineMockRecorder) DropIndexes(bean any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropIndexes", reflect.TypeOf((*MockXormEngine)(nil).DropIndexes), bean)
}

// DropTables mocks base method.
func (m *MockXormEngine) DropTables(arg0 ...any) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DropTables", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DropTables indicates an expected call of DropTables.
func (mr *MockXormEngineMockRecorder) DropTables(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropTables", reflect.TypeOf((*MockXormEngine)(nil).DropTables), arg0...)
}

// DumpAllToFile mocks base method.
func (m *MockXormEngine) DumpAllToFile(fp string, tp ...schemas.DBType) error {
	m.ctrl.T.Helper()
	varargs := []any{fp}
	for _, a := range tp {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DumpAllToFile", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DumpAllToFile indicates an expected call of DumpAllToFile.
func (mr *MockXormEngineMockRecorder) DumpAllToFile(fp any, tp ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{fp}, tp...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DumpAllToFile", reflect.TypeOf((*MockXormEngine)(nil).DumpAllToFile), varargs...)
}

// EnableSessionID mocks base method.
func (m *MockXormEngine) EnableSessionID(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnableSessionID", arg0)
}

// EnableSessionID indicates an expected call of EnableSessionID.
func (mr *MockXormEngineMockRecorder) EnableSessionID(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSessionID", reflect.TypeOf((*MockXormEngine)(nil).EnableSessionID), arg0)
}

// Exec mocks base method.
func (m *MockXormEngine) Exec(sqlOrArgs ...any) (sql.Result, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range sqlOrArgs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Exec", varargs...)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Exec indicates an expected call of Exec.
func (mr *MockXormEngineMockRecorder) Exec(sqlOrArgs ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockXormEngine)(nil).Exec), sqlOrArgs...)
}

// Exist mocks base method.
func (m *MockXormEngine) Exist(bean ...any) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range bean {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Exist", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Exist indicates an expected call of Exist.
func (mr *MockXormEngineMockRecorder) Exist(bean ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exist", reflect.TypeOf((*MockXormEngine)(nil).Exist), bean...)
}

// Find mocks base method.
func (m *MockXormEngine) Find(arg0 any, arg1 ...any) error {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Find", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// FindAndCount mocks base method.
func (m *MockXormEngine) FindAndCount(arg0 any, arg1 ...any) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindAndCount", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Get mocks base method.
func (m *MockXormEngine) Get(arg0 ...any) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Get", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// GetCacher indicates an expected call of GetCacher.
func (mr *MockXormEngineMockRecorder) GetCacher(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCacher", reflect.TypeOf((*MockXormEngine)(nil).GetCacher), arg0)
}

// GetColumnMapper mocks base method.
func (m *MockXormEngine) GetColumnMapper() names.Mapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetColumnMapper")
	ret0, _ := ret[0].(names.Mapper)
	return ret0
}

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

// GetDefaultCacher mocks base method.
func (m *MockXormEngine) GetDefaultCacher() caches.Cacher {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultCacher")
	ret0, _ := ret[0].(caches.Cacher)
	return ret0
}

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

// GetOriginEngine mocks base method.
func (m *MockXormEngine) GetOriginEngine() xorm.EngineInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOriginEngine")
	ret0, _ := ret[0].(xorm.EngineInterface)
	return ret0
}

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

// GetTZDatabase mocks base method.
func (m *MockXormEngine) GetTZDatabase() *time.Location {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTZDatabase")
	ret0, _ := ret[0].(*time.Location)
	return ret0
}

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

// GetTZLocation mocks base method.
func (m *MockXormEngine) GetTZLocation() *time.Location {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTZLocation")
	ret0, _ := ret[0].(*time.Location)
	return ret0
}

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

// GetTableMapper mocks base method.
func (m *MockXormEngine) GetTableMapper() names.Mapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTableMapper")
	ret0, _ := ret[0].(names.Mapper)
	return ret0
}

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

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

// GroupBy indicates an expected call of GroupBy.
func (mr *MockXormEngineMockRecorder) GroupBy(keys any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupBy", reflect.TypeOf((*MockXormEngine)(nil).GroupBy), keys)
}

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

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

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

// ImportFile indicates an expected call of ImportFile.
func (mr *MockXormEngineMockRecorder) ImportFile(fp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportFile", reflect.TypeOf((*MockXormEngine)(nil).ImportFile), fp)
}

// In mocks base method.
func (m *MockXormEngine) In(arg0 string, arg1 ...any) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "In", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

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

// Incr mocks base method.
func (m *MockXormEngine) Incr(column string, arg ...any) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{column}
	for _, a := range arg {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Incr", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Incr indicates an expected call of Incr.
func (mr *MockXormEngineMockRecorder) Incr(column any, arg ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{column}, arg...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockXormEngine)(nil).Incr), varargs...)
}

// Insert mocks base method.
func (m *MockXormEngine) Insert(arg0 ...any) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Insert", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Insert indicates an expected call of Insert.
func (mr *MockXormEngineMockRecorder) Insert(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockXormEngine)(nil).Insert), arg0...)
}

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

// InsertOne indicates an expected call of InsertOne.
func (mr *MockXormEngineMockRecorder) InsertOne(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOne", reflect.TypeOf((*MockXormEngine)(nil).InsertOne), arg0)
}

// IsTableEmpty mocks base method.
func (m *MockXormEngine) IsTableEmpty(bean any) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsTableEmpty", bean)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsTableEmpty indicates an expected call of IsTableEmpty.
func (mr *MockXormEngineMockRecorder) IsTableEmpty(bean any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsTableEmpty", reflect.TypeOf((*MockXormEngine)(nil).IsTableEmpty), bean)
}

// IsTableExist mocks base method.
func (m *MockXormEngine) IsTableExist(beanOrTableName any) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsTableExist", beanOrTableName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsTableExist indicates an expected call of IsTableExist.
func (mr *MockXormEngineMockRecorder) IsTableExist(beanOrTableName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsTableExist", reflect.TypeOf((*MockXormEngine)(nil).IsTableExist), beanOrTableName)
}

// Iterate mocks base method.
func (m *MockXormEngine) Iterate(arg0 any, arg1 xorm.IterFunc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Iterate", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Iterate indicates an expected call of Iterate.
func (mr *MockXormEngineMockRecorder) Iterate(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockXormEngine)(nil).Iterate), arg0, arg1)
}

// Join mocks base method.
func (m *MockXormEngine) Join(joinOperator string, tablename any, condition string, args ...any) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{joinOperator, tablename, condition}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Join", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Join indicates an expected call of Join.
func (mr *MockXormEngineMockRecorder) Join(joinOperator, tablename, condition any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{joinOperator, tablename, condition}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Join", reflect.TypeOf((*MockXormEngine)(nil).Join), varargs...)
}

// Limit mocks base method.
func (m *MockXormEngine) Limit(arg0 int, arg1 ...int) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Limit", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

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

// MapCacher mocks base method.
func (m *MockXormEngine) MapCacher(arg0 any, arg1 caches.Cacher) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MapCacher", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// MapCacher indicates an expected call of MapCacher.
func (mr *MockXormEngineMockRecorder) MapCacher(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MapCacher", reflect.TypeOf((*MockXormEngine)(nil).MapCacher), arg0, arg1)
}

// MustCols mocks base method.
func (m *MockXormEngine) MustCols(columns ...string) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range columns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MustCols", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// MustCols indicates an expected call of MustCols.
func (mr *MockXormEngineMockRecorder) MustCols(columns ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MustCols", reflect.TypeOf((*MockXormEngine)(nil).MustCols), columns...)
}

// NewSession mocks base method.
func (m *MockXormEngine) NewSession() *xorm.Session {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSession")
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

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

// NoAutoCondition mocks base method.
func (m *MockXormEngine) NoAutoCondition(arg0 ...bool) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NoAutoCondition", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// NoAutoCondition indicates an expected call of NoAutoCondition.
func (mr *MockXormEngineMockRecorder) NoAutoCondition(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NoAutoCondition", reflect.TypeOf((*MockXormEngine)(nil).NoAutoCondition), arg0...)
}

// NoAutoTime mocks base method.
func (m *MockXormEngine) NoAutoTime() *xorm.Session {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NoAutoTime")
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

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

// NotIn mocks base method.
func (m *MockXormEngine) NotIn(arg0 string, arg1 ...any) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NotIn", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

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

// Nullable mocks base method.
func (m *MockXormEngine) Nullable(arg0 ...string) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Nullable", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Nullable indicates an expected call of Nullable.
func (mr *MockXormEngineMockRecorder) Nullable(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nullable", reflect.TypeOf((*MockXormEngine)(nil).Nullable), arg0...)
}

// Omit mocks base method.
func (m *MockXormEngine) Omit(columns ...string) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range columns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Omit", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Omit indicates an expected call of Omit.
func (mr *MockXormEngineMockRecorder) Omit(columns ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Omit", reflect.TypeOf((*MockXormEngine)(nil).Omit), columns...)
}

// OrderBy mocks base method.
func (m *MockXormEngine) OrderBy(order any, args ...any) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{order}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OrderBy", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// OrderBy indicates an expected call of OrderBy.
func (mr *MockXormEngineMockRecorder) OrderBy(order any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{order}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrderBy", reflect.TypeOf((*MockXormEngine)(nil).OrderBy), varargs...)
}

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

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

// Prepare mocks base method.
func (m *MockXormEngine) Prepare() *xorm.Session {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Prepare")
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

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

// Query mocks base method.
func (m *MockXormEngine) Query(sqlOrArgs ...any) ([]map[string][]byte, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range sqlOrArgs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Query", varargs...)
	ret0, _ := ret[0].([]map[string][]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Query indicates an expected call of Query.
func (mr *MockXormEngineMockRecorder) Query(sqlOrArgs ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockXormEngine)(nil).Query), sqlOrArgs...)
}

// QueryInterface mocks base method.
func (m *MockXormEngine) QueryInterface(sqlOrArgs ...any) ([]map[string]any, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range sqlOrArgs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryInterface", varargs...)
	ret0, _ := ret[0].([]map[string]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryInterface indicates an expected call of QueryInterface.
func (mr *MockXormEngineMockRecorder) QueryInterface(sqlOrArgs ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryInterface", reflect.TypeOf((*MockXormEngine)(nil).QueryInterface), sqlOrArgs...)
}

// QueryString mocks base method.
func (m *MockXormEngine) QueryString(sqlOrArgs ...any) ([]map[string]string, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range sqlOrArgs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryString", varargs...)
	ret0, _ := ret[0].([]map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryString indicates an expected call of QueryString.
func (mr *MockXormEngineMockRecorder) QueryString(sqlOrArgs ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryString", reflect.TypeOf((*MockXormEngine)(nil).QueryString), sqlOrArgs...)
}

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

// Quote indicates an expected call of Quote.
func (mr *MockXormEngineMockRecorder) Quote(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quote", reflect.TypeOf((*MockXormEngine)(nil).Quote), arg0)
}

// Rows mocks base method.
func (m *MockXormEngine) Rows(bean any) (*xorm.Rows, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rows", bean)
	ret0, _ := ret[0].(*xorm.Rows)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Rows indicates an expected call of Rows.
func (mr *MockXormEngineMockRecorder) Rows(bean any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rows", reflect.TypeOf((*MockXormEngine)(nil).Rows), bean)
}

// SQL mocks base method.
func (m *MockXormEngine) SQL(arg0 any, arg1 ...any) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SQL", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

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

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

// Select indicates an expected call of Select.
func (mr *MockXormEngineMockRecorder) Select(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Select", reflect.TypeOf((*MockXormEngine)(nil).Select), arg0)
}

// SetCacher mocks base method.
func (m *MockXormEngine) SetCacher(arg0 string, arg1 caches.Cacher) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCacher", arg0, arg1)
}

// SetCacher indicates an expected call of SetCacher.
func (mr *MockXormEngineMockRecorder) SetCacher(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCacher", reflect.TypeOf((*MockXormEngine)(nil).SetCacher), arg0, arg1)
}

// SetColumnMapper mocks base method.
func (m *MockXormEngine) SetColumnMapper(arg0 names.Mapper) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetColumnMapper", arg0)
}

// SetColumnMapper indicates an expected call of SetColumnMapper.
func (mr *MockXormEngineMockRecorder) SetColumnMapper(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetColumnMapper", reflect.TypeOf((*MockXormEngine)(nil).SetColumnMapper), arg0)
}

// SetConnMaxLifetime mocks base method.
func (m *MockXormEngine) SetConnMaxLifetime(arg0 time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetConnMaxLifetime", arg0)
}

// SetConnMaxLifetime indicates an expected call of SetConnMaxLifetime.
func (mr *MockXormEngineMockRecorder) SetConnMaxLifetime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConnMaxLifetime", reflect.TypeOf((*MockXormEngine)(nil).SetConnMaxLifetime), arg0)
}

// SetDefaultCacher mocks base method.
func (m *MockXormEngine) SetDefaultCacher(arg0 caches.Cacher) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetDefaultCacher", arg0)
}

// SetDefaultCacher indicates an expected call of SetDefaultCacher.
func (mr *MockXormEngineMockRecorder) SetDefaultCacher(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultCacher", reflect.TypeOf((*MockXormEngine)(nil).SetDefaultCacher), arg0)
}

// SetExpr mocks base method.
func (m *MockXormEngine) SetExpr(arg0 string, arg1 any) *xorm.Session {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetExpr", arg0, arg1)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// SetExpr indicates an expected call of SetExpr.
func (mr *MockXormEngineMockRecorder) SetExpr(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpr", reflect.TypeOf((*MockXormEngine)(nil).SetExpr), arg0, arg1)
}

// SetLogLevel mocks base method.
func (m *MockXormEngine) SetLogLevel(arg0 log.LogLevel) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogLevel", arg0)
}

// SetLogLevel indicates an expected call of SetLogLevel.
func (mr *MockXormEngineMockRecorder) SetLogLevel(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogLevel", reflect.TypeOf((*MockXormEngine)(nil).SetLogLevel), arg0)
}

// SetLogger mocks base method.
func (m *MockXormEngine) SetLogger(logger any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogger", logger)
}

// SetLogger indicates an expected call of SetLogger.
func (mr *MockXormEngineMockRecorder) SetLogger(logger any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogger", reflect.TypeOf((*MockXormEngine)(nil).SetLogger), logger)
}

// SetMapper mocks base method.
func (m *MockXormEngine) SetMapper(arg0 names.Mapper) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMapper", arg0)
}

// SetMapper indicates an expected call of SetMapper.
func (mr *MockXormEngineMockRecorder) SetMapper(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMapper", reflect.TypeOf((*MockXormEngine)(nil).SetMapper), arg0)
}

// SetMaxIdleConns mocks base method.
func (m *MockXormEngine) SetMaxIdleConns(arg0 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxIdleConns", arg0)
}

// SetMaxIdleConns indicates an expected call of SetMaxIdleConns.
func (mr *MockXormEngineMockRecorder) SetMaxIdleConns(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxIdleConns", reflect.TypeOf((*MockXormEngine)(nil).SetMaxIdleConns), arg0)
}

// SetMaxOpenConns mocks base method.
func (m *MockXormEngine) SetMaxOpenConns(arg0 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxOpenConns", arg0)
}

// SetMaxOpenConns indicates an expected call of SetMaxOpenConns.
func (mr *MockXormEngineMockRecorder) SetMaxOpenConns(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxOpenConns", reflect.TypeOf((*MockXormEngine)(nil).SetMaxOpenConns), arg0)
}

// SetQuotePolicy mocks base method.
func (m *MockXormEngine) SetQuotePolicy(arg0 dialects.QuotePolicy) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetQuotePolicy", arg0)
}

// SetQuotePolicy indicates an expected call of SetQuotePolicy.
func (mr *MockXormEngineMockRecorder) SetQuotePolicy(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQuotePolicy", reflect.TypeOf((*MockXormEngine)(nil).SetQuotePolicy), arg0)
}

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

// SetSchema indicates an expected call of SetSchema.
func (mr *MockXormEngineMockRecorder) SetSchema(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSchema", reflect.TypeOf((*MockXormEngine)(nil).SetSchema), arg0)
}

// SetTZDatabase mocks base method.
func (m *MockXormEngine) SetTZDatabase(tz *time.Location) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTZDatabase", tz)
}

// SetTZDatabase indicates an expected call of SetTZDatabase.
func (mr *MockXormEngineMockRecorder) SetTZDatabase(tz any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTZDatabase", reflect.TypeOf((*MockXormEngine)(nil).SetTZDatabase), tz)
}

// SetTZLocation mocks base method.
func (m *MockXormEngine) SetTZLocation(tz *time.Location) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTZLocation", tz)
}

// SetTZLocation indicates an expected call of SetTZLocation.
func (mr *MockXormEngineMockRecorder) SetTZLocation(tz any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTZLocation", reflect.TypeOf((*MockXormEngine)(nil).SetTZLocation), tz)
}

// SetTableMapper mocks base method.
func (m *MockXormEngine) SetTableMapper(arg0 names.Mapper) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTableMapper", arg0)
}

// SetTableMapper indicates an expected call of SetTableMapper.
func (mr *MockXormEngineMockRecorder) SetTableMapper(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTableMapper", reflect.TypeOf((*MockXormEngine)(nil).SetTableMapper), arg0)
}

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

// SetTagIdentifier indicates an expected call of SetTagIdentifier.
func (mr *MockXormEngineMockRecorder) SetTagIdentifier(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTagIdentifier", reflect.TypeOf((*MockXormEngine)(nil).SetTagIdentifier), arg0)
}

// ShowSQL mocks base method.
func (m *MockXormEngine) ShowSQL(show ...bool) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range show {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "ShowSQL", varargs...)
}

// ShowSQL indicates an expected call of ShowSQL.
func (mr *MockXormEngineMockRecorder) ShowSQL(show ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShowSQL", reflect.TypeOf((*MockXormEngine)(nil).ShowSQL), show...)
}

// Sqlx mocks base method.
func (m *MockXormEngine) Sqlx(sql string, args ...any) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{sql}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Sqlx", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Sqlx indicates an expected call of Sqlx.
func (mr *MockXormEngineMockRecorder) Sqlx(sql any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{sql}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sqlx", reflect.TypeOf((*MockXormEngine)(nil).Sqlx), varargs...)
}

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

// StoreEngine indicates an expected call of StoreEngine.
func (mr *MockXormEngineMockRecorder) StoreEngine(storeEngine any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreEngine", reflect.TypeOf((*MockXormEngine)(nil).StoreEngine), storeEngine)
}

// Sum mocks base method.
func (m *MockXormEngine) Sum(bean any, colName string) (float64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sum", bean, colName)
	ret0, _ := ret[0].(float64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Sum indicates an expected call of Sum.
func (mr *MockXormEngineMockRecorder) Sum(bean, colName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sum", reflect.TypeOf((*MockXormEngine)(nil).Sum), bean, colName)
}

// SumInt mocks base method.
func (m *MockXormEngine) SumInt(bean any, colName string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SumInt", bean, colName)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SumInt indicates an expected call of SumInt.
func (mr *MockXormEngineMockRecorder) SumInt(bean, colName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SumInt", reflect.TypeOf((*MockXormEngine)(nil).SumInt), bean, colName)
}

// Sums mocks base method.
func (m *MockXormEngine) Sums(bean any, colNames ...string) ([]float64, error) {
	m.ctrl.T.Helper()
	varargs := []any{bean}
	for _, a := range colNames {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Sums", varargs...)
	ret0, _ := ret[0].([]float64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Sums indicates an expected call of Sums.
func (mr *MockXormEngineMockRecorder) Sums(bean any, colNames ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{bean}, colNames...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sums", reflect.TypeOf((*MockXormEngine)(nil).Sums), varargs...)
}

// SumsInt mocks base method.
func (m *MockXormEngine) SumsInt(bean any, colNames ...string) ([]int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{bean}
	for _, a := range colNames {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SumsInt", varargs...)
	ret0, _ := ret[0].([]int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SumsInt indicates an expected call of SumsInt.
func (mr *MockXormEngineMockRecorder) SumsInt(bean any, colNames ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{bean}, colNames...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SumsInt", reflect.TypeOf((*MockXormEngine)(nil).SumsInt), varargs...)
}

// Sync mocks base method.
func (m *MockXormEngine) Sync(arg0 ...any) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Sync", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Sync indicates an expected call of Sync.
func (mr *MockXormEngineMockRecorder) Sync(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockXormEngine)(nil).Sync), arg0...)
}

// Sync2 mocks base method.
func (m *MockXormEngine) Sync2(arg0 ...any) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Sync2", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Sync2 indicates an expected call of Sync2.
func (mr *MockXormEngineMockRecorder) Sync2(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync2", reflect.TypeOf((*MockXormEngine)(nil).Sync2), arg0...)
}

// Table mocks base method.
func (m *MockXormEngine) Table(tableNameOrBean any) *xorm.Session {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Table", tableNameOrBean)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// Table indicates an expected call of Table.
func (mr *MockXormEngineMockRecorder) Table(tableNameOrBean any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Table", reflect.TypeOf((*MockXormEngine)(nil).Table), tableNameOrBean)
}

// TableInfo mocks base method.
func (m *MockXormEngine) TableInfo(bean any) (*schemas.Table, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TableInfo", bean)
	ret0, _ := ret[0].(*schemas.Table)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TableInfo indicates an expected call of TableInfo.
func (mr *MockXormEngineMockRecorder) TableInfo(bean any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TableInfo", reflect.TypeOf((*MockXormEngine)(nil).TableInfo), bean)
}

// TableName mocks base method.
func (m *MockXormEngine) TableName(arg0 any, arg1 ...bool) string {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TableName", varargs...)
	ret0, _ := ret[0].(string)
	return ret0
}

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

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

// Transaction indicates an expected call of Transaction.
func (mr *MockXormEngineMockRecorder) Transaction(fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transaction", reflect.TypeOf((*MockXormEngine)(nil).Transaction), fn)
}

// UnMapType mocks base method.
func (m *MockXormEngine) UnMapType(arg0 reflect.Type) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UnMapType", arg0)
}

// UnMapType indicates an expected call of UnMapType.
func (mr *MockXormEngineMockRecorder) UnMapType(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnMapType", reflect.TypeOf((*MockXormEngine)(nil).UnMapType), arg0)
}

// Unscoped mocks base method.
func (m *MockXormEngine) Unscoped() *xorm.Session {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unscoped")
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

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

// Update mocks base method.
func (m *MockXormEngine) Update(bean any, condiBeans ...any) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{bean}
	for _, a := range condiBeans {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Update", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockXormEngineMockRecorder) Update(bean any, condiBeans ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{bean}, condiBeans...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockXormEngine)(nil).Update), varargs...)
}

// UseBool mocks base method.
func (m *MockXormEngine) UseBool(arg0 ...string) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UseBool", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

// UseBool indicates an expected call of UseBool.
func (mr *MockXormEngineMockRecorder) UseBool(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseBool", reflect.TypeOf((*MockXormEngine)(nil).UseBool), arg0...)
}

// Where mocks base method.
func (m *MockXormEngine) Where(arg0 any, arg1 ...any) *xorm.Session {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Where", varargs...)
	ret0, _ := ret[0].(*xorm.Session)
	return ret0
}

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

// MockCMuxServer is a mock of CMuxServer interface.
type MockCMuxServer struct {
	ctrl     *gomock.Controller
	recorder *MockCMuxServerMockRecorder
	isgomock struct{}
}

// MockCMuxServerMockRecorder is the mock recorder for MockCMuxServer.
type MockCMuxServerMockRecorder struct {
	mock *MockCMuxServer
}

// NewMockCMuxServer creates a new mock instance.
func NewMockCMuxServer(ctrl *gomock.Controller) *MockCMuxServer {
	mock := &MockCMuxServer{ctrl: ctrl}
	mock.recorder = &MockCMuxServerMockRecorder{mock}
	return mock
}

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

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

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

// Match mocks base method.
func (m *MockCMuxServer) Match(matcher ...cmux.Matcher) net.Listener {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range matcher {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Match", varargs...)
	ret0, _ := ret[0].(net.Listener)
	return ret0
}

// Match indicates an expected call of Match.
func (mr *MockCMuxServerMockRecorder) Match(matcher ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Match", reflect.TypeOf((*MockCMuxServer)(nil).Match), matcher...)
}

// MatchWithWriters mocks base method.
func (m *MockCMuxServer) MatchWithWriters(matcher ...cmux.MatchWriter) net.Listener {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range matcher {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MatchWithWriters", varargs...)
	ret0, _ := ret[0].(net.Listener)
	return ret0
}

// MatchWithWriters indicates an expected call of MatchWithWriters.
func (mr *MockCMuxServerMockRecorder) MatchWithWriters(matcher ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatchWithWriters", reflect.TypeOf((*MockCMuxServer)(nil).MatchWithWriters), matcher...)
}

// MockConfigure is a mock of Configure interface.
type MockConfigure struct {
	ctrl     *gomock.Controller
	recorder *MockConfigureMockRecorder
	isgomock struct{}
}

// MockConfigureMockRecorder is the mock recorder for MockConfigure.
type MockConfigureMockRecorder struct {
	mock *MockConfigure
}

// NewMockConfigure creates a new mock instance.
func NewMockConfigure(ctrl *gomock.Controller) *MockConfigure {
	mock := &MockConfigure{ctrl: ctrl}
	mock.recorder = &MockConfigureMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockConfigure) Get(key string, v any, defaultVal string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key, v, defaultVal)
	ret0, _ := ret[0].(error)
	return ret0
}

// Get indicates an expected call of Get.
func (mr *MockConfigureMockRecorder) Get(key, v, defaultVal any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockConfigure)(nil).Get), key, v, defaultVal)
}

// MockNamedGoner is a mock of NamedGoner interface.
type MockNamedGoner struct {
	ctrl     *gomock.Controller
	recorder *MockNamedGonerMockRecorder
	isgomock struct{}
}

// MockNamedGonerMockRecorder is the mock recorder for MockNamedGoner.
type MockNamedGonerMockRecorder struct {
	mock *MockNamedGoner
}

// NewMockNamedGoner creates a new mock instance.
func NewMockNamedGoner(ctrl *gomock.Controller) *MockNamedGoner {
	mock := &MockNamedGoner{ctrl: ctrl}
	mock.recorder = &MockNamedGonerMockRecorder{mock}
	return mock
}

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

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

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