// Code generated by mockery v2.53.3. DO NOT EDIT.

package mocks

import (
	blockchain "github.com/ChainSafe/gossamer/internal/primitives/blockchain"
	common "github.com/ChainSafe/gossamer/internal/primitives/consensus/common"

	consensuscommon "github.com/ChainSafe/gossamer/internal/client/consensus/common"

	generic "github.com/ChainSafe/gossamer/internal/primitives/runtime/generic"

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

	runtime "github.com/ChainSafe/gossamer/internal/primitives/runtime"

	sync "sync"

	types "github.com/ChainSafe/gossamer/dot/types"
)

// Client is an autogenerated mock type for the Client type
type Client[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	mock.Mock
}

type Client_Expecter[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	mock *mock.Mock
}

func (_m *Client[H, Hasher, N, E, Header]) EXPECT() *Client_Expecter[H, Hasher, N, E, Header] {
	return &Client_Expecter[H, Hasher, N, E, Header]{mock: &_m.Mock}
}

// Block provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) Block(hash H) (*generic.SignedBlock[N, H, Hasher, E, Header], error) {
	ret := _m.Called(hash)

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

	var r0 *generic.SignedBlock[N, H, Hasher, E, Header]
	var r1 error
	if rf, ok := ret.Get(0).(func(H) (*generic.SignedBlock[N, H, Hasher, E, Header], error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) *generic.SignedBlock[N, H, Hasher, E, Header]); ok {
		r0 = rf(hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*generic.SignedBlock[N, H, Hasher, E, Header])
		}
	}

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

	return r0, r1
}

// Client_Block_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Block'
type Client_Block_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// Block is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) Block(hash interface{}) *Client_Block_Call[H, Hasher, N, E, Header] {
	return &Client_Block_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("Block", hash)}
}

func (_c *Client_Block_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_Block_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_Block_Call[H, Hasher, N, E, Header]) Return(_a0 *generic.SignedBlock[N, H, Hasher, E, Header], _a1 error) *Client_Block_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_Block_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) (*generic.SignedBlock[N, H, Hasher, E, Header], error)) *Client_Block_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// BlockBody provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) BlockBody(hash H) ([]E, error) {
	ret := _m.Called(hash)

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

	var r0 []E
	var r1 error
	if rf, ok := ret.Get(0).(func(H) ([]E, error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) []E); ok {
		r0 = rf(hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]E)
		}
	}

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

	return r0, r1
}

// Client_BlockBody_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockBody'
type Client_BlockBody_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// BlockBody is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) BlockBody(hash interface{}) *Client_BlockBody_Call[H, Hasher, N, E, Header] {
	return &Client_BlockBody_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("BlockBody", hash)}
}

func (_c *Client_BlockBody_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_BlockBody_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_BlockBody_Call[H, Hasher, N, E, Header]) Return(_a0 []E, _a1 error) *Client_BlockBody_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_BlockBody_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) ([]E, error)) *Client_BlockBody_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// BlockHash provides a mock function with given fields: number
func (_m *Client[H, Hasher, N, E, Header]) BlockHash(number N) (*H, error) {
	ret := _m.Called(number)

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

	var r0 *H
	var r1 error
	if rf, ok := ret.Get(0).(func(N) (*H, error)); ok {
		return rf(number)
	}
	if rf, ok := ret.Get(0).(func(N) *H); ok {
		r0 = rf(number)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*H)
		}
	}

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

	return r0, r1
}

// Client_BlockHash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockHash'
type Client_BlockHash_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// BlockHash is a helper method to define mock.On call
//   - number N
func (_e *Client_Expecter[H, Hasher, N, E, Header]) BlockHash(number interface{}) *Client_BlockHash_Call[H, Hasher, N, E, Header] {
	return &Client_BlockHash_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("BlockHash", number)}
}

func (_c *Client_BlockHash_Call[H, Hasher, N, E, Header]) Run(run func(number N)) *Client_BlockHash_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(N))
	})
	return _c
}

func (_c *Client_BlockHash_Call[H, Hasher, N, E, Header]) Return(_a0 *H, _a1 error) *Client_BlockHash_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_BlockHash_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(N) (*H, error)) *Client_BlockHash_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// BlockHashFromID provides a mock function with given fields: id
func (_m *Client[H, Hasher, N, E, Header]) BlockHashFromID(id generic.BlockID) (*H, error) {
	ret := _m.Called(id)

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

	var r0 *H
	var r1 error
	if rf, ok := ret.Get(0).(func(generic.BlockID) (*H, error)); ok {
		return rf(id)
	}
	if rf, ok := ret.Get(0).(func(generic.BlockID) *H); ok {
		r0 = rf(id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*H)
		}
	}

	if rf, ok := ret.Get(1).(func(generic.BlockID) error); ok {
		r1 = rf(id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Client_BlockHashFromID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockHashFromID'
type Client_BlockHashFromID_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// BlockHashFromID is a helper method to define mock.On call
//   - id generic.BlockID
func (_e *Client_Expecter[H, Hasher, N, E, Header]) BlockHashFromID(id interface{}) *Client_BlockHashFromID_Call[H, Hasher, N, E, Header] {
	return &Client_BlockHashFromID_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("BlockHashFromID", id)}
}

func (_c *Client_BlockHashFromID_Call[H, Hasher, N, E, Header]) Run(run func(id generic.BlockID)) *Client_BlockHashFromID_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(generic.BlockID))
	})
	return _c
}

func (_c *Client_BlockHashFromID_Call[H, Hasher, N, E, Header]) Return(_a0 *H, _a1 error) *Client_BlockHashFromID_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_BlockHashFromID_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(generic.BlockID) (*H, error)) *Client_BlockHashFromID_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// BlockIndexedBody provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) BlockIndexedBody(hash H) ([][]byte, error) {
	ret := _m.Called(hash)

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

	var r0 [][]byte
	var r1 error
	if rf, ok := ret.Get(0).(func(H) ([][]byte, error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) [][]byte); ok {
		r0 = rf(hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([][]byte)
		}
	}

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

	return r0, r1
}

// Client_BlockIndexedBody_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockIndexedBody'
type Client_BlockIndexedBody_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// BlockIndexedBody is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) BlockIndexedBody(hash interface{}) *Client_BlockIndexedBody_Call[H, Hasher, N, E, Header] {
	return &Client_BlockIndexedBody_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("BlockIndexedBody", hash)}
}

func (_c *Client_BlockIndexedBody_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_BlockIndexedBody_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_BlockIndexedBody_Call[H, Hasher, N, E, Header]) Return(_a0 [][]byte, _a1 error) *Client_BlockIndexedBody_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_BlockIndexedBody_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) ([][]byte, error)) *Client_BlockIndexedBody_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// BlockNumberFromID provides a mock function with given fields: id
func (_m *Client[H, Hasher, N, E, Header]) BlockNumberFromID(id generic.BlockID) (*N, error) {
	ret := _m.Called(id)

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

	var r0 *N
	var r1 error
	if rf, ok := ret.Get(0).(func(generic.BlockID) (*N, error)); ok {
		return rf(id)
	}
	if rf, ok := ret.Get(0).(func(generic.BlockID) *N); ok {
		r0 = rf(id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*N)
		}
	}

	if rf, ok := ret.Get(1).(func(generic.BlockID) error); ok {
		r1 = rf(id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Client_BlockNumberFromID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockNumberFromID'
type Client_BlockNumberFromID_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// BlockNumberFromID is a helper method to define mock.On call
//   - id generic.BlockID
func (_e *Client_Expecter[H, Hasher, N, E, Header]) BlockNumberFromID(id interface{}) *Client_BlockNumberFromID_Call[H, Hasher, N, E, Header] {
	return &Client_BlockNumberFromID_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("BlockNumberFromID", id)}
}

func (_c *Client_BlockNumberFromID_Call[H, Hasher, N, E, Header]) Run(run func(id generic.BlockID)) *Client_BlockNumberFromID_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(generic.BlockID))
	})
	return _c
}

func (_c *Client_BlockNumberFromID_Call[H, Hasher, N, E, Header]) Return(_a0 *N, _a1 error) *Client_BlockNumberFromID_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_BlockNumberFromID_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(generic.BlockID) (*N, error)) *Client_BlockNumberFromID_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// BlockStatus provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) BlockStatus(hash H) (common.BlockStatus, error) {
	ret := _m.Called(hash)

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

	var r0 common.BlockStatus
	var r1 error
	if rf, ok := ret.Get(0).(func(H) (common.BlockStatus, error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) common.BlockStatus); ok {
		r0 = rf(hash)
	} else {
		r0 = ret.Get(0).(common.BlockStatus)
	}

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

	return r0, r1
}

// Client_BlockStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockStatus'
type Client_BlockStatus_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// BlockStatus is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) BlockStatus(hash interface{}) *Client_BlockStatus_Call[H, Hasher, N, E, Header] {
	return &Client_BlockStatus_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("BlockStatus", hash)}
}

func (_c *Client_BlockStatus_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_BlockStatus_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_BlockStatus_Call[H, Hasher, N, E, Header]) Return(_a0 common.BlockStatus, _a1 error) *Client_BlockStatus_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_BlockStatus_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) (common.BlockStatus, error)) *Client_BlockStatus_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// Body provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) Body(hash H) ([]E, error) {
	ret := _m.Called(hash)

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

	var r0 []E
	var r1 error
	if rf, ok := ret.Get(0).(func(H) ([]E, error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) []E); ok {
		r0 = rf(hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]E)
		}
	}

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

	return r0, r1
}

// Client_Body_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Body'
type Client_Body_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// Body is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) Body(hash interface{}) *Client_Body_Call[H, Hasher, N, E, Header] {
	return &Client_Body_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("Body", hash)}
}

func (_c *Client_Body_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_Body_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_Body_Call[H, Hasher, N, E, Header]) Return(_a0 []E, _a1 error) *Client_Body_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_Body_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) ([]E, error)) *Client_Body_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// CheckBlock provides a mock function with given fields: block
func (_m *Client[H, Hasher, N, E, Header]) CheckBlock(block consensuscommon.BlockCheckParams[H, N]) (consensuscommon.ImportResult, error) {
	ret := _m.Called(block)

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

	var r0 consensuscommon.ImportResult
	var r1 error
	if rf, ok := ret.Get(0).(func(consensuscommon.BlockCheckParams[H, N]) (consensuscommon.ImportResult, error)); ok {
		return rf(block)
	}
	if rf, ok := ret.Get(0).(func(consensuscommon.BlockCheckParams[H, N]) consensuscommon.ImportResult); ok {
		r0 = rf(block)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(consensuscommon.ImportResult)
		}
	}

	if rf, ok := ret.Get(1).(func(consensuscommon.BlockCheckParams[H, N]) error); ok {
		r1 = rf(block)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Client_CheckBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckBlock'
type Client_CheckBlock_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// CheckBlock is a helper method to define mock.On call
//   - block consensuscommon.BlockCheckParams[H,N]
func (_e *Client_Expecter[H, Hasher, N, E, Header]) CheckBlock(block interface{}) *Client_CheckBlock_Call[H, Hasher, N, E, Header] {
	return &Client_CheckBlock_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("CheckBlock", block)}
}

func (_c *Client_CheckBlock_Call[H, Hasher, N, E, Header]) Run(run func(block consensuscommon.BlockCheckParams[H, N])) *Client_CheckBlock_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(consensuscommon.BlockCheckParams[H, N]))
	})
	return _c
}

func (_c *Client_CheckBlock_Call[H, Hasher, N, E, Header]) Return(_a0 consensuscommon.ImportResult, _a1 error) *Client_CheckBlock_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_CheckBlock_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(consensuscommon.BlockCheckParams[H, N]) (consensuscommon.ImportResult, error)) *Client_CheckBlock_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// Children provides a mock function with given fields: parentHash
func (_m *Client[H, Hasher, N, E, Header]) Children(parentHash H) ([]H, error) {
	ret := _m.Called(parentHash)

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

	var r0 []H
	var r1 error
	if rf, ok := ret.Get(0).(func(H) ([]H, error)); ok {
		return rf(parentHash)
	}
	if rf, ok := ret.Get(0).(func(H) []H); ok {
		r0 = rf(parentHash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]H)
		}
	}

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

	return r0, r1
}

// Client_Children_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Children'
type Client_Children_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// Children is a helper method to define mock.On call
//   - parentHash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) Children(parentHash interface{}) *Client_Children_Call[H, Hasher, N, E, Header] {
	return &Client_Children_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("Children", parentHash)}
}

func (_c *Client_Children_Call[H, Hasher, N, E, Header]) Run(run func(parentHash H)) *Client_Children_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_Children_Call[H, Hasher, N, E, Header]) Return(_a0 []H, _a1 error) *Client_Children_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_Children_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) ([]H, error)) *Client_Children_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// CompareAndSetBlockData provides a mock function with given fields: bd
func (_m *Client[H, Hasher, N, E, Header]) CompareAndSetBlockData(bd *types.BlockData) error {
	ret := _m.Called(bd)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*types.BlockData) error); ok {
		r0 = rf(bd)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// Client_CompareAndSetBlockData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompareAndSetBlockData'
type Client_CompareAndSetBlockData_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// CompareAndSetBlockData is a helper method to define mock.On call
//   - bd *types.BlockData
func (_e *Client_Expecter[H, Hasher, N, E, Header]) CompareAndSetBlockData(bd interface{}) *Client_CompareAndSetBlockData_Call[H, Hasher, N, E, Header] {
	return &Client_CompareAndSetBlockData_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("CompareAndSetBlockData", bd)}
}

func (_c *Client_CompareAndSetBlockData_Call[H, Hasher, N, E, Header]) Run(run func(bd *types.BlockData)) *Client_CompareAndSetBlockData_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*types.BlockData))
	})
	return _c
}

func (_c *Client_CompareAndSetBlockData_Call[H, Hasher, N, E, Header]) Return(_a0 error) *Client_CompareAndSetBlockData_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Client_CompareAndSetBlockData_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(*types.BlockData) error) *Client_CompareAndSetBlockData_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// DisplacedLeavesAfterFinalizing provides a mock function with given fields: blockHash, blockNumber
func (_m *Client[H, Hasher, N, E, Header]) DisplacedLeavesAfterFinalizing(blockHash H, blockNumber N) (blockchain.DisplacedLeavesAfterFinalization[H, N], error) {
	ret := _m.Called(blockHash, blockNumber)

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

	var r0 blockchain.DisplacedLeavesAfterFinalization[H, N]
	var r1 error
	if rf, ok := ret.Get(0).(func(H, N) (blockchain.DisplacedLeavesAfterFinalization[H, N], error)); ok {
		return rf(blockHash, blockNumber)
	}
	if rf, ok := ret.Get(0).(func(H, N) blockchain.DisplacedLeavesAfterFinalization[H, N]); ok {
		r0 = rf(blockHash, blockNumber)
	} else {
		r0 = ret.Get(0).(blockchain.DisplacedLeavesAfterFinalization[H, N])
	}

	if rf, ok := ret.Get(1).(func(H, N) error); ok {
		r1 = rf(blockHash, blockNumber)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Client_DisplacedLeavesAfterFinalizing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisplacedLeavesAfterFinalizing'
type Client_DisplacedLeavesAfterFinalizing_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// DisplacedLeavesAfterFinalizing is a helper method to define mock.On call
//   - blockHash H
//   - blockNumber N
func (_e *Client_Expecter[H, Hasher, N, E, Header]) DisplacedLeavesAfterFinalizing(blockHash interface{}, blockNumber interface{}) *Client_DisplacedLeavesAfterFinalizing_Call[H, Hasher, N, E, Header] {
	return &Client_DisplacedLeavesAfterFinalizing_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("DisplacedLeavesAfterFinalizing", blockHash, blockNumber)}
}

func (_c *Client_DisplacedLeavesAfterFinalizing_Call[H, Hasher, N, E, Header]) Run(run func(blockHash H, blockNumber N)) *Client_DisplacedLeavesAfterFinalizing_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H), args[1].(N))
	})
	return _c
}

func (_c *Client_DisplacedLeavesAfterFinalizing_Call[H, Hasher, N, E, Header]) Return(_a0 blockchain.DisplacedLeavesAfterFinalization[H, N], _a1 error) *Client_DisplacedLeavesAfterFinalizing_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_DisplacedLeavesAfterFinalizing_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H, N) (blockchain.DisplacedLeavesAfterFinalization[H, N], error)) *Client_DisplacedLeavesAfterFinalizing_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// HasIndexedTransaction provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) HasIndexedTransaction(hash H) (bool, error) {
	ret := _m.Called(hash)

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

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(H) (bool, error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) bool); ok {
		r0 = rf(hash)
	} else {
		r0 = ret.Get(0).(bool)
	}

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

	return r0, r1
}

// Client_HasIndexedTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasIndexedTransaction'
type Client_HasIndexedTransaction_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// HasIndexedTransaction is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) HasIndexedTransaction(hash interface{}) *Client_HasIndexedTransaction_Call[H, Hasher, N, E, Header] {
	return &Client_HasIndexedTransaction_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("HasIndexedTransaction", hash)}
}

func (_c *Client_HasIndexedTransaction_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_HasIndexedTransaction_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_HasIndexedTransaction_Call[H, Hasher, N, E, Header]) Return(_a0 bool, _a1 error) *Client_HasIndexedTransaction_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_HasIndexedTransaction_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) (bool, error)) *Client_HasIndexedTransaction_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// Hash provides a mock function with given fields: number
func (_m *Client[H, Hasher, N, E, Header]) Hash(number N) (*H, error) {
	ret := _m.Called(number)

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

	var r0 *H
	var r1 error
	if rf, ok := ret.Get(0).(func(N) (*H, error)); ok {
		return rf(number)
	}
	if rf, ok := ret.Get(0).(func(N) *H); ok {
		r0 = rf(number)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*H)
		}
	}

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

	return r0, r1
}

// Client_Hash_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hash'
type Client_Hash_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// Hash is a helper method to define mock.On call
//   - number N
func (_e *Client_Expecter[H, Hasher, N, E, Header]) Hash(number interface{}) *Client_Hash_Call[H, Hasher, N, E, Header] {
	return &Client_Hash_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("Hash", number)}
}

func (_c *Client_Hash_Call[H, Hasher, N, E, Header]) Run(run func(number N)) *Client_Hash_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(N))
	})
	return _c
}

func (_c *Client_Hash_Call[H, Hasher, N, E, Header]) Return(_a0 *H, _a1 error) *Client_Hash_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_Hash_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(N) (*H, error)) *Client_Hash_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// Header provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) Header(hash H) (*Header, error) {
	ret := _m.Called(hash)

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

	var r0 *Header
	var r1 error
	if rf, ok := ret.Get(0).(func(H) (*Header, error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) *Header); ok {
		r0 = rf(hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*Header)
		}
	}

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

	return r0, r1
}

// Client_Header_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Header'
type Client_Header_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// Header is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) Header(hash interface{}) *Client_Header_Call[H, Hasher, N, E, Header] {
	return &Client_Header_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("Header", hash)}
}

func (_c *Client_Header_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_Header_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_Header_Call[H, Hasher, N, E, Header]) Return(_a0 *Header, _a1 error) *Client_Header_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_Header_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) (*Header, error)) *Client_Header_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// HeaderMetadata provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) HeaderMetadata(hash H) (blockchain.CachedHeaderMetadata[H, N], error) {
	ret := _m.Called(hash)

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

	var r0 blockchain.CachedHeaderMetadata[H, N]
	var r1 error
	if rf, ok := ret.Get(0).(func(H) (blockchain.CachedHeaderMetadata[H, N], error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) blockchain.CachedHeaderMetadata[H, N]); ok {
		r0 = rf(hash)
	} else {
		r0 = ret.Get(0).(blockchain.CachedHeaderMetadata[H, N])
	}

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

	return r0, r1
}

// Client_HeaderMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeaderMetadata'
type Client_HeaderMetadata_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// HeaderMetadata is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) HeaderMetadata(hash interface{}) *Client_HeaderMetadata_Call[H, Hasher, N, E, Header] {
	return &Client_HeaderMetadata_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("HeaderMetadata", hash)}
}

func (_c *Client_HeaderMetadata_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_HeaderMetadata_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_HeaderMetadata_Call[H, Hasher, N, E, Header]) Return(_a0 blockchain.CachedHeaderMetadata[H, N], _a1 error) *Client_HeaderMetadata_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_HeaderMetadata_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) (blockchain.CachedHeaderMetadata[H, N], error)) *Client_HeaderMetadata_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// ImportBlock provides a mock function with given fields: block
func (_m *Client[H, Hasher, N, E, Header]) ImportBlock(block *consensuscommon.BlockImportParams[H, N, E, Header]) (consensuscommon.ImportResult, error) {
	ret := _m.Called(block)

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

	var r0 consensuscommon.ImportResult
	var r1 error
	if rf, ok := ret.Get(0).(func(*consensuscommon.BlockImportParams[H, N, E, Header]) (consensuscommon.ImportResult, error)); ok {
		return rf(block)
	}
	if rf, ok := ret.Get(0).(func(*consensuscommon.BlockImportParams[H, N, E, Header]) consensuscommon.ImportResult); ok {
		r0 = rf(block)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(consensuscommon.ImportResult)
		}
	}

	if rf, ok := ret.Get(1).(func(*consensuscommon.BlockImportParams[H, N, E, Header]) error); ok {
		r1 = rf(block)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Client_ImportBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportBlock'
type Client_ImportBlock_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// ImportBlock is a helper method to define mock.On call
//   - block *consensuscommon.BlockImportParams[H,N,E,Header]
func (_e *Client_Expecter[H, Hasher, N, E, Header]) ImportBlock(block interface{}) *Client_ImportBlock_Call[H, Hasher, N, E, Header] {
	return &Client_ImportBlock_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("ImportBlock", block)}
}

func (_c *Client_ImportBlock_Call[H, Hasher, N, E, Header]) Run(run func(block *consensuscommon.BlockImportParams[H, N, E, Header])) *Client_ImportBlock_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*consensuscommon.BlockImportParams[H, N, E, Header]))
	})
	return _c
}

func (_c *Client_ImportBlock_Call[H, Hasher, N, E, Header]) Return(_a0 consensuscommon.ImportResult, _a1 error) *Client_ImportBlock_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_ImportBlock_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(*consensuscommon.BlockImportParams[H, N, E, Header]) (consensuscommon.ImportResult, error)) *Client_ImportBlock_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// IndexedTransaction provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) IndexedTransaction(hash H) ([]byte, error) {
	ret := _m.Called(hash)

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

	var r0 []byte
	var r1 error
	if rf, ok := ret.Get(0).(func(H) ([]byte, error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) []byte); ok {
		r0 = rf(hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}

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

	return r0, r1
}

// Client_IndexedTransaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IndexedTransaction'
type Client_IndexedTransaction_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// IndexedTransaction is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) IndexedTransaction(hash interface{}) *Client_IndexedTransaction_Call[H, Hasher, N, E, Header] {
	return &Client_IndexedTransaction_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("IndexedTransaction", hash)}
}

func (_c *Client_IndexedTransaction_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_IndexedTransaction_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_IndexedTransaction_Call[H, Hasher, N, E, Header]) Return(_a0 []byte, _a1 error) *Client_IndexedTransaction_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_IndexedTransaction_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) ([]byte, error)) *Client_IndexedTransaction_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// Info provides a mock function with no fields
func (_m *Client[H, Hasher, N, E, Header]) Info() blockchain.Info[H, N] {
	ret := _m.Called()

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

	var r0 blockchain.Info[H, N]
	if rf, ok := ret.Get(0).(func() blockchain.Info[H, N]); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(blockchain.Info[H, N])
	}

	return r0
}

// Client_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info'
type Client_Info_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// Info is a helper method to define mock.On call
func (_e *Client_Expecter[H, Hasher, N, E, Header]) Info() *Client_Info_Call[H, Hasher, N, E, Header] {
	return &Client_Info_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("Info")}
}

func (_c *Client_Info_Call[H, Hasher, N, E, Header]) Run(run func()) *Client_Info_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Client_Info_Call[H, Hasher, N, E, Header]) Return(_a0 blockchain.Info[H, N]) *Client_Info_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Client_Info_Call[H, Hasher, N, E, Header]) RunAndReturn(run func() blockchain.Info[H, N]) *Client_Info_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// InsertHeaderMetadata provides a mock function with given fields: hash, headerMetadata
func (_m *Client[H, Hasher, N, E, Header]) InsertHeaderMetadata(hash H, headerMetadata blockchain.CachedHeaderMetadata[H, N]) {
	_m.Called(hash, headerMetadata)
}

// Client_InsertHeaderMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertHeaderMetadata'
type Client_InsertHeaderMetadata_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// InsertHeaderMetadata is a helper method to define mock.On call
//   - hash H
//   - headerMetadata blockchain.CachedHeaderMetadata[H,N]
func (_e *Client_Expecter[H, Hasher, N, E, Header]) InsertHeaderMetadata(hash interface{}, headerMetadata interface{}) *Client_InsertHeaderMetadata_Call[H, Hasher, N, E, Header] {
	return &Client_InsertHeaderMetadata_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("InsertHeaderMetadata", hash, headerMetadata)}
}

func (_c *Client_InsertHeaderMetadata_Call[H, Hasher, N, E, Header]) Run(run func(hash H, headerMetadata blockchain.CachedHeaderMetadata[H, N])) *Client_InsertHeaderMetadata_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H), args[1].(blockchain.CachedHeaderMetadata[H, N]))
	})
	return _c
}

func (_c *Client_InsertHeaderMetadata_Call[H, Hasher, N, E, Header]) Return() *Client_InsertHeaderMetadata_Call[H, Hasher, N, E, Header] {
	_c.Call.Return()
	return _c
}

func (_c *Client_InsertHeaderMetadata_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H, blockchain.CachedHeaderMetadata[H, N])) *Client_InsertHeaderMetadata_Call[H, Hasher, N, E, Header] {
	_c.Run(run)
	return _c
}

// Justifications provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) Justifications(hash H) (runtime.Justifications, error) {
	ret := _m.Called(hash)

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

	var r0 runtime.Justifications
	var r1 error
	if rf, ok := ret.Get(0).(func(H) (runtime.Justifications, error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) runtime.Justifications); ok {
		r0 = rf(hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(runtime.Justifications)
		}
	}

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

	return r0, r1
}

// Client_Justifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Justifications'
type Client_Justifications_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// Justifications is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) Justifications(hash interface{}) *Client_Justifications_Call[H, Hasher, N, E, Header] {
	return &Client_Justifications_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("Justifications", hash)}
}

func (_c *Client_Justifications_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_Justifications_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_Justifications_Call[H, Hasher, N, E, Header]) Return(_a0 runtime.Justifications, _a1 error) *Client_Justifications_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_Justifications_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) (runtime.Justifications, error)) *Client_Justifications_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// LastFinalized provides a mock function with no fields
func (_m *Client[H, Hasher, N, E, Header]) LastFinalized() (H, error) {
	ret := _m.Called()

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

	var r0 H
	var r1 error
	if rf, ok := ret.Get(0).(func() (H, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() H); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(H)
		}
	}

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

	return r0, r1
}

// Client_LastFinalized_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastFinalized'
type Client_LastFinalized_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// LastFinalized is a helper method to define mock.On call
func (_e *Client_Expecter[H, Hasher, N, E, Header]) LastFinalized() *Client_LastFinalized_Call[H, Hasher, N, E, Header] {
	return &Client_LastFinalized_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("LastFinalized")}
}

func (_c *Client_LastFinalized_Call[H, Hasher, N, E, Header]) Run(run func()) *Client_LastFinalized_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Client_LastFinalized_Call[H, Hasher, N, E, Header]) Return(_a0 H, _a1 error) *Client_LastFinalized_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_LastFinalized_Call[H, Hasher, N, E, Header]) RunAndReturn(run func() (H, error)) *Client_LastFinalized_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// Leaves provides a mock function with no fields
func (_m *Client[H, Hasher, N, E, Header]) Leaves() ([]H, error) {
	ret := _m.Called()

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

	var r0 []H
	var r1 error
	if rf, ok := ret.Get(0).(func() ([]H, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() []H); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]H)
		}
	}

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

	return r0, r1
}

// Client_Leaves_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Leaves'
type Client_Leaves_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// Leaves is a helper method to define mock.On call
func (_e *Client_Expecter[H, Hasher, N, E, Header]) Leaves() *Client_Leaves_Call[H, Hasher, N, E, Header] {
	return &Client_Leaves_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("Leaves")}
}

func (_c *Client_Leaves_Call[H, Hasher, N, E, Header]) Run(run func()) *Client_Leaves_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Client_Leaves_Call[H, Hasher, N, E, Header]) Return(_a0 []H, _a1 error) *Client_Leaves_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_Leaves_Call[H, Hasher, N, E, Header]) RunAndReturn(run func() ([]H, error)) *Client_Leaves_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// LongestContaining provides a mock function with given fields: baseHash, importLock
func (_m *Client[H, Hasher, N, E, Header]) LongestContaining(baseHash H, importLock *sync.RWMutex) (*H, error) {
	ret := _m.Called(baseHash, importLock)

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

	var r0 *H
	var r1 error
	if rf, ok := ret.Get(0).(func(H, *sync.RWMutex) (*H, error)); ok {
		return rf(baseHash, importLock)
	}
	if rf, ok := ret.Get(0).(func(H, *sync.RWMutex) *H); ok {
		r0 = rf(baseHash, importLock)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*H)
		}
	}

	if rf, ok := ret.Get(1).(func(H, *sync.RWMutex) error); ok {
		r1 = rf(baseHash, importLock)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Client_LongestContaining_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LongestContaining'
type Client_LongestContaining_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// LongestContaining is a helper method to define mock.On call
//   - baseHash H
//   - importLock *sync.RWMutex
func (_e *Client_Expecter[H, Hasher, N, E, Header]) LongestContaining(baseHash interface{}, importLock interface{}) *Client_LongestContaining_Call[H, Hasher, N, E, Header] {
	return &Client_LongestContaining_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("LongestContaining", baseHash, importLock)}
}

func (_c *Client_LongestContaining_Call[H, Hasher, N, E, Header]) Run(run func(baseHash H, importLock *sync.RWMutex)) *Client_LongestContaining_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H), args[1].(*sync.RWMutex))
	})
	return _c
}

func (_c *Client_LongestContaining_Call[H, Hasher, N, E, Header]) Return(_a0 *H, _a1 error) *Client_LongestContaining_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_LongestContaining_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H, *sync.RWMutex) (*H, error)) *Client_LongestContaining_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// Number provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) Number(hash H) (*N, error) {
	ret := _m.Called(hash)

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

	var r0 *N
	var r1 error
	if rf, ok := ret.Get(0).(func(H) (*N, error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) *N); ok {
		r0 = rf(hash)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*N)
		}
	}

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

	return r0, r1
}

// Client_Number_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Number'
type Client_Number_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// Number is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) Number(hash interface{}) *Client_Number_Call[H, Hasher, N, E, Header] {
	return &Client_Number_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("Number", hash)}
}

func (_c *Client_Number_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_Number_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_Number_Call[H, Hasher, N, E, Header]) Return(_a0 *N, _a1 error) *Client_Number_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_Number_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) (*N, error)) *Client_Number_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// RemoveHeaderMetadata provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) RemoveHeaderMetadata(hash H) {
	_m.Called(hash)
}

// Client_RemoveHeaderMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveHeaderMetadata'
type Client_RemoveHeaderMetadata_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// RemoveHeaderMetadata is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) RemoveHeaderMetadata(hash interface{}) *Client_RemoveHeaderMetadata_Call[H, Hasher, N, E, Header] {
	return &Client_RemoveHeaderMetadata_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("RemoveHeaderMetadata", hash)}
}

func (_c *Client_RemoveHeaderMetadata_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_RemoveHeaderMetadata_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_RemoveHeaderMetadata_Call[H, Hasher, N, E, Header]) Return() *Client_RemoveHeaderMetadata_Call[H, Hasher, N, E, Header] {
	_c.Call.Return()
	return _c
}

func (_c *Client_RemoveHeaderMetadata_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H)) *Client_RemoveHeaderMetadata_Call[H, Hasher, N, E, Header] {
	_c.Run(run)
	return _c
}

// RequiresFullSync provides a mock function with no fields
func (_m *Client[H, Hasher, N, E, Header]) RequiresFullSync() bool {
	ret := _m.Called()

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

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// Client_RequiresFullSync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequiresFullSync'
type Client_RequiresFullSync_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// RequiresFullSync is a helper method to define mock.On call
func (_e *Client_Expecter[H, Hasher, N, E, Header]) RequiresFullSync() *Client_RequiresFullSync_Call[H, Hasher, N, E, Header] {
	return &Client_RequiresFullSync_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("RequiresFullSync")}
}

func (_c *Client_RequiresFullSync_Call[H, Hasher, N, E, Header]) Run(run func()) *Client_RequiresFullSync_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Client_RequiresFullSync_Call[H, Hasher, N, E, Header]) Return(_a0 bool) *Client_RequiresFullSync_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Client_RequiresFullSync_Call[H, Hasher, N, E, Header]) RunAndReturn(run func() bool) *Client_RequiresFullSync_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// Status provides a mock function with given fields: hash
func (_m *Client[H, Hasher, N, E, Header]) Status(hash H) (blockchain.BlockStatus, error) {
	ret := _m.Called(hash)

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

	var r0 blockchain.BlockStatus
	var r1 error
	if rf, ok := ret.Get(0).(func(H) (blockchain.BlockStatus, error)); ok {
		return rf(hash)
	}
	if rf, ok := ret.Get(0).(func(H) blockchain.BlockStatus); ok {
		r0 = rf(hash)
	} else {
		r0 = ret.Get(0).(blockchain.BlockStatus)
	}

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

	return r0, r1
}

// Client_Status_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Status'
type Client_Status_Call[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]] struct {
	*mock.Call
}

// Status is a helper method to define mock.On call
//   - hash H
func (_e *Client_Expecter[H, Hasher, N, E, Header]) Status(hash interface{}) *Client_Status_Call[H, Hasher, N, E, Header] {
	return &Client_Status_Call[H, Hasher, N, E, Header]{Call: _e.mock.On("Status", hash)}
}

func (_c *Client_Status_Call[H, Hasher, N, E, Header]) Run(run func(hash H)) *Client_Status_Call[H, Hasher, N, E, Header] {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(H))
	})
	return _c
}

func (_c *Client_Status_Call[H, Hasher, N, E, Header]) Return(_a0 blockchain.BlockStatus, _a1 error) *Client_Status_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Client_Status_Call[H, Hasher, N, E, Header]) RunAndReturn(run func(H) (blockchain.BlockStatus, error)) *Client_Status_Call[H, Hasher, N, E, Header] {
	_c.Call.Return(run)
	return _c
}

// NewClient creates a new instance of Client. 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 NewClient[H runtime.Hash, Hasher runtime.Hasher[H], N runtime.Number, E runtime.Extrinsic, Header runtime.Header[N, H]](t interface {
	mock.TestingT
	Cleanup(func())
}) *Client[H, Hasher, N, E, Header] {
	mock := &Client[H, Hasher, N, E, Header]{}
	mock.Mock.Test(t)

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

	return mock
}
