query-orchestration/mocks/queryapi/mock_ClientInterface.go

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

package queryapimock

import (
	context "context"
	http "net/http"

	io "io"

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

	queryapi "queryorchestration/pkg/queryAPI"

	types "github.com/oapi-codegen/runtime/types"
)

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

type MockClientInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockClientInterface) EXPECT() *MockClientInterface_Expecter {
	return &MockClientInterface_Expecter{mock: &_m.Mock}
}

// ApplyLabel provides a mock function with given fields: ctx, documentId, body, reqEditors
func (_m *MockClientInterface) ApplyLabel(ctx context.Context, documentId types.UUID, body queryapi.ApplyLabelJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, documentId, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, queryapi.ApplyLabelJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, documentId, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, queryapi.ApplyLabelJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, documentId, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.UUID, queryapi.ApplyLabelJSONRequestBody, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, documentId, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ApplyLabel is a helper method to define mock.On call
//   - ctx context.Context
//   - documentId types.UUID
//   - body queryapi.ApplyLabelJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) ApplyLabel(ctx interface{}, documentId interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_ApplyLabel_Call {
	return &MockClientInterface_ApplyLabel_Call{Call: _e.mock.On("ApplyLabel",
		append([]interface{}{ctx, documentId, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_ApplyLabel_Call) Run(run func(ctx context.Context, documentId types.UUID, body queryapi.ApplyLabelJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_ApplyLabel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(types.UUID), args[2].(queryapi.ApplyLabelJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_ApplyLabel_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_ApplyLabel_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_ApplyLabel_Call) RunAndReturn(run func(context.Context, types.UUID, queryapi.ApplyLabelJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_ApplyLabel_Call {
	_c.Call.Return(run)
	return _c
}

// ApplyLabelWithBody provides a mock function with given fields: ctx, documentId, contentType, body, reqEditors
func (_m *MockClientInterface) ApplyLabelWithBody(ctx context.Context, documentId types.UUID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, documentId, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, documentId, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, documentId, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.UUID, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, documentId, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ApplyLabelWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - documentId types.UUID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) ApplyLabelWithBody(ctx interface{}, documentId interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_ApplyLabelWithBody_Call {
	return &MockClientInterface_ApplyLabelWithBody_Call{Call: _e.mock.On("ApplyLabelWithBody",
		append([]interface{}{ctx, documentId, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_ApplyLabelWithBody_Call) Run(run func(ctx context.Context, documentId types.UUID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_ApplyLabelWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(types.UUID), args[2].(string), args[3].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_ApplyLabelWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_ApplyLabelWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_ApplyLabelWithBody_Call) RunAndReturn(run func(context.Context, types.UUID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_ApplyLabelWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// CancelDocumentBatch provides a mock function with given fields: ctx, id, batchId, reqEditors
func (_m *MockClientInterface) CancelDocumentBatch(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, batchId)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, batchId, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, batchId, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, batchId, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CancelDocumentBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - batchId queryapi.BatchID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CancelDocumentBatch(ctx interface{}, id interface{}, batchId interface{}, reqEditors ...interface{}) *MockClientInterface_CancelDocumentBatch_Call {
	return &MockClientInterface_CancelDocumentBatch_Call{Call: _e.mock.On("CancelDocumentBatch",
		append([]interface{}{ctx, id, batchId}, reqEditors...)...)}
}

func (_c *MockClientInterface_CancelDocumentBatch_Call) Run(run func(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CancelDocumentBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(queryapi.BatchID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CancelDocumentBatch_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CancelDocumentBatch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CancelDocumentBatch_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CancelDocumentBatch_Call {
	_c.Call.Return(run)
	return _c
}

// CheckAdminUserExists provides a mock function with given fields: ctx, email, reqEditors
func (_m *MockClientInterface) CheckAdminUserExists(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, email)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, email, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, email, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// CheckAdminUserExists is a helper method to define mock.On call
//   - ctx context.Context
//   - email queryapi.UserEmail
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CheckAdminUserExists(ctx interface{}, email interface{}, reqEditors ...interface{}) *MockClientInterface_CheckAdminUserExists_Call {
	return &MockClientInterface_CheckAdminUserExists_Call{Call: _e.mock.On("CheckAdminUserExists",
		append([]interface{}{ctx, email}, reqEditors...)...)}
}

func (_c *MockClientInterface_CheckAdminUserExists_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CheckAdminUserExists_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.UserEmail), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CheckAdminUserExists_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CheckAdminUserExists_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CheckAdminUserExists_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CheckAdminUserExists_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAdminUser provides a mock function with given fields: ctx, body, reqEditors
func (_m *MockClientInterface) CreateAdminUser(ctx context.Context, body queryapi.CreateAdminUserJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// CreateAdminUser is a helper method to define mock.On call
//   - ctx context.Context
//   - body queryapi.CreateAdminUserJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CreateAdminUser(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_CreateAdminUser_Call {
	return &MockClientInterface_CreateAdminUser_Call{Call: _e.mock.On("CreateAdminUser",
		append([]interface{}{ctx, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_CreateAdminUser_Call) Run(run func(ctx context.Context, body queryapi.CreateAdminUserJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CreateAdminUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.CreateAdminUserJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CreateAdminUser_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CreateAdminUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CreateAdminUser_Call) RunAndReturn(run func(context.Context, queryapi.CreateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CreateAdminUser_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAdminUserWithBody provides a mock function with given fields: ctx, contentType, body, reqEditors
func (_m *MockClientInterface) CreateAdminUserWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateAdminUserWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CreateAdminUserWithBody(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_CreateAdminUserWithBody_Call {
	return &MockClientInterface_CreateAdminUserWithBody_Call{Call: _e.mock.On("CreateAdminUserWithBody",
		append([]interface{}{ctx, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_CreateAdminUserWithBody_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CreateAdminUserWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CreateAdminUserWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CreateAdminUserWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CreateAdminUserWithBody_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CreateAdminUserWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClient provides a mock function with given fields: ctx, body, reqEditors
func (_m *MockClientInterface) CreateClient(ctx context.Context, body queryapi.CreateClientJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateClientJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateClientJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// CreateClient is a helper method to define mock.On call
//   - ctx context.Context
//   - body queryapi.CreateClientJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CreateClient(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_CreateClient_Call {
	return &MockClientInterface_CreateClient_Call{Call: _e.mock.On("CreateClient",
		append([]interface{}{ctx, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_CreateClient_Call) Run(run func(ctx context.Context, body queryapi.CreateClientJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CreateClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.CreateClientJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CreateClient_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CreateClient_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CreateClient_Call) RunAndReturn(run func(context.Context, queryapi.CreateClientJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CreateClient_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClientWithBody provides a mock function with given fields: ctx, contentType, body, reqEditors
func (_m *MockClientInterface) CreateClientWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateClientWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CreateClientWithBody(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_CreateClientWithBody_Call {
	return &MockClientInterface_CreateClientWithBody_Call{Call: _e.mock.On("CreateClientWithBody",
		append([]interface{}{ctx, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_CreateClientWithBody_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CreateClientWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CreateClientWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CreateClientWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CreateClientWithBody_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CreateClientWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFieldExtraction provides a mock function with given fields: ctx, body, reqEditors
func (_m *MockClientInterface) CreateFieldExtraction(ctx context.Context, body queryapi.CreateFieldExtractionJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateFieldExtractionJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateFieldExtractionJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// CreateFieldExtraction is a helper method to define mock.On call
//   - ctx context.Context
//   - body queryapi.CreateFieldExtractionJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CreateFieldExtraction(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_CreateFieldExtraction_Call {
	return &MockClientInterface_CreateFieldExtraction_Call{Call: _e.mock.On("CreateFieldExtraction",
		append([]interface{}{ctx, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_CreateFieldExtraction_Call) Run(run func(ctx context.Context, body queryapi.CreateFieldExtractionJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CreateFieldExtraction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.CreateFieldExtractionJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CreateFieldExtraction_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CreateFieldExtraction_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CreateFieldExtraction_Call) RunAndReturn(run func(context.Context, queryapi.CreateFieldExtractionJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CreateFieldExtraction_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFieldExtractionWithBody provides a mock function with given fields: ctx, contentType, body, reqEditors
func (_m *MockClientInterface) CreateFieldExtractionWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateFieldExtractionWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CreateFieldExtractionWithBody(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_CreateFieldExtractionWithBody_Call {
	return &MockClientInterface_CreateFieldExtractionWithBody_Call{Call: _e.mock.On("CreateFieldExtractionWithBody",
		append([]interface{}{ctx, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_CreateFieldExtractionWithBody_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CreateFieldExtractionWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CreateFieldExtractionWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CreateFieldExtractionWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CreateFieldExtractionWithBody_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CreateFieldExtractionWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFolder provides a mock function with given fields: ctx, body, reqEditors
func (_m *MockClientInterface) CreateFolder(ctx context.Context, body queryapi.CreateFolderJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateFolderJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateFolderJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// CreateFolder is a helper method to define mock.On call
//   - ctx context.Context
//   - body queryapi.CreateFolderJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CreateFolder(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_CreateFolder_Call {
	return &MockClientInterface_CreateFolder_Call{Call: _e.mock.On("CreateFolder",
		append([]interface{}{ctx, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_CreateFolder_Call) Run(run func(ctx context.Context, body queryapi.CreateFolderJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CreateFolder_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.CreateFolderJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CreateFolder_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CreateFolder_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CreateFolder_Call) RunAndReturn(run func(context.Context, queryapi.CreateFolderJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CreateFolder_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFolderWithBody provides a mock function with given fields: ctx, contentType, body, reqEditors
func (_m *MockClientInterface) CreateFolderWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateFolderWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CreateFolderWithBody(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_CreateFolderWithBody_Call {
	return &MockClientInterface_CreateFolderWithBody_Call{Call: _e.mock.On("CreateFolderWithBody",
		append([]interface{}{ctx, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_CreateFolderWithBody_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CreateFolderWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CreateFolderWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CreateFolderWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CreateFolderWithBody_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CreateFolderWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// CreateQuery provides a mock function with given fields: ctx, body, reqEditors
func (_m *MockClientInterface) CreateQuery(ctx context.Context, body queryapi.CreateQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateQueryJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateQueryJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// CreateQuery is a helper method to define mock.On call
//   - ctx context.Context
//   - body queryapi.CreateQueryJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CreateQuery(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_CreateQuery_Call {
	return &MockClientInterface_CreateQuery_Call{Call: _e.mock.On("CreateQuery",
		append([]interface{}{ctx, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_CreateQuery_Call) Run(run func(ctx context.Context, body queryapi.CreateQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CreateQuery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.CreateQueryJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CreateQuery_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CreateQuery_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CreateQuery_Call) RunAndReturn(run func(context.Context, queryapi.CreateQueryJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CreateQuery_Call {
	_c.Call.Return(run)
	return _c
}

// CreateQueryWithBody provides a mock function with given fields: ctx, contentType, body, reqEditors
func (_m *MockClientInterface) CreateQueryWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateQueryWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CreateQueryWithBody(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_CreateQueryWithBody_Call {
	return &MockClientInterface_CreateQueryWithBody_Call{Call: _e.mock.On("CreateQueryWithBody",
		append([]interface{}{ctx, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_CreateQueryWithBody_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CreateQueryWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_CreateQueryWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CreateQueryWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_CreateQueryWithBody_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CreateQueryWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAdminUser provides a mock function with given fields: ctx, email, params, reqEditors
func (_m *MockClientInterface) DeleteAdminUser(ctx context.Context, email queryapi.UserEmail, params *queryapi.DeleteAdminUserParams, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, email, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, *queryapi.DeleteAdminUserParams, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, email, params, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, *queryapi.DeleteAdminUserParams, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, email, params, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.UserEmail, *queryapi.DeleteAdminUserParams, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, email, params, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteAdminUser is a helper method to define mock.On call
//   - ctx context.Context
//   - email queryapi.UserEmail
//   - params *queryapi.DeleteAdminUserParams
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) DeleteAdminUser(ctx interface{}, email interface{}, params interface{}, reqEditors ...interface{}) *MockClientInterface_DeleteAdminUser_Call {
	return &MockClientInterface_DeleteAdminUser_Call{Call: _e.mock.On("DeleteAdminUser",
		append([]interface{}{ctx, email, params}, reqEditors...)...)}
}

func (_c *MockClientInterface_DeleteAdminUser_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, params *queryapi.DeleteAdminUserParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_DeleteAdminUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.UserEmail), args[2].(*queryapi.DeleteAdminUserParams), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_DeleteAdminUser_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_DeleteAdminUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_DeleteAdminUser_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, *queryapi.DeleteAdminUserParams, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_DeleteAdminUser_Call {
	_c.Call.Return(run)
	return _c
}

// DisableAdminUser provides a mock function with given fields: ctx, email, reqEditors
func (_m *MockClientInterface) DisableAdminUser(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, email)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, email, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, email, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// DisableAdminUser is a helper method to define mock.On call
//   - ctx context.Context
//   - email queryapi.UserEmail
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) DisableAdminUser(ctx interface{}, email interface{}, reqEditors ...interface{}) *MockClientInterface_DisableAdminUser_Call {
	return &MockClientInterface_DisableAdminUser_Call{Call: _e.mock.On("DisableAdminUser",
		append([]interface{}{ctx, email}, reqEditors...)...)}
}

func (_c *MockClientInterface_DisableAdminUser_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_DisableAdminUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.UserEmail), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_DisableAdminUser_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_DisableAdminUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_DisableAdminUser_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_DisableAdminUser_Call {
	_c.Call.Return(run)
	return _c
}

// EnableAdminUser provides a mock function with given fields: ctx, email, reqEditors
func (_m *MockClientInterface) EnableAdminUser(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, email)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, email, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, email, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// EnableAdminUser is a helper method to define mock.On call
//   - ctx context.Context
//   - email queryapi.UserEmail
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) EnableAdminUser(ctx interface{}, email interface{}, reqEditors ...interface{}) *MockClientInterface_EnableAdminUser_Call {
	return &MockClientInterface_EnableAdminUser_Call{Call: _e.mock.On("EnableAdminUser",
		append([]interface{}{ctx, email}, reqEditors...)...)}
}

func (_c *MockClientInterface_EnableAdminUser_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_EnableAdminUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.UserEmail), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_EnableAdminUser_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_EnableAdminUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_EnableAdminUser_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_EnableAdminUser_Call {
	_c.Call.Return(run)
	return _c
}

// ExportState provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientInterface) ExportState(ctx context.Context, id queryapi.ExportID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ExportID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ExportID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// ExportState is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ExportID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) ExportState(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientInterface_ExportState_Call {
	return &MockClientInterface_ExportState_Call{Call: _e.mock.On("ExportState",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

func (_c *MockClientInterface_ExportState_Call) Run(run func(ctx context.Context, id queryapi.ExportID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_ExportState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ExportID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_ExportState_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_ExportState_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_ExportState_Call) RunAndReturn(run func(context.Context, queryapi.ExportID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_ExportState_Call {
	_c.Call.Return(run)
	return _c
}

// GetAdminUser provides a mock function with given fields: ctx, email, reqEditors
func (_m *MockClientInterface) GetAdminUser(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, email)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, email, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, email, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// GetAdminUser is a helper method to define mock.On call
//   - ctx context.Context
//   - email queryapi.UserEmail
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetAdminUser(ctx interface{}, email interface{}, reqEditors ...interface{}) *MockClientInterface_GetAdminUser_Call {
	return &MockClientInterface_GetAdminUser_Call{Call: _e.mock.On("GetAdminUser",
		append([]interface{}{ctx, email}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetAdminUser_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetAdminUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.UserEmail), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetAdminUser_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetAdminUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetAdminUser_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetAdminUser_Call {
	_c.Call.Return(run)
	return _c
}

// GetClient provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientInterface) GetClient(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// GetClient is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetClient(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientInterface_GetClient_Call {
	return &MockClientInterface_GetClient_Call{Call: _e.mock.On("GetClient",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetClient_Call) Run(run func(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetClient_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetClient_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetClient_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetClient_Call {
	_c.Call.Return(run)
	return _c
}

// GetCollectorByClientId provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientInterface) GetCollectorByClientId(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// GetCollectorByClientId is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetCollectorByClientId(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientInterface_GetCollectorByClientId_Call {
	return &MockClientInterface_GetCollectorByClientId_Call{Call: _e.mock.On("GetCollectorByClientId",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetCollectorByClientId_Call) Run(run func(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetCollectorByClientId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetCollectorByClientId_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetCollectorByClientId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetCollectorByClientId_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetCollectorByClientId_Call {
	_c.Call.Return(run)
	return _c
}

// GetCurrentFieldExtraction provides a mock function with given fields: ctx, params, reqEditors
func (_m *MockClientInterface) GetCurrentFieldExtraction(ctx context.Context, params *queryapi.GetCurrentFieldExtractionParams, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *queryapi.GetCurrentFieldExtractionParams, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, params, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *queryapi.GetCurrentFieldExtractionParams, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, params, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *queryapi.GetCurrentFieldExtractionParams, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, params, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetCurrentFieldExtraction is a helper method to define mock.On call
//   - ctx context.Context
//   - params *queryapi.GetCurrentFieldExtractionParams
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetCurrentFieldExtraction(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClientInterface_GetCurrentFieldExtraction_Call {
	return &MockClientInterface_GetCurrentFieldExtraction_Call{Call: _e.mock.On("GetCurrentFieldExtraction",
		append([]interface{}{ctx, params}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetCurrentFieldExtraction_Call) Run(run func(ctx context.Context, params *queryapi.GetCurrentFieldExtractionParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetCurrentFieldExtraction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(*queryapi.GetCurrentFieldExtractionParams), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetCurrentFieldExtraction_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetCurrentFieldExtraction_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetCurrentFieldExtraction_Call) RunAndReturn(run func(context.Context, *queryapi.GetCurrentFieldExtractionParams, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetCurrentFieldExtraction_Call {
	_c.Call.Return(run)
	return _c
}

// GetDocument provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientInterface) GetDocument(ctx context.Context, id queryapi.DocumentID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.DocumentID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.DocumentID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// GetDocument is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.DocumentID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetDocument(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientInterface_GetDocument_Call {
	return &MockClientInterface_GetDocument_Call{Call: _e.mock.On("GetDocument",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetDocument_Call) Run(run func(ctx context.Context, id queryapi.DocumentID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetDocument_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.DocumentID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetDocument_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetDocument_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetDocument_Call) RunAndReturn(run func(context.Context, queryapi.DocumentID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetDocument_Call {
	_c.Call.Return(run)
	return _c
}

// GetDocumentBatch provides a mock function with given fields: ctx, id, batchId, reqEditors
func (_m *MockClientInterface) GetDocumentBatch(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, batchId)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, batchId, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, batchId, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, batchId, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetDocumentBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - batchId queryapi.BatchID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetDocumentBatch(ctx interface{}, id interface{}, batchId interface{}, reqEditors ...interface{}) *MockClientInterface_GetDocumentBatch_Call {
	return &MockClientInterface_GetDocumentBatch_Call{Call: _e.mock.On("GetDocumentBatch",
		append([]interface{}{ctx, id, batchId}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetDocumentBatch_Call) Run(run func(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetDocumentBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(queryapi.BatchID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetDocumentBatch_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetDocumentBatch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetDocumentBatch_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetDocumentBatch_Call {
	_c.Call.Return(run)
	return _c
}

// GetDocumentLabels provides a mock function with given fields: ctx, documentId, reqEditors
func (_m *MockClientInterface) GetDocumentLabels(ctx context.Context, documentId types.UUID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, documentId)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, documentId, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, documentId, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.UUID, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, documentId, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetDocumentLabels is a helper method to define mock.On call
//   - ctx context.Context
//   - documentId types.UUID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetDocumentLabels(ctx interface{}, documentId interface{}, reqEditors ...interface{}) *MockClientInterface_GetDocumentLabels_Call {
	return &MockClientInterface_GetDocumentLabels_Call{Call: _e.mock.On("GetDocumentLabels",
		append([]interface{}{ctx, documentId}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetDocumentLabels_Call) Run(run func(ctx context.Context, documentId types.UUID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetDocumentLabels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(types.UUID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetDocumentLabels_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetDocumentLabels_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetDocumentLabels_Call) RunAndReturn(run func(context.Context, types.UUID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetDocumentLabels_Call {
	_c.Call.Return(run)
	return _c
}

// GetDocumentsByLabel provides a mock function with given fields: ctx, labelName, params, reqEditors
func (_m *MockClientInterface) GetDocumentsByLabel(ctx context.Context, labelName string, params *queryapi.GetDocumentsByLabelParams, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, labelName, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *queryapi.GetDocumentsByLabelParams, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, labelName, params, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, *queryapi.GetDocumentsByLabelParams, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, labelName, params, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, *queryapi.GetDocumentsByLabelParams, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, labelName, params, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetDocumentsByLabel is a helper method to define mock.On call
//   - ctx context.Context
//   - labelName string
//   - params *queryapi.GetDocumentsByLabelParams
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetDocumentsByLabel(ctx interface{}, labelName interface{}, params interface{}, reqEditors ...interface{}) *MockClientInterface_GetDocumentsByLabel_Call {
	return &MockClientInterface_GetDocumentsByLabel_Call{Call: _e.mock.On("GetDocumentsByLabel",
		append([]interface{}{ctx, labelName, params}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetDocumentsByLabel_Call) Run(run func(ctx context.Context, labelName string, params *queryapi.GetDocumentsByLabelParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetDocumentsByLabel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(*queryapi.GetDocumentsByLabelParams), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetDocumentsByLabel_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetDocumentsByLabel_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetDocumentsByLabel_Call) RunAndReturn(run func(context.Context, string, *queryapi.GetDocumentsByLabelParams, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetDocumentsByLabel_Call {
	_c.Call.Return(run)
	return _c
}

// GetFieldExtractionByVersion provides a mock function with given fields: ctx, params, reqEditors
func (_m *MockClientInterface) GetFieldExtractionByVersion(ctx context.Context, params *queryapi.GetFieldExtractionByVersionParams, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *queryapi.GetFieldExtractionByVersionParams, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, params, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *queryapi.GetFieldExtractionByVersionParams, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, params, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *queryapi.GetFieldExtractionByVersionParams, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, params, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetFieldExtractionByVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - params *queryapi.GetFieldExtractionByVersionParams
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetFieldExtractionByVersion(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClientInterface_GetFieldExtractionByVersion_Call {
	return &MockClientInterface_GetFieldExtractionByVersion_Call{Call: _e.mock.On("GetFieldExtractionByVersion",
		append([]interface{}{ctx, params}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetFieldExtractionByVersion_Call) Run(run func(ctx context.Context, params *queryapi.GetFieldExtractionByVersionParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetFieldExtractionByVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(*queryapi.GetFieldExtractionByVersionParams), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetFieldExtractionByVersion_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetFieldExtractionByVersion_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetFieldExtractionByVersion_Call) RunAndReturn(run func(context.Context, *queryapi.GetFieldExtractionByVersionParams, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetFieldExtractionByVersion_Call {
	_c.Call.Return(run)
	return _c
}

// GetFieldExtractionHistory provides a mock function with given fields: ctx, params, reqEditors
func (_m *MockClientInterface) GetFieldExtractionHistory(ctx context.Context, params *queryapi.GetFieldExtractionHistoryParams, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *queryapi.GetFieldExtractionHistoryParams, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, params, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *queryapi.GetFieldExtractionHistoryParams, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, params, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *queryapi.GetFieldExtractionHistoryParams, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, params, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetFieldExtractionHistory is a helper method to define mock.On call
//   - ctx context.Context
//   - params *queryapi.GetFieldExtractionHistoryParams
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetFieldExtractionHistory(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClientInterface_GetFieldExtractionHistory_Call {
	return &MockClientInterface_GetFieldExtractionHistory_Call{Call: _e.mock.On("GetFieldExtractionHistory",
		append([]interface{}{ctx, params}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetFieldExtractionHistory_Call) Run(run func(ctx context.Context, params *queryapi.GetFieldExtractionHistoryParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetFieldExtractionHistory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(*queryapi.GetFieldExtractionHistoryParams), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetFieldExtractionHistory_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetFieldExtractionHistory_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetFieldExtractionHistory_Call) RunAndReturn(run func(context.Context, *queryapi.GetFieldExtractionHistoryParams, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetFieldExtractionHistory_Call {
	_c.Call.Return(run)
	return _c
}

// GetFolderDocuments provides a mock function with given fields: ctx, folderId, reqEditors
func (_m *MockClientInterface) GetFolderDocuments(ctx context.Context, folderId types.UUID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, folderId)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, folderId, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, folderId, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.UUID, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, folderId, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetFolderDocuments is a helper method to define mock.On call
//   - ctx context.Context
//   - folderId types.UUID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetFolderDocuments(ctx interface{}, folderId interface{}, reqEditors ...interface{}) *MockClientInterface_GetFolderDocuments_Call {
	return &MockClientInterface_GetFolderDocuments_Call{Call: _e.mock.On("GetFolderDocuments",
		append([]interface{}{ctx, folderId}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetFolderDocuments_Call) Run(run func(ctx context.Context, folderId types.UUID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetFolderDocuments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(types.UUID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetFolderDocuments_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetFolderDocuments_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetFolderDocuments_Call) RunAndReturn(run func(context.Context, types.UUID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetFolderDocuments_Call {
	_c.Call.Return(run)
	return _c
}

// GetFolderMetrics provides a mock function with given fields: ctx, folderId, reqEditors
func (_m *MockClientInterface) GetFolderMetrics(ctx context.Context, folderId types.UUID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, folderId)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, folderId, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, folderId, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.UUID, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, folderId, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetFolderMetrics is a helper method to define mock.On call
//   - ctx context.Context
//   - folderId types.UUID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetFolderMetrics(ctx interface{}, folderId interface{}, reqEditors ...interface{}) *MockClientInterface_GetFolderMetrics_Call {
	return &MockClientInterface_GetFolderMetrics_Call{Call: _e.mock.On("GetFolderMetrics",
		append([]interface{}{ctx, folderId}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetFolderMetrics_Call) Run(run func(ctx context.Context, folderId types.UUID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetFolderMetrics_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(types.UUID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetFolderMetrics_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetFolderMetrics_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetFolderMetrics_Call) RunAndReturn(run func(context.Context, types.UUID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetFolderMetrics_Call {
	_c.Call.Return(run)
	return _c
}

// GetHomePage provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientInterface) GetHomePage(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

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

	return r0, r1
}

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

// GetHomePage is a helper method to define mock.On call
//   - ctx context.Context
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetHomePage(ctx interface{}, reqEditors ...interface{}) *MockClientInterface_GetHomePage_Call {
	return &MockClientInterface_GetHomePage_Call{Call: _e.mock.On("GetHomePage",
		append([]interface{}{ctx}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetHomePage_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetHomePage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetHomePage_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetHomePage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetHomePage_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetHomePage_Call {
	_c.Call.Return(run)
	return _c
}

// GetQuery provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientInterface) GetQuery(ctx context.Context, id queryapi.QueryID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// GetQuery is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.QueryID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetQuery(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientInterface_GetQuery_Call {
	return &MockClientInterface_GetQuery_Call{Call: _e.mock.On("GetQuery",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetQuery_Call) Run(run func(ctx context.Context, id queryapi.QueryID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetQuery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.QueryID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetQuery_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetQuery_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetQuery_Call) RunAndReturn(run func(context.Context, queryapi.QueryID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetQuery_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatusByClientId provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientInterface) GetStatusByClientId(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// GetStatusByClientId is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetStatusByClientId(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientInterface_GetStatusByClientId_Call {
	return &MockClientInterface_GetStatusByClientId_Call{Call: _e.mock.On("GetStatusByClientId",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

func (_c *MockClientInterface_GetStatusByClientId_Call) Run(run func(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetStatusByClientId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_GetStatusByClientId_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetStatusByClientId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_GetStatusByClientId_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetStatusByClientId_Call {
	_c.Call.Return(run)
	return _c
}

// ListAdminUsers provides a mock function with given fields: ctx, params, reqEditors
func (_m *MockClientInterface) ListAdminUsers(ctx context.Context, params *queryapi.ListAdminUsersParams, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *queryapi.ListAdminUsersParams, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, params, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *queryapi.ListAdminUsersParams, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, params, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *queryapi.ListAdminUsersParams, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, params, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListAdminUsers is a helper method to define mock.On call
//   - ctx context.Context
//   - params *queryapi.ListAdminUsersParams
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) ListAdminUsers(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClientInterface_ListAdminUsers_Call {
	return &MockClientInterface_ListAdminUsers_Call{Call: _e.mock.On("ListAdminUsers",
		append([]interface{}{ctx, params}, reqEditors...)...)}
}

func (_c *MockClientInterface_ListAdminUsers_Call) Run(run func(ctx context.Context, params *queryapi.ListAdminUsersParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_ListAdminUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(*queryapi.ListAdminUsersParams), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_ListAdminUsers_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_ListAdminUsers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_ListAdminUsers_Call) RunAndReturn(run func(context.Context, *queryapi.ListAdminUsersParams, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_ListAdminUsers_Call {
	_c.Call.Return(run)
	return _c
}

// ListClientFolders provides a mock function with given fields: ctx, id, params, reqEditors
func (_m *MockClientInterface) ListClientFolders(ctx context.Context, id queryapi.ClientID, params *queryapi.ListClientFoldersParams, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, *queryapi.ListClientFoldersParams, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, params, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, *queryapi.ListClientFoldersParams, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, params, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, *queryapi.ListClientFoldersParams, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, params, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListClientFolders is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - params *queryapi.ListClientFoldersParams
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) ListClientFolders(ctx interface{}, id interface{}, params interface{}, reqEditors ...interface{}) *MockClientInterface_ListClientFolders_Call {
	return &MockClientInterface_ListClientFolders_Call{Call: _e.mock.On("ListClientFolders",
		append([]interface{}{ctx, id, params}, reqEditors...)...)}
}

func (_c *MockClientInterface_ListClientFolders_Call) Run(run func(ctx context.Context, id queryapi.ClientID, params *queryapi.ListClientFoldersParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_ListClientFolders_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(*queryapi.ListClientFoldersParams), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_ListClientFolders_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_ListClientFolders_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_ListClientFolders_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, *queryapi.ListClientFoldersParams, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_ListClientFolders_Call {
	_c.Call.Return(run)
	return _c
}

// ListClients provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientInterface) ListClients(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

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

	return r0, r1
}

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

// ListClients is a helper method to define mock.On call
//   - ctx context.Context
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) ListClients(ctx interface{}, reqEditors ...interface{}) *MockClientInterface_ListClients_Call {
	return &MockClientInterface_ListClients_Call{Call: _e.mock.On("ListClients",
		append([]interface{}{ctx}, reqEditors...)...)}
}

func (_c *MockClientInterface_ListClients_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_ListClients_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_ListClients_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_ListClients_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_ListClients_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_ListClients_Call {
	_c.Call.Return(run)
	return _c
}

// ListDocumentBatches provides a mock function with given fields: ctx, id, params, reqEditors
func (_m *MockClientInterface) ListDocumentBatches(ctx context.Context, id queryapi.ClientID, params *queryapi.ListDocumentBatchesParams, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, *queryapi.ListDocumentBatchesParams, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, params, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, *queryapi.ListDocumentBatchesParams, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, params, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, *queryapi.ListDocumentBatchesParams, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, params, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListDocumentBatches is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - params *queryapi.ListDocumentBatchesParams
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) ListDocumentBatches(ctx interface{}, id interface{}, params interface{}, reqEditors ...interface{}) *MockClientInterface_ListDocumentBatches_Call {
	return &MockClientInterface_ListDocumentBatches_Call{Call: _e.mock.On("ListDocumentBatches",
		append([]interface{}{ctx, id, params}, reqEditors...)...)}
}

func (_c *MockClientInterface_ListDocumentBatches_Call) Run(run func(ctx context.Context, id queryapi.ClientID, params *queryapi.ListDocumentBatchesParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_ListDocumentBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(*queryapi.ListDocumentBatchesParams), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_ListDocumentBatches_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_ListDocumentBatches_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_ListDocumentBatches_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, *queryapi.ListDocumentBatchesParams, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_ListDocumentBatches_Call {
	_c.Call.Return(run)
	return _c
}

// ListDocumentsByClientId provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientInterface) ListDocumentsByClientId(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

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

// ListDocumentsByClientId is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) ListDocumentsByClientId(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientInterface_ListDocumentsByClientId_Call {
	return &MockClientInterface_ListDocumentsByClientId_Call{Call: _e.mock.On("ListDocumentsByClientId",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

func (_c *MockClientInterface_ListDocumentsByClientId_Call) Run(run func(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_ListDocumentsByClientId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_ListDocumentsByClientId_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_ListDocumentsByClientId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_ListDocumentsByClientId_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_ListDocumentsByClientId_Call {
	_c.Call.Return(run)
	return _c
}

// ListQueries provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientInterface) ListQueries(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

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

	return r0, r1
}

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

// ListQueries is a helper method to define mock.On call
//   - ctx context.Context
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) ListQueries(ctx interface{}, reqEditors ...interface{}) *MockClientInterface_ListQueries_Call {
	return &MockClientInterface_ListQueries_Call{Call: _e.mock.On("ListQueries",
		append([]interface{}{ctx}, reqEditors...)...)}
}

func (_c *MockClientInterface_ListQueries_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_ListQueries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_ListQueries_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_ListQueries_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_ListQueries_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_ListQueries_Call {
	_c.Call.Return(run)
	return _c
}

// Login provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientInterface) Login(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

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

	return r0, r1
}

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

// Login is a helper method to define mock.On call
//   - ctx context.Context
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) Login(ctx interface{}, reqEditors ...interface{}) *MockClientInterface_Login_Call {
	return &MockClientInterface_Login_Call{Call: _e.mock.On("Login",
		append([]interface{}{ctx}, reqEditors...)...)}
}

func (_c *MockClientInterface_Login_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_Login_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_Login_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_Login_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_Login_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_Login_Call {
	_c.Call.Return(run)
	return _c
}

// LoginCallback provides a mock function with given fields: ctx, params, reqEditors
func (_m *MockClientInterface) LoginCallback(ctx context.Context, params *queryapi.LoginCallbackParams, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, params, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, params, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, params, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LoginCallback is a helper method to define mock.On call
//   - ctx context.Context
//   - params *queryapi.LoginCallbackParams
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) LoginCallback(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClientInterface_LoginCallback_Call {
	return &MockClientInterface_LoginCallback_Call{Call: _e.mock.On("LoginCallback",
		append([]interface{}{ctx, params}, reqEditors...)...)}
}

func (_c *MockClientInterface_LoginCallback_Call) Run(run func(ctx context.Context, params *queryapi.LoginCallbackParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_LoginCallback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(*queryapi.LoginCallbackParams), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_LoginCallback_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_LoginCallback_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_LoginCallback_Call) RunAndReturn(run func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_LoginCallback_Call {
	_c.Call.Return(run)
	return _c
}

// Logout provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientInterface) Logout(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

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

	return r0, r1
}

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

// Logout is a helper method to define mock.On call
//   - ctx context.Context
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) Logout(ctx interface{}, reqEditors ...interface{}) *MockClientInterface_Logout_Call {
	return &MockClientInterface_Logout_Call{Call: _e.mock.On("Logout",
		append([]interface{}{ctx}, reqEditors...)...)}
}

func (_c *MockClientInterface_Logout_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_Logout_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_Logout_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_Logout_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_Logout_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_Logout_Call {
	_c.Call.Return(run)
	return _c
}

// RenameFolder provides a mock function with given fields: ctx, folderId, body, reqEditors
func (_m *MockClientInterface) RenameFolder(ctx context.Context, folderId types.UUID, body queryapi.RenameFolderJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, folderId, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, queryapi.RenameFolderJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, folderId, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, queryapi.RenameFolderJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, folderId, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.UUID, queryapi.RenameFolderJSONRequestBody, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, folderId, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RenameFolder is a helper method to define mock.On call
//   - ctx context.Context
//   - folderId types.UUID
//   - body queryapi.RenameFolderJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) RenameFolder(ctx interface{}, folderId interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_RenameFolder_Call {
	return &MockClientInterface_RenameFolder_Call{Call: _e.mock.On("RenameFolder",
		append([]interface{}{ctx, folderId, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_RenameFolder_Call) Run(run func(ctx context.Context, folderId types.UUID, body queryapi.RenameFolderJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_RenameFolder_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(types.UUID), args[2].(queryapi.RenameFolderJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_RenameFolder_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_RenameFolder_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_RenameFolder_Call) RunAndReturn(run func(context.Context, types.UUID, queryapi.RenameFolderJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_RenameFolder_Call {
	_c.Call.Return(run)
	return _c
}

// RenameFolderWithBody provides a mock function with given fields: ctx, folderId, contentType, body, reqEditors
func (_m *MockClientInterface) RenameFolderWithBody(ctx context.Context, folderId types.UUID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, folderId, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, folderId, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, folderId, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.UUID, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, folderId, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RenameFolderWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - folderId types.UUID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) RenameFolderWithBody(ctx interface{}, folderId interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_RenameFolderWithBody_Call {
	return &MockClientInterface_RenameFolderWithBody_Call{Call: _e.mock.On("RenameFolderWithBody",
		append([]interface{}{ctx, folderId, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_RenameFolderWithBody_Call) Run(run func(ctx context.Context, folderId types.UUID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_RenameFolderWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(types.UUID), args[2].(string), args[3].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_RenameFolderWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_RenameFolderWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_RenameFolderWithBody_Call) RunAndReturn(run func(context.Context, types.UUID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_RenameFolderWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// SetCollectorByClientId provides a mock function with given fields: ctx, id, body, reqEditors
func (_m *MockClientInterface) SetCollectorByClientId(ctx context.Context, id queryapi.ClientID, body queryapi.SetCollectorByClientIdJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.SetCollectorByClientIdJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.SetCollectorByClientIdJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, queryapi.SetCollectorByClientIdJSONRequestBody, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SetCollectorByClientId is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - body queryapi.SetCollectorByClientIdJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) SetCollectorByClientId(ctx interface{}, id interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_SetCollectorByClientId_Call {
	return &MockClientInterface_SetCollectorByClientId_Call{Call: _e.mock.On("SetCollectorByClientId",
		append([]interface{}{ctx, id, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_SetCollectorByClientId_Call) Run(run func(ctx context.Context, id queryapi.ClientID, body queryapi.SetCollectorByClientIdJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_SetCollectorByClientId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(queryapi.SetCollectorByClientIdJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_SetCollectorByClientId_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_SetCollectorByClientId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_SetCollectorByClientId_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, queryapi.SetCollectorByClientIdJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_SetCollectorByClientId_Call {
	_c.Call.Return(run)
	return _c
}

// SetCollectorByClientIdWithBody provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientInterface) SetCollectorByClientIdWithBody(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SetCollectorByClientIdWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) SetCollectorByClientIdWithBody(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_SetCollectorByClientIdWithBody_Call {
	return &MockClientInterface_SetCollectorByClientIdWithBody_Call{Call: _e.mock.On("SetCollectorByClientIdWithBody",
		append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_SetCollectorByClientIdWithBody_Call) Run(run func(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_SetCollectorByClientIdWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(string), args[3].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_SetCollectorByClientIdWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_SetCollectorByClientIdWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_SetCollectorByClientIdWithBody_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_SetCollectorByClientIdWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// TestQuery provides a mock function with given fields: ctx, id, body, reqEditors
func (_m *MockClientInterface) TestQuery(ctx context.Context, id queryapi.QueryID, body queryapi.TestQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, queryapi.TestQueryJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, queryapi.TestQueryJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.QueryID, queryapi.TestQueryJSONRequestBody, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TestQuery is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.QueryID
//   - body queryapi.TestQueryJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) TestQuery(ctx interface{}, id interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_TestQuery_Call {
	return &MockClientInterface_TestQuery_Call{Call: _e.mock.On("TestQuery",
		append([]interface{}{ctx, id, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_TestQuery_Call) Run(run func(ctx context.Context, id queryapi.QueryID, body queryapi.TestQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_TestQuery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.QueryID), args[2].(queryapi.TestQueryJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_TestQuery_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_TestQuery_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_TestQuery_Call) RunAndReturn(run func(context.Context, queryapi.QueryID, queryapi.TestQueryJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_TestQuery_Call {
	_c.Call.Return(run)
	return _c
}

// TestQueryWithBody provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientInterface) TestQueryWithBody(ctx context.Context, id queryapi.QueryID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TestQueryWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.QueryID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) TestQueryWithBody(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_TestQueryWithBody_Call {
	return &MockClientInterface_TestQueryWithBody_Call{Call: _e.mock.On("TestQueryWithBody",
		append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_TestQueryWithBody_Call) Run(run func(ctx context.Context, id queryapi.QueryID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_TestQueryWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.QueryID), args[2].(string), args[3].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_TestQueryWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_TestQueryWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_TestQueryWithBody_Call) RunAndReturn(run func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_TestQueryWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// TriggerExport provides a mock function with given fields: ctx, id, body, reqEditors
func (_m *MockClientInterface) TriggerExport(ctx context.Context, id queryapi.ClientID, body queryapi.TriggerExportJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.TriggerExportJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.TriggerExportJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, queryapi.TriggerExportJSONRequestBody, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TriggerExport is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - body queryapi.TriggerExportJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) TriggerExport(ctx interface{}, id interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_TriggerExport_Call {
	return &MockClientInterface_TriggerExport_Call{Call: _e.mock.On("TriggerExport",
		append([]interface{}{ctx, id, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_TriggerExport_Call) Run(run func(ctx context.Context, id queryapi.ClientID, body queryapi.TriggerExportJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_TriggerExport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(queryapi.TriggerExportJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_TriggerExport_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_TriggerExport_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_TriggerExport_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, queryapi.TriggerExportJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_TriggerExport_Call {
	_c.Call.Return(run)
	return _c
}

// TriggerExportWithBody provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientInterface) TriggerExportWithBody(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TriggerExportWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) TriggerExportWithBody(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_TriggerExportWithBody_Call {
	return &MockClientInterface_TriggerExportWithBody_Call{Call: _e.mock.On("TriggerExportWithBody",
		append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_TriggerExportWithBody_Call) Run(run func(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_TriggerExportWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(string), args[3].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_TriggerExportWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_TriggerExportWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_TriggerExportWithBody_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_TriggerExportWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateAdminUser provides a mock function with given fields: ctx, email, body, reqEditors
func (_m *MockClientInterface) UpdateAdminUser(ctx context.Context, email queryapi.UserEmail, body queryapi.UpdateAdminUserJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, email, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, queryapi.UpdateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, email, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, queryapi.UpdateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, email, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.UserEmail, queryapi.UpdateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, email, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateAdminUser is a helper method to define mock.On call
//   - ctx context.Context
//   - email queryapi.UserEmail
//   - body queryapi.UpdateAdminUserJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) UpdateAdminUser(ctx interface{}, email interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_UpdateAdminUser_Call {
	return &MockClientInterface_UpdateAdminUser_Call{Call: _e.mock.On("UpdateAdminUser",
		append([]interface{}{ctx, email, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_UpdateAdminUser_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, body queryapi.UpdateAdminUserJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_UpdateAdminUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.UserEmail), args[2].(queryapi.UpdateAdminUserJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_UpdateAdminUser_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_UpdateAdminUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_UpdateAdminUser_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, queryapi.UpdateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_UpdateAdminUser_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateAdminUserWithBody provides a mock function with given fields: ctx, email, contentType, body, reqEditors
func (_m *MockClientInterface) UpdateAdminUserWithBody(ctx context.Context, email queryapi.UserEmail, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, email, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, email, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, email, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.UserEmail, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, email, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateAdminUserWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - email queryapi.UserEmail
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) UpdateAdminUserWithBody(ctx interface{}, email interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_UpdateAdminUserWithBody_Call {
	return &MockClientInterface_UpdateAdminUserWithBody_Call{Call: _e.mock.On("UpdateAdminUserWithBody",
		append([]interface{}{ctx, email, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_UpdateAdminUserWithBody_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_UpdateAdminUserWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.UserEmail), args[2].(string), args[3].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_UpdateAdminUserWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_UpdateAdminUserWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_UpdateAdminUserWithBody_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_UpdateAdminUserWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClient provides a mock function with given fields: ctx, id, body, reqEditors
func (_m *MockClientInterface) UpdateClient(ctx context.Context, id queryapi.ClientID, body queryapi.UpdateClientJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.UpdateClientJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.UpdateClientJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, queryapi.UpdateClientJSONRequestBody, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateClient is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - body queryapi.UpdateClientJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) UpdateClient(ctx interface{}, id interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_UpdateClient_Call {
	return &MockClientInterface_UpdateClient_Call{Call: _e.mock.On("UpdateClient",
		append([]interface{}{ctx, id, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_UpdateClient_Call) Run(run func(ctx context.Context, id queryapi.ClientID, body queryapi.UpdateClientJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_UpdateClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(queryapi.UpdateClientJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_UpdateClient_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_UpdateClient_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_UpdateClient_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, queryapi.UpdateClientJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_UpdateClient_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClientWithBody provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientInterface) UpdateClientWithBody(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateClientWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) UpdateClientWithBody(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_UpdateClientWithBody_Call {
	return &MockClientInterface_UpdateClientWithBody_Call{Call: _e.mock.On("UpdateClientWithBody",
		append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_UpdateClientWithBody_Call) Run(run func(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_UpdateClientWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(string), args[3].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_UpdateClientWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_UpdateClientWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_UpdateClientWithBody_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_UpdateClientWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateQuery provides a mock function with given fields: ctx, id, body, reqEditors
func (_m *MockClientInterface) UpdateQuery(ctx context.Context, id queryapi.QueryID, body queryapi.UpdateQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, queryapi.UpdateQueryJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, queryapi.UpdateQueryJSONRequestBody, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.QueryID, queryapi.UpdateQueryJSONRequestBody, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateQuery is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.QueryID
//   - body queryapi.UpdateQueryJSONRequestBody
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) UpdateQuery(ctx interface{}, id interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_UpdateQuery_Call {
	return &MockClientInterface_UpdateQuery_Call{Call: _e.mock.On("UpdateQuery",
		append([]interface{}{ctx, id, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_UpdateQuery_Call) Run(run func(ctx context.Context, id queryapi.QueryID, body queryapi.UpdateQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_UpdateQuery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
		for i, a := range args[3:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.QueryID), args[2].(queryapi.UpdateQueryJSONRequestBody), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_UpdateQuery_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_UpdateQuery_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_UpdateQuery_Call) RunAndReturn(run func(context.Context, queryapi.QueryID, queryapi.UpdateQueryJSONRequestBody, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_UpdateQuery_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateQueryWithBody provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientInterface) UpdateQueryWithBody(ctx context.Context, id queryapi.QueryID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateQueryWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.QueryID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) UpdateQueryWithBody(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_UpdateQueryWithBody_Call {
	return &MockClientInterface_UpdateQueryWithBody_Call{Call: _e.mock.On("UpdateQueryWithBody",
		append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_UpdateQueryWithBody_Call) Run(run func(ctx context.Context, id queryapi.QueryID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_UpdateQueryWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.QueryID), args[2].(string), args[3].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_UpdateQueryWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_UpdateQueryWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_UpdateQueryWithBody_Call) RunAndReturn(run func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_UpdateQueryWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// UploadDocumentBatchWithBody provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientInterface) UploadDocumentBatchWithBody(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UploadDocumentBatchWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) UploadDocumentBatchWithBody(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_UploadDocumentBatchWithBody_Call {
	return &MockClientInterface_UploadDocumentBatchWithBody_Call{Call: _e.mock.On("UploadDocumentBatchWithBody",
		append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_UploadDocumentBatchWithBody_Call) Run(run func(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_UploadDocumentBatchWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(string), args[3].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_UploadDocumentBatchWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_UploadDocumentBatchWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_UploadDocumentBatchWithBody_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_UploadDocumentBatchWithBody_Call {
	_c.Call.Return(run)
	return _c
}

// UploadDocumentWithBody provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientInterface) UploadDocumentWithBody(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
		return rf(ctx, id, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UploadDocumentWithBody is a helper method to define mock.On call
//   - ctx context.Context
//   - id queryapi.ClientID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) UploadDocumentWithBody(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_UploadDocumentWithBody_Call {
	return &MockClientInterface_UploadDocumentWithBody_Call{Call: _e.mock.On("UploadDocumentWithBody",
		append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientInterface_UploadDocumentWithBody_Call) Run(run func(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_UploadDocumentWithBody_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(queryapi.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(string), args[3].(io.Reader), variadicArgs...)
	})
	return _c
}

func (_c *MockClientInterface_UploadDocumentWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_UploadDocumentWithBody_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientInterface_UploadDocumentWithBody_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_UploadDocumentWithBody_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}