mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: code.vegaprotocol.io/vega/core/execution/common (interfaces: TimeService,Assets,StateVarEngine,Collateral,OracleEngine,EpochEngine,AuctionState,LiquidityEngine,EquityLikeShares,MarketLiquidityEngine,Teams,AccountBalanceChecker,Banking)

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

import (
	context "context"
	reflect "reflect"
	time "time"

	assets "code.vegaprotocol.io/vega/core/assets"
	common "code.vegaprotocol.io/vega/core/datasource/common"
	spec "code.vegaprotocol.io/vega/core/datasource/spec"
	events "code.vegaprotocol.io/vega/core/events"
	liquidity "code.vegaprotocol.io/vega/core/liquidity/v2"
	types "code.vegaprotocol.io/vega/core/types"
	statevar "code.vegaprotocol.io/vega/core/types/statevar"
	num "code.vegaprotocol.io/vega/libs/num"
	vega "code.vegaprotocol.io/vega/protos/vega"
	gomock "github.com/golang/mock/gomock"
	decimal "github.com/shopspring/decimal"
)

// MockTimeService is a mock of TimeService interface.
type MockTimeService struct {
	ctrl     *gomock.Controller
	recorder *MockTimeServiceMockRecorder
}

// MockTimeServiceMockRecorder is the mock recorder for MockTimeService.
type MockTimeServiceMockRecorder struct {
	mock *MockTimeService
}

// NewMockTimeService creates a new mock instance.
func NewMockTimeService(ctrl *gomock.Controller) *MockTimeService {
	mock := &MockTimeService{ctrl: ctrl}
	mock.recorder = &MockTimeServiceMockRecorder{mock}
	return mock
}

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

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

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

// MockAssets is a mock of Assets interface.
type MockAssets struct {
	ctrl     *gomock.Controller
	recorder *MockAssetsMockRecorder
}

// MockAssetsMockRecorder is the mock recorder for MockAssets.
type MockAssetsMockRecorder struct {
	mock *MockAssets
}

// NewMockAssets creates a new mock instance.
func NewMockAssets(ctrl *gomock.Controller) *MockAssets {
	mock := &MockAssets{ctrl: ctrl}
	mock.recorder = &MockAssetsMockRecorder{mock}
	return mock
}

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

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

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

// MockStateVarEngine is a mock of StateVarEngine interface.
type MockStateVarEngine struct {
	ctrl     *gomock.Controller
	recorder *MockStateVarEngineMockRecorder
}

// MockStateVarEngineMockRecorder is the mock recorder for MockStateVarEngine.
type MockStateVarEngineMockRecorder struct {
	mock *MockStateVarEngine
}

// NewMockStateVarEngine creates a new mock instance.
func NewMockStateVarEngine(ctrl *gomock.Controller) *MockStateVarEngine {
	mock := &MockStateVarEngine{ctrl: ctrl}
	mock.recorder = &MockStateVarEngineMockRecorder{mock}
	return mock
}

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

// NewEvent mocks base method.
func (m *MockStateVarEngine) NewEvent(arg0, arg1 string, arg2 statevar.EventType) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NewEvent", arg0, arg1, arg2)
}

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

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

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

// RegisterStateVariable mocks base method.
func (m *MockStateVarEngine) RegisterStateVariable(arg0, arg1, arg2 string, arg3 statevar.Converter, arg4 func(string, statevar.FinaliseCalculation), arg5 []statevar.EventType, arg6 func(context.Context, statevar.StateVariableResult) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterStateVariable", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// MockCollateral is a mock of Collateral interface.
type MockCollateral struct {
	ctrl     *gomock.Controller
	recorder *MockCollateralMockRecorder
}

// MockCollateralMockRecorder is the mock recorder for MockCollateral.
type MockCollateralMockRecorder struct {
	mock *MockCollateral
}

// NewMockCollateral creates a new mock instance.
func NewMockCollateral(ctrl *gomock.Controller) *MockCollateral {
	mock := &MockCollateral{ctrl: ctrl}
	mock.recorder = &MockCollateralMockRecorder{mock}
	return mock
}

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

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

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

// BondSpotUpdate mocks base method.
func (m *MockCollateral) BondSpotUpdate(arg0 context.Context, arg1 string, arg2 *types.Transfer) (*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BondSpotUpdate", arg0, arg1, arg2)
	ret0, _ := ret[0].(*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BondUpdate mocks base method.
func (m *MockCollateral) BondUpdate(arg0 context.Context, arg1 string, arg2 *types.Transfer) (*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BondUpdate", arg0, arg1, arg2)
	ret0, _ := ret[0].(*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CanCoverBond mocks base method.
func (m *MockCollateral) CanCoverBond(arg0, arg1, arg2 string, arg3 *num.Uint) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CanCoverBond", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(bool)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Deposit mocks base method.
func (m *MockCollateral) Deposit(arg0 context.Context, arg1, arg2 string, arg3 *num.Uint) (*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Deposit", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// FinalSettlement mocks base method.
func (m *MockCollateral) FinalSettlement(arg0 context.Context, arg1 string, arg2 []*types.Transfer, arg3 *num.Uint, arg4 func(string) bool) ([]*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalSettlement", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// IsolatedMarginUpdate mocks base method.
func (m *MockCollateral) IsolatedMarginUpdate(arg0 []events.Risk) []events.Margin {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsolatedMarginUpdate", arg0)
	ret0, _ := ret[0].([]events.Margin)
	return ret0
}

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

// MarginUpdate mocks base method.
func (m *MockCollateral) MarginUpdate(arg0 context.Context, arg1 string, arg2 []events.Risk) ([]*types.LedgerMovement, []events.Margin, []events.Margin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarginUpdate", arg0, arg1, arg2)
	ret0, _ := ret[0].([]*types.LedgerMovement)
	ret1, _ := ret[1].([]events.Margin)
	ret2, _ := ret[2].([]events.Margin)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// MarginUpdateOnOrder mocks base method.
func (m *MockCollateral) MarginUpdateOnOrder(arg0 context.Context, arg1 string, arg2 events.Risk) (*types.LedgerMovement, events.Margin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarginUpdateOnOrder", arg0, arg1, arg2)
	ret0, _ := ret[0].(*types.LedgerMovement)
	ret1, _ := ret[1].(events.Margin)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// MarkToMarket mocks base method.
func (m *MockCollateral) MarkToMarket(arg0 context.Context, arg1 string, arg2 []events.Transfer, arg3 string, arg4 func(string) bool) ([]events.Margin, []*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkToMarket", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].([]events.Margin)
	ret1, _ := ret[1].([]*types.LedgerMovement)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// PartyCanCoverFees mocks base method.
func (m *MockCollateral) PartyCanCoverFees(arg0, arg1, arg2 string, arg3 *num.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PartyCanCoverFees", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// PerpsFundingSettlement mocks base method.
func (m *MockCollateral) PerpsFundingSettlement(arg0 context.Context, arg1 string, arg2 []events.Transfer, arg3 string, arg4 *num.Uint, arg5 func(string) bool) ([]events.Margin, []*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PerpsFundingSettlement", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].([]events.Margin)
	ret1, _ := ret[1].([]*types.LedgerMovement)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// ReleaseFromHoldingAccount mocks base method.
func (m *MockCollateral) ReleaseFromHoldingAccount(arg0 context.Context, arg1 *types.Transfer) (*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseFromHoldingAccount", arg0, arg1)
	ret0, _ := ret[0].(*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// RemoveDistressed mocks base method.
func (m *MockCollateral) RemoveDistressed(arg0 context.Context, arg1 []events.MarketPosition, arg2, arg3 string, arg4 func(string) bool) (*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveDistressed", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RollbackMarginUpdateOnOrder mocks base method.
func (m *MockCollateral) RollbackMarginUpdateOnOrder(arg0 context.Context, arg1, arg2 string, arg3 *types.Transfer) (*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RollbackMarginUpdateOnOrder", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SuccessorInsuranceFraction mocks base method.
func (m *MockCollateral) SuccessorInsuranceFraction(arg0 context.Context, arg1, arg2, arg3 string, arg4 decimal.Decimal) *types.LedgerMovement {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SuccessorInsuranceFraction", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*types.LedgerMovement)
	return ret0
}

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

// TransferFees mocks base method.
func (m *MockCollateral) TransferFees(arg0 context.Context, arg1, arg2 string, arg3 events.FeesTransfer) ([]*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferFees", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TransferFeesContinuousTrading mocks base method.
func (m *MockCollateral) TransferFeesContinuousTrading(arg0 context.Context, arg1, arg2 string, arg3 events.FeesTransfer) ([]*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferFeesContinuousTrading", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TransferSpot mocks base method.
func (m *MockCollateral) TransferSpot(arg0 context.Context, arg1, arg2, arg3 string, arg4 *num.Uint) (*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferSpot", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TransferSpotFees mocks base method.
func (m *MockCollateral) TransferSpotFees(arg0 context.Context, arg1, arg2 string, arg3 events.FeesTransfer) ([]*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferSpotFees", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TransferSpotFeesContinuousTrading mocks base method.
func (m *MockCollateral) TransferSpotFeesContinuousTrading(arg0 context.Context, arg1, arg2 string, arg3 events.FeesTransfer) ([]*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferSpotFeesContinuousTrading", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TransferToHoldingAccount mocks base method.
func (m *MockCollateral) TransferToHoldingAccount(arg0 context.Context, arg1 *types.Transfer) (*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferToHoldingAccount", arg0, arg1)
	ret0, _ := ret[0].(*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Withdraw mocks base method.
func (m *MockCollateral) Withdraw(arg0 context.Context, arg1, arg2 string, arg3 *num.Uint) (*types.LedgerMovement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Withdraw", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*types.LedgerMovement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockOracleEngine is a mock of OracleEngine interface.
type MockOracleEngine struct {
	ctrl     *gomock.Controller
	recorder *MockOracleEngineMockRecorder
}

// MockOracleEngineMockRecorder is the mock recorder for MockOracleEngine.
type MockOracleEngineMockRecorder struct {
	mock *MockOracleEngine
}

// NewMockOracleEngine creates a new mock instance.
func NewMockOracleEngine(ctrl *gomock.Controller) *MockOracleEngine {
	mock := &MockOracleEngine{ctrl: ctrl}
	mock.recorder = &MockOracleEngineMockRecorder{mock}
	return mock
}

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

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

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

// Subscribe mocks base method.
func (m *MockOracleEngine) Subscribe(arg0 context.Context, arg1 spec.Spec, arg2 spec.OnMatchedData) (spec.SubscriptionID, spec.Unsubscriber, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Subscribe", arg0, arg1, arg2)
	ret0, _ := ret[0].(spec.SubscriptionID)
	ret1, _ := ret[1].(spec.Unsubscriber)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// Unsubscribe mocks base method.
func (m *MockOracleEngine) Unsubscribe(arg0 context.Context, arg1 spec.SubscriptionID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Unsubscribe", arg0, arg1)
}

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

// MockEpochEngine is a mock of EpochEngine interface.
type MockEpochEngine struct {
	ctrl     *gomock.Controller
	recorder *MockEpochEngineMockRecorder
}

// MockEpochEngineMockRecorder is the mock recorder for MockEpochEngine.
type MockEpochEngineMockRecorder struct {
	mock *MockEpochEngine
}

// NewMockEpochEngine creates a new mock instance.
func NewMockEpochEngine(ctrl *gomock.Controller) *MockEpochEngine {
	mock := &MockEpochEngine{ctrl: ctrl}
	mock.recorder = &MockEpochEngineMockRecorder{mock}
	return mock
}

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

// NotifyOnEpoch mocks base method.
func (m *MockEpochEngine) NotifyOnEpoch(arg0, arg1 func(context.Context, types.Epoch)) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NotifyOnEpoch", arg0, arg1)
}

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

// MockAuctionState is a mock of AuctionState interface.
type MockAuctionState struct {
	ctrl     *gomock.Controller
	recorder *MockAuctionStateMockRecorder
}

// MockAuctionStateMockRecorder is the mock recorder for MockAuctionState.
type MockAuctionStateMockRecorder struct {
	mock *MockAuctionState
}

// NewMockAuctionState creates a new mock instance.
func NewMockAuctionState(ctrl *gomock.Controller) *MockAuctionState {
	mock := &MockAuctionState{ctrl: ctrl}
	mock.recorder = &MockAuctionStateMockRecorder{mock}
	return mock
}

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

// AuctionExtended mocks base method.
func (m *MockAuctionState) AuctionExtended(arg0 context.Context, arg1 time.Time) *events.Auction {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuctionExtended", arg0, arg1)
	ret0, _ := ret[0].(*events.Auction)
	return ret0
}

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

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

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

// AuctionStarted mocks base method.
func (m *MockAuctionState) AuctionStarted(arg0 context.Context, arg1 time.Time) *events.Auction {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuctionStarted", arg0, arg1)
	ret0, _ := ret[0].(*events.Auction)
	return ret0
}

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

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

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

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

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

// Duration mocks base method.
func (m *MockAuctionState) Duration() types.AuctionDuration {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Duration")
	ret0, _ := ret[0].(types.AuctionDuration)
	return ret0
}

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

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

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

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

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

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

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

// ExtendAuction mocks base method.
func (m *MockAuctionState) ExtendAuction(arg0 types.AuctionDuration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ExtendAuction", arg0)
}

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

// ExtendAuctionPrice mocks base method.
func (m *MockAuctionState) ExtendAuctionPrice(arg0 types.AuctionDuration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ExtendAuctionPrice", arg0)
}

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

// ExtendAuctionSuspension mocks base method.
func (m *MockAuctionState) ExtendAuctionSuspension(arg0 types.AuctionDuration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ExtendAuctionSuspension", arg0)
}

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

// ExtensionTrigger mocks base method.
func (m *MockAuctionState) ExtensionTrigger() vega.AuctionTrigger {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExtensionTrigger")
	ret0, _ := ret[0].(vega.AuctionTrigger)
	return ret0
}

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

// GetState mocks base method.
func (m *MockAuctionState) GetState() *types.AuctionState {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetState")
	ret0, _ := ret[0].(*types.AuctionState)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// Left mocks base method.
func (m *MockAuctionState) Left(arg0 context.Context, arg1 time.Time) *events.Auction {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Left", arg0, arg1)
	ret0, _ := ret[0].(*events.Auction)
	return ret0
}

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

// Mode mocks base method.
func (m *MockAuctionState) Mode() vega.Market_TradingMode {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Mode")
	ret0, _ := ret[0].(vega.Market_TradingMode)
	return ret0
}

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

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

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

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

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

// StartGovernanceSuspensionAuction mocks base method.
func (m *MockAuctionState) StartGovernanceSuspensionAuction(arg0 time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StartGovernanceSuspensionAuction", arg0)
}

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

// StartPriceAuction mocks base method.
func (m *MockAuctionState) StartPriceAuction(arg0 time.Time, arg1 *types.AuctionDuration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StartPriceAuction", arg0, arg1)
}

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

// Trigger mocks base method.
func (m *MockAuctionState) Trigger() vega.AuctionTrigger {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trigger")
	ret0, _ := ret[0].(vega.AuctionTrigger)
	return ret0
}

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

// UpdateMaxDuration mocks base method.
func (m *MockAuctionState) UpdateMaxDuration(arg0 context.Context, arg1 time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateMaxDuration", arg0, arg1)
}

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

// UpdateMinDuration mocks base method.
func (m *MockAuctionState) UpdateMinDuration(arg0 context.Context, arg1 time.Duration) *events.Auction {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMinDuration", arg0, arg1)
	ret0, _ := ret[0].(*events.Auction)
	return ret0
}

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

// MockLiquidityEngine is a mock of LiquidityEngine interface.
type MockLiquidityEngine struct {
	ctrl     *gomock.Controller
	recorder *MockLiquidityEngineMockRecorder
}

// MockLiquidityEngineMockRecorder is the mock recorder for MockLiquidityEngine.
type MockLiquidityEngineMockRecorder struct {
	mock *MockLiquidityEngine
}

// NewMockLiquidityEngine creates a new mock instance.
func NewMockLiquidityEngine(ctrl *gomock.Controller) *MockLiquidityEngine {
	mock := &MockLiquidityEngine{ctrl: ctrl}
	mock.recorder = &MockLiquidityEngineMockRecorder{mock}
	return mock
}

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

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

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

// ApplyPendingProvisions mocks base method.
func (m *MockLiquidityEngine) ApplyPendingProvisions(arg0 context.Context, arg1 time.Time) liquidity.Provisions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyPendingProvisions", arg0, arg1)
	ret0, _ := ret[0].(liquidity.Provisions)
	return ret0
}

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

// CalculateSLAPenalties mocks base method.
func (m *MockLiquidityEngine) CalculateSLAPenalties(arg0 time.Time) liquidity.SlaPenalties {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalculateSLAPenalties", arg0)
	ret0, _ := ret[0].(liquidity.SlaPenalties)
	return ret0
}

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

// CalculateSuppliedStake mocks base method.
func (m *MockLiquidityEngine) CalculateSuppliedStake() *num.Uint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalculateSuppliedStake")
	ret0, _ := ret[0].(*num.Uint)
	return ret0
}

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

// CalculateSuppliedStakeWithoutPending mocks base method.
func (m *MockLiquidityEngine) CalculateSuppliedStakeWithoutPending() *num.Uint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalculateSuppliedStakeWithoutPending")
	ret0, _ := ret[0].(*num.Uint)
	return ret0
}

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

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

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

// EndBlock mocks base method.
func (m *MockLiquidityEngine) EndBlock(arg0, arg1 *num.Uint, arg2 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EndBlock", arg0, arg1, arg2)
}

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

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

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

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

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

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

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

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

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

// LiquidityProviderSLAStats mocks base method.
func (m *MockLiquidityEngine) LiquidityProviderSLAStats(arg0 time.Time) []*vega.LiquidityProviderSLA {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LiquidityProviderSLAStats", arg0)
	ret0, _ := ret[0].([]*vega.LiquidityProviderSLA)
	return ret0
}

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

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

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

// OnEpochRestore mocks base method.
func (m *MockLiquidityEngine) OnEpochRestore(arg0 types.Epoch) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnEpochRestore", arg0)
}

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

// OnMaximumLiquidityFeeFactorLevelUpdate mocks base method.
func (m *MockLiquidityEngine) OnMaximumLiquidityFeeFactorLevelUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnMaximumLiquidityFeeFactorLevelUpdate", arg0)
}

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

// OnMinProbabilityOfTradingLPOrdersUpdate mocks base method.
func (m *MockLiquidityEngine) OnMinProbabilityOfTradingLPOrdersUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnMinProbabilityOfTradingLPOrdersUpdate", arg0)
}

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

// OnNonPerformanceBondPenaltyMaxUpdate mocks base method.
func (m *MockLiquidityEngine) OnNonPerformanceBondPenaltyMaxUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnNonPerformanceBondPenaltyMaxUpdate", arg0)
}

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

// OnNonPerformanceBondPenaltySlopeUpdate mocks base method.
func (m *MockLiquidityEngine) OnNonPerformanceBondPenaltySlopeUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnNonPerformanceBondPenaltySlopeUpdate", arg0)
}

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

// OnProbabilityOfTradingTauScalingUpdate mocks base method.
func (m *MockLiquidityEngine) OnProbabilityOfTradingTauScalingUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnProbabilityOfTradingTauScalingUpdate", arg0)
}

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

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

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

// OnStakeToCcyVolumeUpdate mocks base method.
func (m *MockLiquidityEngine) OnStakeToCcyVolumeUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnStakeToCcyVolumeUpdate", arg0)
}

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

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

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

// PendingProvision mocks base method.
func (m *MockLiquidityEngine) PendingProvision() liquidity.Provisions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingProvision")
	ret0, _ := ret[0].(liquidity.Provisions)
	return ret0
}

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

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

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

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

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

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

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

// RegisterAllocatedFeesPerParty mocks base method.
func (m *MockLiquidityEngine) RegisterAllocatedFeesPerParty(arg0 map[string]*num.Uint) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterAllocatedFeesPerParty", arg0)
}

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

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

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

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

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

// ResetFeeAllocationPeriod mocks base method.
func (m *MockLiquidityEngine) ResetFeeAllocationPeriod(arg0 time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ResetFeeAllocationPeriod", arg0)
}

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

// ResetSLAEpoch mocks base method.
func (m *MockLiquidityEngine) ResetSLAEpoch(arg0 time.Time, arg1, arg2 *num.Uint, arg3 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ResetSLAEpoch", arg0, arg1, arg2, arg3)
}

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

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

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

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

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

// SubmitLiquidityProvision mocks base method.
func (m *MockLiquidityEngine) SubmitLiquidityProvision(arg0 context.Context, arg1 *types.LiquidityProvisionSubmission, arg2 string, arg3 liquidity.IDGen) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitLiquidityProvision", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAverageLiquidityScores mocks base method.
func (m *MockLiquidityEngine) UpdateAverageLiquidityScores(arg0, arg1 decimal.Decimal, arg2, arg3 *num.Uint) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateAverageLiquidityScores", arg0, arg1, arg2, arg3)
}

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

// UpdateMarketConfig mocks base method.
func (m *MockLiquidityEngine) UpdateMarketConfig(arg0 liquidity.RiskModel, arg1 liquidity.PriceMonitor) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateMarketConfig", arg0, arg1)
}

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

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

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

// UpdateSLAParameters mocks base method.
func (m *MockLiquidityEngine) UpdateSLAParameters(arg0 *types.LiquiditySLAParams) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateSLAParameters", arg0)
}

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

// V1StateProvider mocks base method.
func (m *MockLiquidityEngine) V1StateProvider() types.StateProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "V1StateProvider")
	ret0, _ := ret[0].(types.StateProvider)
	return ret0
}

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

// V2StateProvider mocks base method.
func (m *MockLiquidityEngine) V2StateProvider() types.StateProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "V2StateProvider")
	ret0, _ := ret[0].(types.StateProvider)
	return ret0
}

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

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

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

// MockEquityLikeShares is a mock of EquityLikeShares interface.
type MockEquityLikeShares struct {
	ctrl     *gomock.Controller
	recorder *MockEquityLikeSharesMockRecorder
}

// MockEquityLikeSharesMockRecorder is the mock recorder for MockEquityLikeShares.
type MockEquityLikeSharesMockRecorder struct {
	mock *MockEquityLikeShares
}

// NewMockEquityLikeShares creates a new mock instance.
func NewMockEquityLikeShares(ctrl *gomock.Controller) *MockEquityLikeShares {
	mock := &MockEquityLikeShares{ctrl: ctrl}
	mock.recorder = &MockEquityLikeSharesMockRecorder{mock}
	return mock
}

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

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

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

// SetPartyStake mocks base method.
func (m *MockEquityLikeShares) SetPartyStake(arg0 string, arg1 *num.Uint) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPartyStake", arg0, arg1)
}

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

// MockMarketLiquidityEngine is a mock of MarketLiquidityEngine interface.
type MockMarketLiquidityEngine struct {
	ctrl     *gomock.Controller
	recorder *MockMarketLiquidityEngineMockRecorder
}

// MockMarketLiquidityEngineMockRecorder is the mock recorder for MockMarketLiquidityEngine.
type MockMarketLiquidityEngineMockRecorder struct {
	mock *MockMarketLiquidityEngine
}

// NewMockMarketLiquidityEngine creates a new mock instance.
func NewMockMarketLiquidityEngine(ctrl *gomock.Controller) *MockMarketLiquidityEngine {
	mock := &MockMarketLiquidityEngine{ctrl: ctrl}
	mock.recorder = &MockMarketLiquidityEngineMockRecorder{mock}
	return mock
}

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

// AmendLiquidityProvision mocks base method.
func (m *MockMarketLiquidityEngine) AmendLiquidityProvision(arg0 context.Context, arg1 *types.LiquidityProvisionAmendment, arg2, arg3 string, arg4 vega.Market_State) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AmendLiquidityProvision", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CalculateSuppliedStake mocks base method.
func (m *MockMarketLiquidityEngine) CalculateSuppliedStake() *num.Uint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalculateSuppliedStake")
	ret0, _ := ret[0].(*num.Uint)
	return ret0
}

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

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

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

// EndBlock mocks base method.
func (m *MockMarketLiquidityEngine) EndBlock(arg0, arg1 *num.Uint, arg2 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EndBlock", arg0, arg1, arg2)
}

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

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

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

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

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

// OnBondPenaltyFactorUpdate mocks base method.
func (m *MockMarketLiquidityEngine) OnBondPenaltyFactorUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnBondPenaltyFactorUpdate", arg0)
}

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

// OnEarlyExitPenalty mocks base method.
func (m *MockMarketLiquidityEngine) OnEarlyExitPenalty(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnEarlyExitPenalty", arg0)
}

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

// OnEpochEnd mocks base method.
func (m *MockMarketLiquidityEngine) OnEpochEnd(arg0 context.Context, arg1 time.Time, arg2 types.Epoch) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnEpochEnd", arg0, arg1, arg2)
}

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

// OnEpochStart mocks base method.
func (m *MockMarketLiquidityEngine) OnEpochStart(arg0 context.Context, arg1 time.Time, arg2, arg3, arg4 *num.Uint, arg5 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnEpochStart", arg0, arg1, arg2, arg3, arg4, arg5)
}

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

// OnMarketClosed mocks base method.
func (m *MockMarketLiquidityEngine) OnMarketClosed(arg0 context.Context, arg1 time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnMarketClosed", arg0, arg1)
}

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

// OnMaximumLiquidityFeeFactorLevelUpdate mocks base method.
func (m *MockMarketLiquidityEngine) OnMaximumLiquidityFeeFactorLevelUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnMaximumLiquidityFeeFactorLevelUpdate", arg0)
}

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

// OnMinLPStakeQuantumMultiple mocks base method.
func (m *MockMarketLiquidityEngine) OnMinLPStakeQuantumMultiple(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnMinLPStakeQuantumMultiple", arg0)
}

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

// OnMinProbabilityOfTradingLPOrdersUpdate mocks base method.
func (m *MockMarketLiquidityEngine) OnMinProbabilityOfTradingLPOrdersUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnMinProbabilityOfTradingLPOrdersUpdate", arg0)
}

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

// OnNonPerformanceBondPenaltyMaxUpdate mocks base method.
func (m *MockMarketLiquidityEngine) OnNonPerformanceBondPenaltyMaxUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnNonPerformanceBondPenaltyMaxUpdate", arg0)
}

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

// OnNonPerformanceBondPenaltySlopeUpdate mocks base method.
func (m *MockMarketLiquidityEngine) OnNonPerformanceBondPenaltySlopeUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnNonPerformanceBondPenaltySlopeUpdate", arg0)
}

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

// OnProbabilityOfTradingTauScalingUpdate mocks base method.
func (m *MockMarketLiquidityEngine) OnProbabilityOfTradingTauScalingUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnProbabilityOfTradingTauScalingUpdate", arg0)
}

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

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

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

// OnStakeToCcyVolumeUpdate mocks base method.
func (m *MockMarketLiquidityEngine) OnStakeToCcyVolumeUpdate(arg0 decimal.Decimal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnStakeToCcyVolumeUpdate", arg0)
}

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

// OnTick mocks base method.
func (m *MockMarketLiquidityEngine) OnTick(arg0 context.Context, arg1 time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnTick", arg0, arg1)
}

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

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

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

// StopAllLiquidityProvision mocks base method.
func (m *MockMarketLiquidityEngine) StopAllLiquidityProvision(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StopAllLiquidityProvision", arg0)
}

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

// SubmitLiquidityProvision mocks base method.
func (m *MockMarketLiquidityEngine) SubmitLiquidityProvision(arg0 context.Context, arg1 *types.LiquidityProvisionSubmission, arg2, arg3 string, arg4 vega.Market_State) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitLiquidityProvision", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateMarketConfig mocks base method.
func (m *MockMarketLiquidityEngine) UpdateMarketConfig(arg0 liquidity.RiskModel, arg1 liquidity.PriceMonitor) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateMarketConfig", arg0, arg1)
}

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

// UpdateSLAParameters mocks base method.
func (m *MockMarketLiquidityEngine) UpdateSLAParameters(arg0 *types.LiquiditySLAParams) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateSLAParameters", arg0)
}

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

// MockTeams is a mock of Teams interface.
type MockTeams struct {
	ctrl     *gomock.Controller
	recorder *MockTeamsMockRecorder
}

// MockTeamsMockRecorder is the mock recorder for MockTeams.
type MockTeamsMockRecorder struct {
	mock *MockTeams
}

// NewMockTeams creates a new mock instance.
func NewMockTeams(ctrl *gomock.Controller) *MockTeams {
	mock := &MockTeams{ctrl: ctrl}
	mock.recorder = &MockTeamsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockAccountBalanceChecker is a mock of AccountBalanceChecker interface.
type MockAccountBalanceChecker struct {
	ctrl     *gomock.Controller
	recorder *MockAccountBalanceCheckerMockRecorder
}

// MockAccountBalanceCheckerMockRecorder is the mock recorder for MockAccountBalanceChecker.
type MockAccountBalanceCheckerMockRecorder struct {
	mock *MockAccountBalanceChecker
}

// NewMockAccountBalanceChecker creates a new mock instance.
func NewMockAccountBalanceChecker(ctrl *gomock.Controller) *MockAccountBalanceChecker {
	mock := &MockAccountBalanceChecker{ctrl: ctrl}
	mock.recorder = &MockAccountBalanceCheckerMockRecorder{mock}
	return mock
}

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

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

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

// MockBanking is a mock of Banking interface.
type MockBanking struct {
	ctrl     *gomock.Controller
	recorder *MockBankingMockRecorder
}

// MockBankingMockRecorder is the mock recorder for MockBanking.
type MockBankingMockRecorder struct {
	mock *MockBanking
}

// NewMockBanking creates a new mock instance.
func NewMockBanking(ctrl *gomock.Controller) *MockBanking {
	mock := &MockBanking{ctrl: ctrl}
	mock.recorder = &MockBankingMockRecorder{mock}
	return mock
}

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

// RegisterTradingFees mocks base method.
func (m *MockBanking) RegisterTradingFees(arg0 context.Context, arg1 string, arg2 map[string]*num.Uint) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterTradingFees", arg0, arg1, arg2)
}

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