OverflowClient.go

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

package mocks

import (
	cadence "github.com/onflow/cadence"
	accounts "github.com/onflow/flowkit/accounts"

	context "context"

	flow "github.com/onflow/flow-go-sdk"

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

	overflow "github.com/bjartek/overflow"
)

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

type OverflowClient_Expecter struct {
	mock *mock.Mock
}

func (_m *OverflowClient) EXPECT() *OverflowClient_Expecter {
	return &OverflowClient_Expecter{mock: &_m.Mock}
}

// Account provides a mock function with given fields: key
func (_m *OverflowClient) Account(key string) *accounts.Account {
	ret := _m.Called(key)

	var r0 *accounts.Account
	if rf, ok := ret.Get(0).(func(string) *accounts.Account); ok {
		r0 = rf(key)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*accounts.Account)
		}
	}

	return r0
}

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

// Account is a helper method to define mock.On call
//   - key string
func (_e *OverflowClient_Expecter) Account(key interface{}) *OverflowClient_Account_Call {
	return &OverflowClient_Account_Call{Call: _e.mock.On("Account", key)}
}

func (_c *OverflowClient_Account_Call) Run(run func(key string)) *OverflowClient_Account_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *OverflowClient_Account_Call) Return(_a0 *accounts.Account) *OverflowClient_Account_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_Account_Call) RunAndReturn(run func(string) *accounts.Account) *OverflowClient_Account_Call {
	_c.Call.Return(run)
	return _c
}

// AccountE provides a mock function with given fields: key
func (_m *OverflowClient) AccountE(key string) (*accounts.Account, error) {
	ret := _m.Called(key)

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

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

	return r0, r1
}

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

// AccountE is a helper method to define mock.On call
//   - key string
func (_e *OverflowClient_Expecter) AccountE(key interface{}) *OverflowClient_AccountE_Call {
	return &OverflowClient_AccountE_Call{Call: _e.mock.On("AccountE", key)}
}

func (_c *OverflowClient_AccountE_Call) Run(run func(key string)) *OverflowClient_AccountE_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *OverflowClient_AccountE_Call) Return(_a0 *accounts.Account, _a1 error) *OverflowClient_AccountE_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *OverflowClient_AccountE_Call) RunAndReturn(run func(string) (*accounts.Account, error)) *OverflowClient_AccountE_Call {
	_c.Call.Return(run)
	return _c
}

// AccountPublicKey provides a mock function with given fields: name
func (_m *OverflowClient) AccountPublicKey(name string) (string, error) {
	ret := _m.Called(name)

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

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

	return r0, r1
}

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

// AccountPublicKey is a helper method to define mock.On call
//   - name string
func (_e *OverflowClient_Expecter) AccountPublicKey(name interface{}) *OverflowClient_AccountPublicKey_Call {
	return &OverflowClient_AccountPublicKey_Call{Call: _e.mock.On("AccountPublicKey", name)}
}

func (_c *OverflowClient_AccountPublicKey_Call) Run(run func(name string)) *OverflowClient_AccountPublicKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *OverflowClient_AccountPublicKey_Call) Return(_a0 string, _a1 error) *OverflowClient_AccountPublicKey_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *OverflowClient_AccountPublicKey_Call) RunAndReturn(run func(string) (string, error)) *OverflowClient_AccountPublicKey_Call {
	_c.Call.Return(run)
	return _c
}

// AddContract provides a mock function with given fields: ctx, name, code, args, filename, update
func (_m *OverflowClient) AddContract(ctx context.Context, name string, code []byte, args []cadence.Value, filename string, update bool) error {
	ret := _m.Called(ctx, name, code, args, filename, update)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, []byte, []cadence.Value, string, bool) error); ok {
		r0 = rf(ctx, name, code, args, filename, update)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddContract is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
//   - code []byte
//   - args []cadence.Value
//   - filename string
//   - update bool
func (_e *OverflowClient_Expecter) AddContract(ctx interface{}, name interface{}, code interface{}, args interface{}, filename interface{}, update interface{}) *OverflowClient_AddContract_Call {
	return &OverflowClient_AddContract_Call{Call: _e.mock.On("AddContract", ctx, name, code, args, filename, update)}
}

func (_c *OverflowClient_AddContract_Call) Run(run func(ctx context.Context, name string, code []byte, args []cadence.Value, filename string, update bool)) *OverflowClient_AddContract_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].([]byte), args[3].([]cadence.Value), args[4].(string), args[5].(bool))
	})
	return _c
}

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

func (_c *OverflowClient_AddContract_Call) RunAndReturn(run func(context.Context, string, []byte, []cadence.Value, string, bool) error) *OverflowClient_AddContract_Call {
	_c.Call.Return(run)
	return _c
}

// Address provides a mock function with given fields: key
func (_m *OverflowClient) Address(key string) string {
	ret := _m.Called(key)

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

	return r0
}

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

// Address is a helper method to define mock.On call
//   - key string
func (_e *OverflowClient_Expecter) Address(key interface{}) *OverflowClient_Address_Call {
	return &OverflowClient_Address_Call{Call: _e.mock.On("Address", key)}
}

func (_c *OverflowClient_Address_Call) Run(run func(key string)) *OverflowClient_Address_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *OverflowClient_Address_Call) Return(_a0 string) *OverflowClient_Address_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_Address_Call) RunAndReturn(run func(string) string) *OverflowClient_Address_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadAndUploadFile provides a mock function with given fields: url, accountName
func (_m *OverflowClient) DownloadAndUploadFile(url string, accountName string) error {
	ret := _m.Called(url, accountName)

	var r0 error
	if rf, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = rf(url, accountName)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DownloadAndUploadFile is a helper method to define mock.On call
//   - url string
//   - accountName string
func (_e *OverflowClient_Expecter) DownloadAndUploadFile(url interface{}, accountName interface{}) *OverflowClient_DownloadAndUploadFile_Call {
	return &OverflowClient_DownloadAndUploadFile_Call{Call: _e.mock.On("DownloadAndUploadFile", url, accountName)}
}

func (_c *OverflowClient_DownloadAndUploadFile_Call) Run(run func(url string, accountName string)) *OverflowClient_DownloadAndUploadFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

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

func (_c *OverflowClient_DownloadAndUploadFile_Call) RunAndReturn(run func(string, string) error) *OverflowClient_DownloadAndUploadFile_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadImageAndUploadAsDataUrl provides a mock function with given fields: url, accountName
func (_m *OverflowClient) DownloadImageAndUploadAsDataUrl(url string, accountName string) error {
	ret := _m.Called(url, accountName)

	var r0 error
	if rf, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = rf(url, accountName)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DownloadImageAndUploadAsDataUrl is a helper method to define mock.On call
//   - url string
//   - accountName string
func (_e *OverflowClient_Expecter) DownloadImageAndUploadAsDataUrl(url interface{}, accountName interface{}) *OverflowClient_DownloadImageAndUploadAsDataUrl_Call {
	return &OverflowClient_DownloadImageAndUploadAsDataUrl_Call{Call: _e.mock.On("DownloadImageAndUploadAsDataUrl", url, accountName)}
}

func (_c *OverflowClient_DownloadImageAndUploadAsDataUrl_Call) Run(run func(url string, accountName string)) *OverflowClient_DownloadImageAndUploadAsDataUrl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

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

func (_c *OverflowClient_DownloadImageAndUploadAsDataUrl_Call) RunAndReturn(run func(string, string) error) *OverflowClient_DownloadImageAndUploadAsDataUrl_Call {
	_c.Call.Return(run)
	return _c
}

// FetchEventsWithResult provides a mock function with given fields: opts
func (_m *OverflowClient) FetchEventsWithResult(opts ...overflow.OverflowEventFetcherOption) overflow.EventFetcherResult {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 overflow.EventFetcherResult
	if rf, ok := ret.Get(0).(func(...overflow.OverflowEventFetcherOption) overflow.EventFetcherResult); ok {
		r0 = rf(opts...)
	} else {
		r0 = ret.Get(0).(overflow.EventFetcherResult)
	}

	return r0
}

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

// FetchEventsWithResult is a helper method to define mock.On call
//   - opts ...overflow.OverflowEventFetcherOption
func (_e *OverflowClient_Expecter) FetchEventsWithResult(opts ...interface{}) *OverflowClient_FetchEventsWithResult_Call {
	return &OverflowClient_FetchEventsWithResult_Call{Call: _e.mock.On("FetchEventsWithResult",
		append([]interface{}{}, opts...)...)}
}

func (_c *OverflowClient_FetchEventsWithResult_Call) Run(run func(opts ...overflow.OverflowEventFetcherOption)) *OverflowClient_FetchEventsWithResult_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]overflow.OverflowEventFetcherOption, len(args)-0)
		for i, a := range args[0:] {
			if a != nil {
				variadicArgs[i] = a.(overflow.OverflowEventFetcherOption)
			}
		}
		run(variadicArgs...)
	})
	return _c
}

func (_c *OverflowClient_FetchEventsWithResult_Call) Return(_a0 overflow.EventFetcherResult) *OverflowClient_FetchEventsWithResult_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_FetchEventsWithResult_Call) RunAndReturn(run func(...overflow.OverflowEventFetcherOption) overflow.EventFetcherResult) *OverflowClient_FetchEventsWithResult_Call {
	_c.Call.Return(run)
	return _c
}

// FillUpStorage provides a mock function with given fields: accountName
func (_m *OverflowClient) FillUpStorage(accountName string) *overflow.OverflowState {
	ret := _m.Called(accountName)

	var r0 *overflow.OverflowState
	if rf, ok := ret.Get(0).(func(string) *overflow.OverflowState); ok {
		r0 = rf(accountName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*overflow.OverflowState)
		}
	}

	return r0
}

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

// FillUpStorage is a helper method to define mock.On call
//   - accountName string
func (_e *OverflowClient_Expecter) FillUpStorage(accountName interface{}) *OverflowClient_FillUpStorage_Call {
	return &OverflowClient_FillUpStorage_Call{Call: _e.mock.On("FillUpStorage", accountName)}
}

func (_c *OverflowClient_FillUpStorage_Call) Run(run func(accountName string)) *OverflowClient_FillUpStorage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *OverflowClient_FillUpStorage_Call) Return(_a0 *overflow.OverflowState) *OverflowClient_FillUpStorage_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_FillUpStorage_Call) RunAndReturn(run func(string) *overflow.OverflowState) *OverflowClient_FillUpStorage_Call {
	_c.Call.Return(run)
	return _c
}

// GetAccount provides a mock function with given fields: ctx, key
func (_m *OverflowClient) GetAccount(ctx context.Context, key string) (*flow.Account, error) {
	ret := _m.Called(ctx, key)

	var r0 *flow.Account
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*flow.Account, error)); ok {
		return rf(ctx, key)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *flow.Account); ok {
		r0 = rf(ctx, key)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flow.Account)
		}
	}

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

	return r0, r1
}

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

// GetAccount is a helper method to define mock.On call
//   - ctx context.Context
//   - key string
func (_e *OverflowClient_Expecter) GetAccount(ctx interface{}, key interface{}) *OverflowClient_GetAccount_Call {
	return &OverflowClient_GetAccount_Call{Call: _e.mock.On("GetAccount", ctx, key)}
}

func (_c *OverflowClient_GetAccount_Call) Run(run func(ctx context.Context, key string)) *OverflowClient_GetAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *OverflowClient_GetAccount_Call) Return(_a0 *flow.Account, _a1 error) *OverflowClient_GetAccount_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *OverflowClient_GetAccount_Call) RunAndReturn(run func(context.Context, string) (*flow.Account, error)) *OverflowClient_GetAccount_Call {
	_c.Call.Return(run)
	return _c
}

// GetBlockAtHeight provides a mock function with given fields: ctx, height
func (_m *OverflowClient) GetBlockAtHeight(ctx context.Context, height uint64) (*flow.Block, error) {
	ret := _m.Called(ctx, height)

	var r0 *flow.Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uint64) (*flow.Block, error)); ok {
		return rf(ctx, height)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uint64) *flow.Block); ok {
		r0 = rf(ctx, height)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flow.Block)
		}
	}

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

	return r0, r1
}

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

// GetBlockAtHeight is a helper method to define mock.On call
//   - ctx context.Context
//   - height uint64
func (_e *OverflowClient_Expecter) GetBlockAtHeight(ctx interface{}, height interface{}) *OverflowClient_GetBlockAtHeight_Call {
	return &OverflowClient_GetBlockAtHeight_Call{Call: _e.mock.On("GetBlockAtHeight", ctx, height)}
}

func (_c *OverflowClient_GetBlockAtHeight_Call) Run(run func(ctx context.Context, height uint64)) *OverflowClient_GetBlockAtHeight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uint64))
	})
	return _c
}

func (_c *OverflowClient_GetBlockAtHeight_Call) Return(_a0 *flow.Block, _a1 error) *OverflowClient_GetBlockAtHeight_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *OverflowClient_GetBlockAtHeight_Call) RunAndReturn(run func(context.Context, uint64) (*flow.Block, error)) *OverflowClient_GetBlockAtHeight_Call {
	_c.Call.Return(run)
	return _c
}

// GetBlockById provides a mock function with given fields: ctx, blockId
func (_m *OverflowClient) GetBlockById(ctx context.Context, blockId string) (*flow.Block, error) {
	ret := _m.Called(ctx, blockId)

	var r0 *flow.Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*flow.Block, error)); ok {
		return rf(ctx, blockId)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *flow.Block); ok {
		r0 = rf(ctx, blockId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flow.Block)
		}
	}

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

	return r0, r1
}

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

// GetBlockById is a helper method to define mock.On call
//   - ctx context.Context
//   - blockId string
func (_e *OverflowClient_Expecter) GetBlockById(ctx interface{}, blockId interface{}) *OverflowClient_GetBlockById_Call {
	return &OverflowClient_GetBlockById_Call{Call: _e.mock.On("GetBlockById", ctx, blockId)}
}

func (_c *OverflowClient_GetBlockById_Call) Run(run func(ctx context.Context, blockId string)) *OverflowClient_GetBlockById_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *OverflowClient_GetBlockById_Call) Return(_a0 *flow.Block, _a1 error) *OverflowClient_GetBlockById_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *OverflowClient_GetBlockById_Call) RunAndReturn(run func(context.Context, string) (*flow.Block, error)) *OverflowClient_GetBlockById_Call {
	_c.Call.Return(run)
	return _c
}

// GetFreeCapacity provides a mock function with given fields: accountName
func (_m *OverflowClient) GetFreeCapacity(accountName string) int {
	ret := _m.Called(accountName)

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

	return r0
}

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

// GetFreeCapacity is a helper method to define mock.On call
//   - accountName string
func (_e *OverflowClient_Expecter) GetFreeCapacity(accountName interface{}) *OverflowClient_GetFreeCapacity_Call {
	return &OverflowClient_GetFreeCapacity_Call{Call: _e.mock.On("GetFreeCapacity", accountName)}
}

func (_c *OverflowClient_GetFreeCapacity_Call) Run(run func(accountName string)) *OverflowClient_GetFreeCapacity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *OverflowClient_GetFreeCapacity_Call) Return(_a0 int) *OverflowClient_GetFreeCapacity_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_GetFreeCapacity_Call) RunAndReturn(run func(string) int) *OverflowClient_GetFreeCapacity_Call {
	_c.Call.Return(run)
	return _c
}

// GetLatestBlock provides a mock function with given fields: ctx
func (_m *OverflowClient) GetLatestBlock(ctx context.Context) (*flow.Block, error) {
	ret := _m.Called(ctx)

	var r0 *flow.Block
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*flow.Block, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *flow.Block); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flow.Block)
		}
	}

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

	return r0, r1
}

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

// GetLatestBlock is a helper method to define mock.On call
//   - ctx context.Context
func (_e *OverflowClient_Expecter) GetLatestBlock(ctx interface{}) *OverflowClient_GetLatestBlock_Call {
	return &OverflowClient_GetLatestBlock_Call{Call: _e.mock.On("GetLatestBlock", ctx)}
}

func (_c *OverflowClient_GetLatestBlock_Call) Run(run func(ctx context.Context)) *OverflowClient_GetLatestBlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *OverflowClient_GetLatestBlock_Call) Return(_a0 *flow.Block, _a1 error) *OverflowClient_GetLatestBlock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *OverflowClient_GetLatestBlock_Call) RunAndReturn(run func(context.Context) (*flow.Block, error)) *OverflowClient_GetLatestBlock_Call {
	_c.Call.Return(run)
	return _c
}

// GetNetwork provides a mock function with given fields:
func (_m *OverflowClient) GetNetwork() string {
	ret := _m.Called()

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

	return r0
}

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

// GetNetwork is a helper method to define mock.On call
func (_e *OverflowClient_Expecter) GetNetwork() *OverflowClient_GetNetwork_Call {
	return &OverflowClient_GetNetwork_Call{Call: _e.mock.On("GetNetwork")}
}

func (_c *OverflowClient_GetNetwork_Call) Run(run func()) *OverflowClient_GetNetwork_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *OverflowClient_GetNetwork_Call) Return(_a0 string) *OverflowClient_GetNetwork_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_GetNetwork_Call) RunAndReturn(run func() string) *OverflowClient_GetNetwork_Call {
	_c.Call.Return(run)
	return _c
}

// MintFlowTokens provides a mock function with given fields: accountName, amount
func (_m *OverflowClient) MintFlowTokens(accountName string, amount float64) *overflow.OverflowState {
	ret := _m.Called(accountName, amount)

	var r0 *overflow.OverflowState
	if rf, ok := ret.Get(0).(func(string, float64) *overflow.OverflowState); ok {
		r0 = rf(accountName, amount)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*overflow.OverflowState)
		}
	}

	return r0
}

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

// MintFlowTokens is a helper method to define mock.On call
//   - accountName string
//   - amount float64
func (_e *OverflowClient_Expecter) MintFlowTokens(accountName interface{}, amount interface{}) *OverflowClient_MintFlowTokens_Call {
	return &OverflowClient_MintFlowTokens_Call{Call: _e.mock.On("MintFlowTokens", accountName, amount)}
}

func (_c *OverflowClient_MintFlowTokens_Call) Run(run func(accountName string, amount float64)) *OverflowClient_MintFlowTokens_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(float64))
	})
	return _c
}

func (_c *OverflowClient_MintFlowTokens_Call) Return(_a0 *overflow.OverflowState) *OverflowClient_MintFlowTokens_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_MintFlowTokens_Call) RunAndReturn(run func(string, float64) *overflow.OverflowState) *OverflowClient_MintFlowTokens_Call {
	_c.Call.Return(run)
	return _c
}

// QualifiedIdentifier provides a mock function with given fields: contract, name
func (_m *OverflowClient) QualifiedIdentifier(contract string, name string) (string, error) {
	ret := _m.Called(contract, name)

	var r0 string
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string) (string, error)); ok {
		return rf(contract, name)
	}
	if rf, ok := ret.Get(0).(func(string, string) string); ok {
		r0 = rf(contract, name)
	} else {
		r0 = ret.Get(0).(string)
	}

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

	return r0, r1
}

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

// QualifiedIdentifier is a helper method to define mock.On call
//   - contract string
//   - name string
func (_e *OverflowClient_Expecter) QualifiedIdentifier(contract interface{}, name interface{}) *OverflowClient_QualifiedIdentifier_Call {
	return &OverflowClient_QualifiedIdentifier_Call{Call: _e.mock.On("QualifiedIdentifier", contract, name)}
}

func (_c *OverflowClient_QualifiedIdentifier_Call) Run(run func(contract string, name string)) *OverflowClient_QualifiedIdentifier_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

func (_c *OverflowClient_QualifiedIdentifier_Call) Return(_a0 string, _a1 error) *OverflowClient_QualifiedIdentifier_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *OverflowClient_QualifiedIdentifier_Call) RunAndReturn(run func(string, string) (string, error)) *OverflowClient_QualifiedIdentifier_Call {
	_c.Call.Return(run)
	return _c
}

// QualifiedIdentifierFromSnakeCase provides a mock function with given fields: typeName
func (_m *OverflowClient) QualifiedIdentifierFromSnakeCase(typeName string) (string, error) {
	ret := _m.Called(typeName)

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

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

	return r0, r1
}

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

// QualifiedIdentifierFromSnakeCase is a helper method to define mock.On call
//   - typeName string
func (_e *OverflowClient_Expecter) QualifiedIdentifierFromSnakeCase(typeName interface{}) *OverflowClient_QualifiedIdentifierFromSnakeCase_Call {
	return &OverflowClient_QualifiedIdentifierFromSnakeCase_Call{Call: _e.mock.On("QualifiedIdentifierFromSnakeCase", typeName)}
}

func (_c *OverflowClient_QualifiedIdentifierFromSnakeCase_Call) Run(run func(typeName string)) *OverflowClient_QualifiedIdentifierFromSnakeCase_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *OverflowClient_QualifiedIdentifierFromSnakeCase_Call) Return(_a0 string, _a1 error) *OverflowClient_QualifiedIdentifierFromSnakeCase_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *OverflowClient_QualifiedIdentifierFromSnakeCase_Call) RunAndReturn(run func(string) (string, error)) *OverflowClient_QualifiedIdentifierFromSnakeCase_Call {
	_c.Call.Return(run)
	return _c
}

// Script provides a mock function with given fields: filename, opts
func (_m *OverflowClient) Script(filename string, opts ...overflow.OverflowInteractionOption) *overflow.OverflowScriptResult {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, filename)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *overflow.OverflowScriptResult
	if rf, ok := ret.Get(0).(func(string, ...overflow.OverflowInteractionOption) *overflow.OverflowScriptResult); ok {
		r0 = rf(filename, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*overflow.OverflowScriptResult)
		}
	}

	return r0
}

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

// Script is a helper method to define mock.On call
//   - filename string
//   - opts ...overflow.OverflowInteractionOption
func (_e *OverflowClient_Expecter) Script(filename interface{}, opts ...interface{}) *OverflowClient_Script_Call {
	return &OverflowClient_Script_Call{Call: _e.mock.On("Script",
		append([]interface{}{filename}, opts...)...)}
}

func (_c *OverflowClient_Script_Call) Run(run func(filename string, opts ...overflow.OverflowInteractionOption)) *OverflowClient_Script_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(overflow.OverflowInteractionOption)
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *OverflowClient_Script_Call) Return(_a0 *overflow.OverflowScriptResult) *OverflowClient_Script_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_Script_Call) RunAndReturn(run func(string, ...overflow.OverflowInteractionOption) *overflow.OverflowScriptResult) *OverflowClient_Script_Call {
	_c.Call.Return(run)
	return _c
}

// ScriptFN provides a mock function with given fields: outerOpts
func (_m *OverflowClient) ScriptFN(outerOpts ...overflow.OverflowInteractionOption) overflow.OverflowScriptFunction {
	_va := make([]interface{}, len(outerOpts))
	for _i := range outerOpts {
		_va[_i] = outerOpts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 overflow.OverflowScriptFunction
	if rf, ok := ret.Get(0).(func(...overflow.OverflowInteractionOption) overflow.OverflowScriptFunction); ok {
		r0 = rf(outerOpts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(overflow.OverflowScriptFunction)
		}
	}

	return r0
}

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

// ScriptFN is a helper method to define mock.On call
//   - outerOpts ...overflow.OverflowInteractionOption
func (_e *OverflowClient_Expecter) ScriptFN(outerOpts ...interface{}) *OverflowClient_ScriptFN_Call {
	return &OverflowClient_ScriptFN_Call{Call: _e.mock.On("ScriptFN",
		append([]interface{}{}, outerOpts...)...)}
}

func (_c *OverflowClient_ScriptFN_Call) Run(run func(outerOpts ...overflow.OverflowInteractionOption)) *OverflowClient_ScriptFN_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-0)
		for i, a := range args[0:] {
			if a != nil {
				variadicArgs[i] = a.(overflow.OverflowInteractionOption)
			}
		}
		run(variadicArgs...)
	})
	return _c
}

func (_c *OverflowClient_ScriptFN_Call) Return(_a0 overflow.OverflowScriptFunction) *OverflowClient_ScriptFN_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_ScriptFN_Call) RunAndReturn(run func(...overflow.OverflowInteractionOption) overflow.OverflowScriptFunction) *OverflowClient_ScriptFN_Call {
	_c.Call.Return(run)
	return _c
}

// ScriptFileNameFN provides a mock function with given fields: filename, outerOpts
func (_m *OverflowClient) ScriptFileNameFN(filename string, outerOpts ...overflow.OverflowInteractionOption) overflow.OverflowScriptOptsFunction {
	_va := make([]interface{}, len(outerOpts))
	for _i := range outerOpts {
		_va[_i] = outerOpts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, filename)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 overflow.OverflowScriptOptsFunction
	if rf, ok := ret.Get(0).(func(string, ...overflow.OverflowInteractionOption) overflow.OverflowScriptOptsFunction); ok {
		r0 = rf(filename, outerOpts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(overflow.OverflowScriptOptsFunction)
		}
	}

	return r0
}

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

// ScriptFileNameFN is a helper method to define mock.On call
//   - filename string
//   - outerOpts ...overflow.OverflowInteractionOption
func (_e *OverflowClient_Expecter) ScriptFileNameFN(filename interface{}, outerOpts ...interface{}) *OverflowClient_ScriptFileNameFN_Call {
	return &OverflowClient_ScriptFileNameFN_Call{Call: _e.mock.On("ScriptFileNameFN",
		append([]interface{}{filename}, outerOpts...)...)}
}

func (_c *OverflowClient_ScriptFileNameFN_Call) Run(run func(filename string, outerOpts ...overflow.OverflowInteractionOption)) *OverflowClient_ScriptFileNameFN_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(overflow.OverflowInteractionOption)
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *OverflowClient_ScriptFileNameFN_Call) Return(_a0 overflow.OverflowScriptOptsFunction) *OverflowClient_ScriptFileNameFN_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_ScriptFileNameFN_Call) RunAndReturn(run func(string, ...overflow.OverflowInteractionOption) overflow.OverflowScriptOptsFunction) *OverflowClient_ScriptFileNameFN_Call {
	_c.Call.Return(run)
	return _c
}

// SignUserMessage provides a mock function with given fields: account, message
func (_m *OverflowClient) SignUserMessage(account string, message string) (string, error) {
	ret := _m.Called(account, message)

	var r0 string
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string) (string, error)); ok {
		return rf(account, message)
	}
	if rf, ok := ret.Get(0).(func(string, string) string); ok {
		r0 = rf(account, message)
	} else {
		r0 = ret.Get(0).(string)
	}

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

	return r0, r1
}

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

// SignUserMessage is a helper method to define mock.On call
//   - account string
//   - message string
func (_e *OverflowClient_Expecter) SignUserMessage(account interface{}, message interface{}) *OverflowClient_SignUserMessage_Call {
	return &OverflowClient_SignUserMessage_Call{Call: _e.mock.On("SignUserMessage", account, message)}
}

func (_c *OverflowClient_SignUserMessage_Call) Run(run func(account string, message string)) *OverflowClient_SignUserMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

func (_c *OverflowClient_SignUserMessage_Call) Return(_a0 string, _a1 error) *OverflowClient_SignUserMessage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *OverflowClient_SignUserMessage_Call) RunAndReturn(run func(string, string) (string, error)) *OverflowClient_SignUserMessage_Call {
	_c.Call.Return(run)
	return _c
}

// Tx provides a mock function with given fields: filename, opts
func (_m *OverflowClient) Tx(filename string, opts ...overflow.OverflowInteractionOption) *overflow.OverflowResult {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, filename)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *overflow.OverflowResult
	if rf, ok := ret.Get(0).(func(string, ...overflow.OverflowInteractionOption) *overflow.OverflowResult); ok {
		r0 = rf(filename, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*overflow.OverflowResult)
		}
	}

	return r0
}

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

// Tx is a helper method to define mock.On call
//   - filename string
//   - opts ...overflow.OverflowInteractionOption
func (_e *OverflowClient_Expecter) Tx(filename interface{}, opts ...interface{}) *OverflowClient_Tx_Call {
	return &OverflowClient_Tx_Call{Call: _e.mock.On("Tx",
		append([]interface{}{filename}, opts...)...)}
}

func (_c *OverflowClient_Tx_Call) Run(run func(filename string, opts ...overflow.OverflowInteractionOption)) *OverflowClient_Tx_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(overflow.OverflowInteractionOption)
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *OverflowClient_Tx_Call) Return(_a0 *overflow.OverflowResult) *OverflowClient_Tx_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_Tx_Call) RunAndReturn(run func(string, ...overflow.OverflowInteractionOption) *overflow.OverflowResult) *OverflowClient_Tx_Call {
	_c.Call.Return(run)
	return _c
}

// TxFN provides a mock function with given fields: outerOpts
func (_m *OverflowClient) TxFN(outerOpts ...overflow.OverflowInteractionOption) overflow.OverflowTransactionFunction {
	_va := make([]interface{}, len(outerOpts))
	for _i := range outerOpts {
		_va[_i] = outerOpts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 overflow.OverflowTransactionFunction
	if rf, ok := ret.Get(0).(func(...overflow.OverflowInteractionOption) overflow.OverflowTransactionFunction); ok {
		r0 = rf(outerOpts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(overflow.OverflowTransactionFunction)
		}
	}

	return r0
}

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

// TxFN is a helper method to define mock.On call
//   - outerOpts ...overflow.OverflowInteractionOption
func (_e *OverflowClient_Expecter) TxFN(outerOpts ...interface{}) *OverflowClient_TxFN_Call {
	return &OverflowClient_TxFN_Call{Call: _e.mock.On("TxFN",
		append([]interface{}{}, outerOpts...)...)}
}

func (_c *OverflowClient_TxFN_Call) Run(run func(outerOpts ...overflow.OverflowInteractionOption)) *OverflowClient_TxFN_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-0)
		for i, a := range args[0:] {
			if a != nil {
				variadicArgs[i] = a.(overflow.OverflowInteractionOption)
			}
		}
		run(variadicArgs...)
	})
	return _c
}

func (_c *OverflowClient_TxFN_Call) Return(_a0 overflow.OverflowTransactionFunction) *OverflowClient_TxFN_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_TxFN_Call) RunAndReturn(run func(...overflow.OverflowInteractionOption) overflow.OverflowTransactionFunction) *OverflowClient_TxFN_Call {
	_c.Call.Return(run)
	return _c
}

// TxFileNameFN provides a mock function with given fields: filename, outerOpts
func (_m *OverflowClient) TxFileNameFN(filename string, outerOpts ...overflow.OverflowInteractionOption) overflow.OverflowTransactionOptsFunction {
	_va := make([]interface{}, len(outerOpts))
	for _i := range outerOpts {
		_va[_i] = outerOpts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, filename)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 overflow.OverflowTransactionOptsFunction
	if rf, ok := ret.Get(0).(func(string, ...overflow.OverflowInteractionOption) overflow.OverflowTransactionOptsFunction); ok {
		r0 = rf(filename, outerOpts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(overflow.OverflowTransactionOptsFunction)
		}
	}

	return r0
}

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

// TxFileNameFN is a helper method to define mock.On call
//   - filename string
//   - outerOpts ...overflow.OverflowInteractionOption
func (_e *OverflowClient_Expecter) TxFileNameFN(filename interface{}, outerOpts ...interface{}) *OverflowClient_TxFileNameFN_Call {
	return &OverflowClient_TxFileNameFN_Call{Call: _e.mock.On("TxFileNameFN",
		append([]interface{}{filename}, outerOpts...)...)}
}

func (_c *OverflowClient_TxFileNameFN_Call) Run(run func(filename string, outerOpts ...overflow.OverflowInteractionOption)) *OverflowClient_TxFileNameFN_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]overflow.OverflowInteractionOption, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(overflow.OverflowInteractionOption)
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *OverflowClient_TxFileNameFN_Call) Return(_a0 overflow.OverflowTransactionOptsFunction) *OverflowClient_TxFileNameFN_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OverflowClient_TxFileNameFN_Call) RunAndReturn(run func(string, ...overflow.OverflowInteractionOption) overflow.OverflowTransactionOptsFunction) *OverflowClient_TxFileNameFN_Call {
	_c.Call.Return(run)
	return _c
}

// UploadFile provides a mock function with given fields: filename, accountName
func (_m *OverflowClient) UploadFile(filename string, accountName string) error {
	ret := _m.Called(filename, accountName)

	var r0 error
	if rf, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = rf(filename, accountName)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UploadFile is a helper method to define mock.On call
//   - filename string
//   - accountName string
func (_e *OverflowClient_Expecter) UploadFile(filename interface{}, accountName interface{}) *OverflowClient_UploadFile_Call {
	return &OverflowClient_UploadFile_Call{Call: _e.mock.On("UploadFile", filename, accountName)}
}

func (_c *OverflowClient_UploadFile_Call) Run(run func(filename string, accountName string)) *OverflowClient_UploadFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

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

func (_c *OverflowClient_UploadFile_Call) RunAndReturn(run func(string, string) error) *OverflowClient_UploadFile_Call {
	_c.Call.Return(run)
	return _c
}

// UploadImageAsDataUrl provides a mock function with given fields: filename, accountName
func (_m *OverflowClient) UploadImageAsDataUrl(filename string, accountName string) error {
	ret := _m.Called(filename, accountName)

	var r0 error
	if rf, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = rf(filename, accountName)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UploadImageAsDataUrl is a helper method to define mock.On call
//   - filename string
//   - accountName string
func (_e *OverflowClient_Expecter) UploadImageAsDataUrl(filename interface{}, accountName interface{}) *OverflowClient_UploadImageAsDataUrl_Call {
	return &OverflowClient_UploadImageAsDataUrl_Call{Call: _e.mock.On("UploadImageAsDataUrl", filename, accountName)}
}

func (_c *OverflowClient_UploadImageAsDataUrl_Call) Run(run func(filename string, accountName string)) *OverflowClient_UploadImageAsDataUrl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

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

func (_c *OverflowClient_UploadImageAsDataUrl_Call) RunAndReturn(run func(string, string) error) *OverflowClient_UploadImageAsDataUrl_Call {
	_c.Call.Return(run)
	return _c
}

// UploadString provides a mock function with given fields: content, accountName
func (_m *OverflowClient) UploadString(content string, accountName string) error {
	ret := _m.Called(content, accountName)

	var r0 error
	if rf, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = rf(content, accountName)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UploadString is a helper method to define mock.On call
//   - content string
//   - accountName string
func (_e *OverflowClient_Expecter) UploadString(content interface{}, accountName interface{}) *OverflowClient_UploadString_Call {
	return &OverflowClient_UploadString_Call{Call: _e.mock.On("UploadString", content, accountName)}
}

func (_c *OverflowClient_UploadString_Call) Run(run func(content string, accountName string)) *OverflowClient_UploadString_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

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

func (_c *OverflowClient_UploadString_Call) RunAndReturn(run func(string, string) error) *OverflowClient_UploadString_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}