// Code generated by mockery. DO NOT EDIT.

package mocks

import (
	big "math/big"

	claimsponsor "github.com/0xPolygon/cdk/claimsponsor"
	l1infotreesync "github.com/0xPolygon/cdk/l1infotreesync"

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

	types "github.com/0xPolygon/cdk/rpc/types"
)

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

type ClientInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *ClientInterface) EXPECT() *ClientInterface_Expecter {
	return &ClientInterface_Expecter{mock: &_m.Mock}
}

// ClaimProof provides a mock function with given fields: networkID, depositCount, l1InfoTreeIndex
func (_m *ClientInterface) ClaimProof(networkID uint32, depositCount uint32, l1InfoTreeIndex uint32) (*types.ClaimProof, error) {
	ret := _m.Called(networkID, depositCount, l1InfoTreeIndex)

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

	var r0 *types.ClaimProof
	var r1 error
	if rf, ok := ret.Get(0).(func(uint32, uint32, uint32) (*types.ClaimProof, error)); ok {
		return rf(networkID, depositCount, l1InfoTreeIndex)
	}
	if rf, ok := ret.Get(0).(func(uint32, uint32, uint32) *types.ClaimProof); ok {
		r0 = rf(networkID, depositCount, l1InfoTreeIndex)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*types.ClaimProof)
		}
	}

	if rf, ok := ret.Get(1).(func(uint32, uint32, uint32) error); ok {
		r1 = rf(networkID, depositCount, l1InfoTreeIndex)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ClaimProof is a helper method to define mock.On call
//   - networkID uint32
//   - depositCount uint32
//   - l1InfoTreeIndex uint32
func (_e *ClientInterface_Expecter) ClaimProof(networkID interface{}, depositCount interface{}, l1InfoTreeIndex interface{}) *ClientInterface_ClaimProof_Call {
	return &ClientInterface_ClaimProof_Call{Call: _e.mock.On("ClaimProof", networkID, depositCount, l1InfoTreeIndex)}
}

func (_c *ClientInterface_ClaimProof_Call) Run(run func(networkID uint32, depositCount uint32, l1InfoTreeIndex uint32)) *ClientInterface_ClaimProof_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint32), args[1].(uint32), args[2].(uint32))
	})
	return _c
}

func (_c *ClientInterface_ClaimProof_Call) Return(_a0 *types.ClaimProof, _a1 error) *ClientInterface_ClaimProof_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientInterface_ClaimProof_Call) RunAndReturn(run func(uint32, uint32, uint32) (*types.ClaimProof, error)) *ClientInterface_ClaimProof_Call {
	_c.Call.Return(run)
	return _c
}

// GetSponsoredClaimStatus provides a mock function with given fields: globalIndex
func (_m *ClientInterface) GetSponsoredClaimStatus(globalIndex *big.Int) (claimsponsor.ClaimStatus, error) {
	ret := _m.Called(globalIndex)

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

	var r0 claimsponsor.ClaimStatus
	var r1 error
	if rf, ok := ret.Get(0).(func(*big.Int) (claimsponsor.ClaimStatus, error)); ok {
		return rf(globalIndex)
	}
	if rf, ok := ret.Get(0).(func(*big.Int) claimsponsor.ClaimStatus); ok {
		r0 = rf(globalIndex)
	} else {
		r0 = ret.Get(0).(claimsponsor.ClaimStatus)
	}

	if rf, ok := ret.Get(1).(func(*big.Int) error); ok {
		r1 = rf(globalIndex)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetSponsoredClaimStatus is a helper method to define mock.On call
//   - globalIndex *big.Int
func (_e *ClientInterface_Expecter) GetSponsoredClaimStatus(globalIndex interface{}) *ClientInterface_GetSponsoredClaimStatus_Call {
	return &ClientInterface_GetSponsoredClaimStatus_Call{Call: _e.mock.On("GetSponsoredClaimStatus", globalIndex)}
}

func (_c *ClientInterface_GetSponsoredClaimStatus_Call) Run(run func(globalIndex *big.Int)) *ClientInterface_GetSponsoredClaimStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*big.Int))
	})
	return _c
}

func (_c *ClientInterface_GetSponsoredClaimStatus_Call) Return(_a0 claimsponsor.ClaimStatus, _a1 error) *ClientInterface_GetSponsoredClaimStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientInterface_GetSponsoredClaimStatus_Call) RunAndReturn(run func(*big.Int) (claimsponsor.ClaimStatus, error)) *ClientInterface_GetSponsoredClaimStatus_Call {
	_c.Call.Return(run)
	return _c
}

// InjectedInfoAfterIndex provides a mock function with given fields: networkID, l1InfoTreeIndex
func (_m *ClientInterface) InjectedInfoAfterIndex(networkID uint32, l1InfoTreeIndex uint32) (*l1infotreesync.L1InfoTreeLeaf, error) {
	ret := _m.Called(networkID, l1InfoTreeIndex)

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

	var r0 *l1infotreesync.L1InfoTreeLeaf
	var r1 error
	if rf, ok := ret.Get(0).(func(uint32, uint32) (*l1infotreesync.L1InfoTreeLeaf, error)); ok {
		return rf(networkID, l1InfoTreeIndex)
	}
	if rf, ok := ret.Get(0).(func(uint32, uint32) *l1infotreesync.L1InfoTreeLeaf); ok {
		r0 = rf(networkID, l1InfoTreeIndex)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*l1infotreesync.L1InfoTreeLeaf)
		}
	}

	if rf, ok := ret.Get(1).(func(uint32, uint32) error); ok {
		r1 = rf(networkID, l1InfoTreeIndex)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// InjectedInfoAfterIndex is a helper method to define mock.On call
//   - networkID uint32
//   - l1InfoTreeIndex uint32
func (_e *ClientInterface_Expecter) InjectedInfoAfterIndex(networkID interface{}, l1InfoTreeIndex interface{}) *ClientInterface_InjectedInfoAfterIndex_Call {
	return &ClientInterface_InjectedInfoAfterIndex_Call{Call: _e.mock.On("InjectedInfoAfterIndex", networkID, l1InfoTreeIndex)}
}

func (_c *ClientInterface_InjectedInfoAfterIndex_Call) Run(run func(networkID uint32, l1InfoTreeIndex uint32)) *ClientInterface_InjectedInfoAfterIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint32), args[1].(uint32))
	})
	return _c
}

func (_c *ClientInterface_InjectedInfoAfterIndex_Call) Return(_a0 *l1infotreesync.L1InfoTreeLeaf, _a1 error) *ClientInterface_InjectedInfoAfterIndex_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientInterface_InjectedInfoAfterIndex_Call) RunAndReturn(run func(uint32, uint32) (*l1infotreesync.L1InfoTreeLeaf, error)) *ClientInterface_InjectedInfoAfterIndex_Call {
	_c.Call.Return(run)
	return _c
}

// L1InfoTreeIndexForBridge provides a mock function with given fields: networkID, depositCount
func (_m *ClientInterface) L1InfoTreeIndexForBridge(networkID uint32, depositCount uint32) (uint32, error) {
	ret := _m.Called(networkID, depositCount)

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

	var r0 uint32
	var r1 error
	if rf, ok := ret.Get(0).(func(uint32, uint32) (uint32, error)); ok {
		return rf(networkID, depositCount)
	}
	if rf, ok := ret.Get(0).(func(uint32, uint32) uint32); ok {
		r0 = rf(networkID, depositCount)
	} else {
		r0 = ret.Get(0).(uint32)
	}

	if rf, ok := ret.Get(1).(func(uint32, uint32) error); ok {
		r1 = rf(networkID, depositCount)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// L1InfoTreeIndexForBridge is a helper method to define mock.On call
//   - networkID uint32
//   - depositCount uint32
func (_e *ClientInterface_Expecter) L1InfoTreeIndexForBridge(networkID interface{}, depositCount interface{}) *ClientInterface_L1InfoTreeIndexForBridge_Call {
	return &ClientInterface_L1InfoTreeIndexForBridge_Call{Call: _e.mock.On("L1InfoTreeIndexForBridge", networkID, depositCount)}
}

func (_c *ClientInterface_L1InfoTreeIndexForBridge_Call) Run(run func(networkID uint32, depositCount uint32)) *ClientInterface_L1InfoTreeIndexForBridge_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint32), args[1].(uint32))
	})
	return _c
}

func (_c *ClientInterface_L1InfoTreeIndexForBridge_Call) Return(_a0 uint32, _a1 error) *ClientInterface_L1InfoTreeIndexForBridge_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientInterface_L1InfoTreeIndexForBridge_Call) RunAndReturn(run func(uint32, uint32) (uint32, error)) *ClientInterface_L1InfoTreeIndexForBridge_Call {
	_c.Call.Return(run)
	return _c
}

// SponsorClaim provides a mock function with given fields: claim
func (_m *ClientInterface) SponsorClaim(claim claimsponsor.Claim) error {
	ret := _m.Called(claim)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(claimsponsor.Claim) error); ok {
		r0 = rf(claim)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SponsorClaim is a helper method to define mock.On call
//   - claim claimsponsor.Claim
func (_e *ClientInterface_Expecter) SponsorClaim(claim interface{}) *ClientInterface_SponsorClaim_Call {
	return &ClientInterface_SponsorClaim_Call{Call: _e.mock.On("SponsorClaim", claim)}
}

func (_c *ClientInterface_SponsorClaim_Call) Run(run func(claim claimsponsor.Claim)) *ClientInterface_SponsorClaim_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(claimsponsor.Claim))
	})
	return _c
}

func (_c *ClientInterface_SponsorClaim_Call) Return(_a0 error) *ClientInterface_SponsorClaim_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ClientInterface_SponsorClaim_Call) RunAndReturn(run func(claimsponsor.Claim) error) *ClientInterface_SponsorClaim_Call {
	_c.Call.Return(run)
	return _c
}

// NewClientInterface creates a new instance of ClientInterface. 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 NewClientInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *ClientInterface {
	mock := &ClientInterface{}
	mock.Mock.Test(t)

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

	return mock
}
