// Code generated by mockery. DO NOT EDIT.

package mocks

import (
	big "math/big"

	bind "github.com/ethereum/go-ethereum/accounts/abi/bind"
	common "github.com/ethereum/go-ethereum/common"

	globalexitrootmanagerl2sovereignchain "github.com/0xPolygon/cdk-contracts-tooling/contracts/pp/l2-sovereign-chain/globalexitrootmanagerl2sovereignchain"

	mock "github.com/stretchr/testify/mock"
)

// L2GERManagerContract is an autogenerated mock type for the L2GERManagerContract type
type L2GERManagerContract struct {
	mock.Mock
}

type L2GERManagerContract_Expecter struct {
	mock *mock.Mock
}

func (_m *L2GERManagerContract) EXPECT() *L2GERManagerContract_Expecter {
	return &L2GERManagerContract_Expecter{mock: &_m.Mock}
}

// BridgeAddress provides a mock function with given fields: _a0
func (_m *L2GERManagerContract) BridgeAddress(_a0 *bind.CallOpts) (common.Address, error) {
	ret := _m.Called(_a0)

	if len(ret) == 0 {
		panic("no return value specified for BridgeAddress")
	}

	var r0 common.Address
	var r1 error
	if rf, ok := ret.Get(0).(func(*bind.CallOpts) (common.Address, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*bind.CallOpts) common.Address); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Address)
		}
	}

	if rf, ok := ret.Get(1).(func(*bind.CallOpts) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// L2GERManagerContract_BridgeAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BridgeAddress'
type L2GERManagerContract_BridgeAddress_Call struct {
	*mock.Call
}

// BridgeAddress is a helper method to define mock.On call
//   - _a0 *bind.CallOpts
func (_e *L2GERManagerContract_Expecter) BridgeAddress(_a0 interface{}) *L2GERManagerContract_BridgeAddress_Call {
	return &L2GERManagerContract_BridgeAddress_Call{Call: _e.mock.On("BridgeAddress", _a0)}
}

func (_c *L2GERManagerContract_BridgeAddress_Call) Run(run func(_a0 *bind.CallOpts)) *L2GERManagerContract_BridgeAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*bind.CallOpts))
	})
	return _c
}

func (_c *L2GERManagerContract_BridgeAddress_Call) Return(_a0 common.Address, _a1 error) *L2GERManagerContract_BridgeAddress_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *L2GERManagerContract_BridgeAddress_Call) RunAndReturn(run func(*bind.CallOpts) (common.Address, error)) *L2GERManagerContract_BridgeAddress_Call {
	_c.Call.Return(run)
	return _c
}

// FilterUpdateHashChainValue provides a mock function with given fields: opts, newGlobalExitRoot, newHashChainValue
func (_m *L2GERManagerContract) FilterUpdateHashChainValue(opts *bind.FilterOpts, newGlobalExitRoot [][32]byte, newHashChainValue [][32]byte) (*globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateHashChainValueIterator, error) {
	ret := _m.Called(opts, newGlobalExitRoot, newHashChainValue)

	if len(ret) == 0 {
		panic("no return value specified for FilterUpdateHashChainValue")
	}

	var r0 *globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateHashChainValueIterator
	var r1 error
	if rf, ok := ret.Get(0).(func(*bind.FilterOpts, [][32]byte, [][32]byte) (*globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateHashChainValueIterator, error)); ok {
		return rf(opts, newGlobalExitRoot, newHashChainValue)
	}
	if rf, ok := ret.Get(0).(func(*bind.FilterOpts, [][32]byte, [][32]byte) *globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateHashChainValueIterator); ok {
		r0 = rf(opts, newGlobalExitRoot, newHashChainValue)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateHashChainValueIterator)
		}
	}

	if rf, ok := ret.Get(1).(func(*bind.FilterOpts, [][32]byte, [][32]byte) error); ok {
		r1 = rf(opts, newGlobalExitRoot, newHashChainValue)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// L2GERManagerContract_FilterUpdateHashChainValue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterUpdateHashChainValue'
type L2GERManagerContract_FilterUpdateHashChainValue_Call struct {
	*mock.Call
}

// FilterUpdateHashChainValue is a helper method to define mock.On call
//   - opts *bind.FilterOpts
//   - newGlobalExitRoot [][32]byte
//   - newHashChainValue [][32]byte
func (_e *L2GERManagerContract_Expecter) FilterUpdateHashChainValue(opts interface{}, newGlobalExitRoot interface{}, newHashChainValue interface{}) *L2GERManagerContract_FilterUpdateHashChainValue_Call {
	return &L2GERManagerContract_FilterUpdateHashChainValue_Call{Call: _e.mock.On("FilterUpdateHashChainValue", opts, newGlobalExitRoot, newHashChainValue)}
}

func (_c *L2GERManagerContract_FilterUpdateHashChainValue_Call) Run(run func(opts *bind.FilterOpts, newGlobalExitRoot [][32]byte, newHashChainValue [][32]byte)) *L2GERManagerContract_FilterUpdateHashChainValue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*bind.FilterOpts), args[1].([][32]byte), args[2].([][32]byte))
	})
	return _c
}

func (_c *L2GERManagerContract_FilterUpdateHashChainValue_Call) Return(_a0 *globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateHashChainValueIterator, _a1 error) *L2GERManagerContract_FilterUpdateHashChainValue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *L2GERManagerContract_FilterUpdateHashChainValue_Call) RunAndReturn(run func(*bind.FilterOpts, [][32]byte, [][32]byte) (*globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateHashChainValueIterator, error)) *L2GERManagerContract_FilterUpdateHashChainValue_Call {
	_c.Call.Return(run)
	return _c
}

// FilterUpdateRemovalHashChainValue provides a mock function with given fields: opts, removedGlobalExitRoot, newRemovalHashChainValue
func (_m *L2GERManagerContract) FilterUpdateRemovalHashChainValue(opts *bind.FilterOpts, removedGlobalExitRoot [][32]byte, newRemovalHashChainValue [][32]byte) (*globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateRemovalHashChainValueIterator, error) {
	ret := _m.Called(opts, removedGlobalExitRoot, newRemovalHashChainValue)

	if len(ret) == 0 {
		panic("no return value specified for FilterUpdateRemovalHashChainValue")
	}

	var r0 *globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateRemovalHashChainValueIterator
	var r1 error
	if rf, ok := ret.Get(0).(func(*bind.FilterOpts, [][32]byte, [][32]byte) (*globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateRemovalHashChainValueIterator, error)); ok {
		return rf(opts, removedGlobalExitRoot, newRemovalHashChainValue)
	}
	if rf, ok := ret.Get(0).(func(*bind.FilterOpts, [][32]byte, [][32]byte) *globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateRemovalHashChainValueIterator); ok {
		r0 = rf(opts, removedGlobalExitRoot, newRemovalHashChainValue)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateRemovalHashChainValueIterator)
		}
	}

	if rf, ok := ret.Get(1).(func(*bind.FilterOpts, [][32]byte, [][32]byte) error); ok {
		r1 = rf(opts, removedGlobalExitRoot, newRemovalHashChainValue)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// L2GERManagerContract_FilterUpdateRemovalHashChainValue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FilterUpdateRemovalHashChainValue'
type L2GERManagerContract_FilterUpdateRemovalHashChainValue_Call struct {
	*mock.Call
}

// FilterUpdateRemovalHashChainValue is a helper method to define mock.On call
//   - opts *bind.FilterOpts
//   - removedGlobalExitRoot [][32]byte
//   - newRemovalHashChainValue [][32]byte
func (_e *L2GERManagerContract_Expecter) FilterUpdateRemovalHashChainValue(opts interface{}, removedGlobalExitRoot interface{}, newRemovalHashChainValue interface{}) *L2GERManagerContract_FilterUpdateRemovalHashChainValue_Call {
	return &L2GERManagerContract_FilterUpdateRemovalHashChainValue_Call{Call: _e.mock.On("FilterUpdateRemovalHashChainValue", opts, removedGlobalExitRoot, newRemovalHashChainValue)}
}

func (_c *L2GERManagerContract_FilterUpdateRemovalHashChainValue_Call) Run(run func(opts *bind.FilterOpts, removedGlobalExitRoot [][32]byte, newRemovalHashChainValue [][32]byte)) *L2GERManagerContract_FilterUpdateRemovalHashChainValue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*bind.FilterOpts), args[1].([][32]byte), args[2].([][32]byte))
	})
	return _c
}

func (_c *L2GERManagerContract_FilterUpdateRemovalHashChainValue_Call) Return(_a0 *globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateRemovalHashChainValueIterator, _a1 error) *L2GERManagerContract_FilterUpdateRemovalHashChainValue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *L2GERManagerContract_FilterUpdateRemovalHashChainValue_Call) RunAndReturn(run func(*bind.FilterOpts, [][32]byte, [][32]byte) (*globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainUpdateRemovalHashChainValueIterator, error)) *L2GERManagerContract_FilterUpdateRemovalHashChainValue_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalExitRootMap provides a mock function with given fields: opts, ger
func (_m *L2GERManagerContract) GlobalExitRootMap(opts *bind.CallOpts, ger [32]byte) (*big.Int, error) {
	ret := _m.Called(opts, ger)

	if len(ret) == 0 {
		panic("no return value specified for GlobalExitRootMap")
	}

	var r0 *big.Int
	var r1 error
	if rf, ok := ret.Get(0).(func(*bind.CallOpts, [32]byte) (*big.Int, error)); ok {
		return rf(opts, ger)
	}
	if rf, ok := ret.Get(0).(func(*bind.CallOpts, [32]byte) *big.Int); ok {
		r0 = rf(opts, ger)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*big.Int)
		}
	}

	if rf, ok := ret.Get(1).(func(*bind.CallOpts, [32]byte) error); ok {
		r1 = rf(opts, ger)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// L2GERManagerContract_GlobalExitRootMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalExitRootMap'
type L2GERManagerContract_GlobalExitRootMap_Call struct {
	*mock.Call
}

// GlobalExitRootMap is a helper method to define mock.On call
//   - opts *bind.CallOpts
//   - ger [32]byte
func (_e *L2GERManagerContract_Expecter) GlobalExitRootMap(opts interface{}, ger interface{}) *L2GERManagerContract_GlobalExitRootMap_Call {
	return &L2GERManagerContract_GlobalExitRootMap_Call{Call: _e.mock.On("GlobalExitRootMap", opts, ger)}
}

func (_c *L2GERManagerContract_GlobalExitRootMap_Call) Run(run func(opts *bind.CallOpts, ger [32]byte)) *L2GERManagerContract_GlobalExitRootMap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*bind.CallOpts), args[1].([32]byte))
	})
	return _c
}

func (_c *L2GERManagerContract_GlobalExitRootMap_Call) Return(_a0 *big.Int, _a1 error) *L2GERManagerContract_GlobalExitRootMap_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *L2GERManagerContract_GlobalExitRootMap_Call) RunAndReturn(run func(*bind.CallOpts, [32]byte) (*big.Int, error)) *L2GERManagerContract_GlobalExitRootMap_Call {
	_c.Call.Return(run)
	return _c
}

// GlobalExitRootUpdater provides a mock function with given fields: opts
func (_m *L2GERManagerContract) GlobalExitRootUpdater(opts *bind.CallOpts) (common.Address, error) {
	ret := _m.Called(opts)

	if len(ret) == 0 {
		panic("no return value specified for GlobalExitRootUpdater")
	}

	var r0 common.Address
	var r1 error
	if rf, ok := ret.Get(0).(func(*bind.CallOpts) (common.Address, error)); ok {
		return rf(opts)
	}
	if rf, ok := ret.Get(0).(func(*bind.CallOpts) common.Address); ok {
		r0 = rf(opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(common.Address)
		}
	}

	if rf, ok := ret.Get(1).(func(*bind.CallOpts) error); ok {
		r1 = rf(opts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// L2GERManagerContract_GlobalExitRootUpdater_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalExitRootUpdater'
type L2GERManagerContract_GlobalExitRootUpdater_Call struct {
	*mock.Call
}

// GlobalExitRootUpdater is a helper method to define mock.On call
//   - opts *bind.CallOpts
func (_e *L2GERManagerContract_Expecter) GlobalExitRootUpdater(opts interface{}) *L2GERManagerContract_GlobalExitRootUpdater_Call {
	return &L2GERManagerContract_GlobalExitRootUpdater_Call{Call: _e.mock.On("GlobalExitRootUpdater", opts)}
}

func (_c *L2GERManagerContract_GlobalExitRootUpdater_Call) Run(run func(opts *bind.CallOpts)) *L2GERManagerContract_GlobalExitRootUpdater_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*bind.CallOpts))
	})
	return _c
}

func (_c *L2GERManagerContract_GlobalExitRootUpdater_Call) Return(_a0 common.Address, _a1 error) *L2GERManagerContract_GlobalExitRootUpdater_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *L2GERManagerContract_GlobalExitRootUpdater_Call) RunAndReturn(run func(*bind.CallOpts) (common.Address, error)) *L2GERManagerContract_GlobalExitRootUpdater_Call {
	_c.Call.Return(run)
	return _c
}

// NewL2GERManagerContract creates a new instance of L2GERManagerContract. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewL2GERManagerContract(t interface {
	mock.TestingT
	Cleanup(func())
}) *L2GERManagerContract {
	mock := &L2GERManagerContract{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
