query-orchestration/mocks/queryservice/mock_ClientWithResponsesInterface.go

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

package queryservicemock

import (
	context "context"
	io "io"

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

	queryservice "queryorchestration/pkg/queryService"

	uuid "github.com/google/uuid"
)

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

type MockClientWithResponsesInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockClientWithResponsesInterface) EXPECT() *MockClientWithResponsesInterface_Expecter {
	return &MockClientWithResponsesInterface_Expecter{mock: &_m.Mock}
}

// CreateClientWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors
func (_m *MockClientWithResponsesInterface) CreateClientWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryservice.RequestEditorFn) (*queryservice.CreateClientResponse, 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 CreateClientWithBodyWithResponse")
	}

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

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

	return r0, r1
}

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

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

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

func (_c *MockClientWithResponsesInterface_CreateClientWithBodyWithResponse_Call) Return(_a0 *queryservice.CreateClientResponse, _a1 error) *MockClientWithResponsesInterface_CreateClientWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_CreateClientWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...queryservice.RequestEditorFn) (*queryservice.CreateClientResponse, error)) *MockClientWithResponsesInterface_CreateClientWithBodyWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClientWithResponse provides a mock function with given fields: ctx, body, reqEditors
func (_m *MockClientWithResponsesInterface) CreateClientWithResponse(ctx context.Context, body queryservice.ClientCreate, reqEditors ...queryservice.RequestEditorFn) (*queryservice.CreateClientResponse, 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 CreateClientWithResponse")
	}

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

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

	return r0, r1
}

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

// CreateClientWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - body queryservice.ClientCreate
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) CreateClientWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_CreateClientWithResponse_Call {
	return &MockClientWithResponsesInterface_CreateClientWithResponse_Call{Call: _e.mock.On("CreateClientWithResponse",
		append([]interface{}{ctx, body}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_CreateClientWithResponse_Call) Return(_a0 *queryservice.CreateClientResponse, _a1 error) *MockClientWithResponsesInterface_CreateClientWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_CreateClientWithResponse_Call) RunAndReturn(run func(context.Context, queryservice.ClientCreate, ...queryservice.RequestEditorFn) (*queryservice.CreateClientResponse, error)) *MockClientWithResponsesInterface_CreateClientWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// CreateQueryWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors
func (_m *MockClientWithResponsesInterface) CreateQueryWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryservice.RequestEditorFn) (*queryservice.CreateQueryResponse, 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 CreateQueryWithBodyWithResponse")
	}

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

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

	return r0, r1
}

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

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

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

func (_c *MockClientWithResponsesInterface_CreateQueryWithBodyWithResponse_Call) Return(_a0 *queryservice.CreateQueryResponse, _a1 error) *MockClientWithResponsesInterface_CreateQueryWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_CreateQueryWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...queryservice.RequestEditorFn) (*queryservice.CreateQueryResponse, error)) *MockClientWithResponsesInterface_CreateQueryWithBodyWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// CreateQueryWithResponse provides a mock function with given fields: ctx, body, reqEditors
func (_m *MockClientWithResponsesInterface) CreateQueryWithResponse(ctx context.Context, body queryservice.QueryCreate, reqEditors ...queryservice.RequestEditorFn) (*queryservice.CreateQueryResponse, 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 CreateQueryWithResponse")
	}

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

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

	return r0, r1
}

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

// CreateQueryWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - body queryservice.QueryCreate
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) CreateQueryWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_CreateQueryWithResponse_Call {
	return &MockClientWithResponsesInterface_CreateQueryWithResponse_Call{Call: _e.mock.On("CreateQueryWithResponse",
		append([]interface{}{ctx, body}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_CreateQueryWithResponse_Call) Return(_a0 *queryservice.CreateQueryResponse, _a1 error) *MockClientWithResponsesInterface_CreateQueryWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_CreateQueryWithResponse_Call) RunAndReturn(run func(context.Context, queryservice.QueryCreate, ...queryservice.RequestEditorFn) (*queryservice.CreateQueryResponse, error)) *MockClientWithResponsesInterface_CreateQueryWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// ExportStateWithResponse provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientWithResponsesInterface) ExportStateWithResponse(ctx context.Context, id uuid.UUID, reqEditors ...queryservice.RequestEditorFn) (*queryservice.ExportStateResponse, 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 ExportStateWithResponse")
	}

	var r0 *queryservice.ExportStateResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, ...queryservice.RequestEditorFn) (*queryservice.ExportStateResponse, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, ...queryservice.RequestEditorFn) *queryservice.ExportStateResponse); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryservice.ExportStateResponse)
		}
	}

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

	return r0, r1
}

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

// ExportStateWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id uuid.UUID
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) ExportStateWithResponse(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_ExportStateWithResponse_Call {
	return &MockClientWithResponsesInterface_ExportStateWithResponse_Call{Call: _e.mock.On("ExportStateWithResponse",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_ExportStateWithResponse_Call) Return(_a0 *queryservice.ExportStateResponse, _a1 error) *MockClientWithResponsesInterface_ExportStateWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_ExportStateWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, ...queryservice.RequestEditorFn) (*queryservice.ExportStateResponse, error)) *MockClientWithResponsesInterface_ExportStateWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// GetClientWithResponse provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientWithResponsesInterface) GetClientWithResponse(ctx context.Context, id string, reqEditors ...queryservice.RequestEditorFn) (*queryservice.GetClientResponse, 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 GetClientWithResponse")
	}

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

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

	return r0, r1
}

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

// GetClientWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) GetClientWithResponse(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_GetClientWithResponse_Call {
	return &MockClientWithResponsesInterface_GetClientWithResponse_Call{Call: _e.mock.On("GetClientWithResponse",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_GetClientWithResponse_Call) Return(_a0 *queryservice.GetClientResponse, _a1 error) *MockClientWithResponsesInterface_GetClientWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_GetClientWithResponse_Call) RunAndReturn(run func(context.Context, string, ...queryservice.RequestEditorFn) (*queryservice.GetClientResponse, error)) *MockClientWithResponsesInterface_GetClientWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// GetCollectorByClientIdWithResponse provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientWithResponsesInterface) GetCollectorByClientIdWithResponse(ctx context.Context, id string, reqEditors ...queryservice.RequestEditorFn) (*queryservice.GetCollectorByClientIdResponse, 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 GetCollectorByClientIdWithResponse")
	}

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

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

	return r0, r1
}

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

// GetCollectorByClientIdWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) GetCollectorByClientIdWithResponse(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_GetCollectorByClientIdWithResponse_Call {
	return &MockClientWithResponsesInterface_GetCollectorByClientIdWithResponse_Call{Call: _e.mock.On("GetCollectorByClientIdWithResponse",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_GetCollectorByClientIdWithResponse_Call) Return(_a0 *queryservice.GetCollectorByClientIdResponse, _a1 error) *MockClientWithResponsesInterface_GetCollectorByClientIdWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_GetCollectorByClientIdWithResponse_Call) RunAndReturn(run func(context.Context, string, ...queryservice.RequestEditorFn) (*queryservice.GetCollectorByClientIdResponse, error)) *MockClientWithResponsesInterface_GetCollectorByClientIdWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// GetQueryWithResponse provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientWithResponsesInterface) GetQueryWithResponse(ctx context.Context, id uuid.UUID, reqEditors ...queryservice.RequestEditorFn) (*queryservice.GetQueryResponse, 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 GetQueryWithResponse")
	}

	var r0 *queryservice.GetQueryResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, ...queryservice.RequestEditorFn) (*queryservice.GetQueryResponse, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, ...queryservice.RequestEditorFn) *queryservice.GetQueryResponse); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryservice.GetQueryResponse)
		}
	}

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

	return r0, r1
}

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

// GetQueryWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id uuid.UUID
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) GetQueryWithResponse(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_GetQueryWithResponse_Call {
	return &MockClientWithResponsesInterface_GetQueryWithResponse_Call{Call: _e.mock.On("GetQueryWithResponse",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_GetQueryWithResponse_Call) Return(_a0 *queryservice.GetQueryResponse, _a1 error) *MockClientWithResponsesInterface_GetQueryWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_GetQueryWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, ...queryservice.RequestEditorFn) (*queryservice.GetQueryResponse, error)) *MockClientWithResponsesInterface_GetQueryWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatusByClientIdWithResponse provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientWithResponsesInterface) GetStatusByClientIdWithResponse(ctx context.Context, id string, reqEditors ...queryservice.RequestEditorFn) (*queryservice.GetStatusByClientIdResponse, 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 GetStatusByClientIdWithResponse")
	}

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

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

	return r0, r1
}

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

// GetStatusByClientIdWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) GetStatusByClientIdWithResponse(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_Call {
	return &MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_Call{Call: _e.mock.On("GetStatusByClientIdWithResponse",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_Call) Return(_a0 *queryservice.GetStatusByClientIdResponse, _a1 error) *MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_Call) RunAndReturn(run func(context.Context, string, ...queryservice.RequestEditorFn) (*queryservice.GetStatusByClientIdResponse, error)) *MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// ListDocumentsByClientIdWithResponse provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientWithResponsesInterface) ListDocumentsByClientIdWithResponse(ctx context.Context, id string, reqEditors ...queryservice.RequestEditorFn) (*queryservice.ListDocumentsByClientIdResponse, 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 ListDocumentsByClientIdWithResponse")
	}

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

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

	return r0, r1
}

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

// ListDocumentsByClientIdWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) ListDocumentsByClientIdWithResponse(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_ListDocumentsByClientIdWithResponse_Call {
	return &MockClientWithResponsesInterface_ListDocumentsByClientIdWithResponse_Call{Call: _e.mock.On("ListDocumentsByClientIdWithResponse",
		append([]interface{}{ctx, id}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_ListDocumentsByClientIdWithResponse_Call) Return(_a0 *queryservice.ListDocumentsByClientIdResponse, _a1 error) *MockClientWithResponsesInterface_ListDocumentsByClientIdWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_ListDocumentsByClientIdWithResponse_Call) RunAndReturn(run func(context.Context, string, ...queryservice.RequestEditorFn) (*queryservice.ListDocumentsByClientIdResponse, error)) *MockClientWithResponsesInterface_ListDocumentsByClientIdWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// ListQueriesWithResponse provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientWithResponsesInterface) ListQueriesWithResponse(ctx context.Context, reqEditors ...queryservice.RequestEditorFn) (*queryservice.ListQueriesResponse, 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 ListQueriesWithResponse")
	}

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

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

	return r0, r1
}

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

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

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

func (_c *MockClientWithResponsesInterface_ListQueriesWithResponse_Call) Return(_a0 *queryservice.ListQueriesResponse, _a1 error) *MockClientWithResponsesInterface_ListQueriesWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_ListQueriesWithResponse_Call) RunAndReturn(run func(context.Context, ...queryservice.RequestEditorFn) (*queryservice.ListQueriesResponse, error)) *MockClientWithResponsesInterface_ListQueriesWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// SetCollectorByClientIdWithBodyWithResponse provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientWithResponsesInterface) SetCollectorByClientIdWithBodyWithResponse(ctx context.Context, id string, contentType string, body io.Reader, reqEditors ...queryservice.RequestEditorFn) (*queryservice.SetCollectorByClientIdResponse, 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 SetCollectorByClientIdWithBodyWithResponse")
	}

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

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

	return r0, r1
}

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

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

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

func (_c *MockClientWithResponsesInterface_SetCollectorByClientIdWithBodyWithResponse_Call) Return(_a0 *queryservice.SetCollectorByClientIdResponse, _a1 error) *MockClientWithResponsesInterface_SetCollectorByClientIdWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_SetCollectorByClientIdWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, string, io.Reader, ...queryservice.RequestEditorFn) (*queryservice.SetCollectorByClientIdResponse, error)) *MockClientWithResponsesInterface_SetCollectorByClientIdWithBodyWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// SetCollectorByClientIdWithResponse provides a mock function with given fields: ctx, id, body, reqEditors
func (_m *MockClientWithResponsesInterface) SetCollectorByClientIdWithResponse(ctx context.Context, id string, body queryservice.CollectorSet, reqEditors ...queryservice.RequestEditorFn) (*queryservice.SetCollectorByClientIdResponse, 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 SetCollectorByClientIdWithResponse")
	}

	var r0 *queryservice.SetCollectorByClientIdResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, queryservice.CollectorSet, ...queryservice.RequestEditorFn) (*queryservice.SetCollectorByClientIdResponse, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, queryservice.CollectorSet, ...queryservice.RequestEditorFn) *queryservice.SetCollectorByClientIdResponse); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryservice.SetCollectorByClientIdResponse)
		}
	}

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

	return r0, r1
}

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

// SetCollectorByClientIdWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - body queryservice.CollectorSet
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) SetCollectorByClientIdWithResponse(ctx interface{}, id interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_SetCollectorByClientIdWithResponse_Call {
	return &MockClientWithResponsesInterface_SetCollectorByClientIdWithResponse_Call{Call: _e.mock.On("SetCollectorByClientIdWithResponse",
		append([]interface{}{ctx, id, body}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_SetCollectorByClientIdWithResponse_Call) Return(_a0 *queryservice.SetCollectorByClientIdResponse, _a1 error) *MockClientWithResponsesInterface_SetCollectorByClientIdWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_SetCollectorByClientIdWithResponse_Call) RunAndReturn(run func(context.Context, string, queryservice.CollectorSet, ...queryservice.RequestEditorFn) (*queryservice.SetCollectorByClientIdResponse, error)) *MockClientWithResponsesInterface_SetCollectorByClientIdWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// TestQueryWithBodyWithResponse provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientWithResponsesInterface) TestQueryWithBodyWithResponse(ctx context.Context, id uuid.UUID, contentType string, body io.Reader, reqEditors ...queryservice.RequestEditorFn) (*queryservice.TestQueryResponse, 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 TestQueryWithBodyWithResponse")
	}

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

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

	return r0, r1
}

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

// TestQueryWithBodyWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id uuid.UUID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) TestQueryWithBodyWithResponse(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_TestQueryWithBodyWithResponse_Call {
	return &MockClientWithResponsesInterface_TestQueryWithBodyWithResponse_Call{Call: _e.mock.On("TestQueryWithBodyWithResponse",
		append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_TestQueryWithBodyWithResponse_Call) Return(_a0 *queryservice.TestQueryResponse, _a1 error) *MockClientWithResponsesInterface_TestQueryWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_TestQueryWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, string, io.Reader, ...queryservice.RequestEditorFn) (*queryservice.TestQueryResponse, error)) *MockClientWithResponsesInterface_TestQueryWithBodyWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// TestQueryWithResponse provides a mock function with given fields: ctx, id, body, reqEditors
func (_m *MockClientWithResponsesInterface) TestQueryWithResponse(ctx context.Context, id uuid.UUID, body queryservice.QueryTestRequest, reqEditors ...queryservice.RequestEditorFn) (*queryservice.TestQueryResponse, 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 TestQueryWithResponse")
	}

	var r0 *queryservice.TestQueryResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, queryservice.QueryTestRequest, ...queryservice.RequestEditorFn) (*queryservice.TestQueryResponse, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, queryservice.QueryTestRequest, ...queryservice.RequestEditorFn) *queryservice.TestQueryResponse); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryservice.TestQueryResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID, queryservice.QueryTestRequest, ...queryservice.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TestQueryWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id uuid.UUID
//   - body queryservice.QueryTestRequest
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) TestQueryWithResponse(ctx interface{}, id interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_TestQueryWithResponse_Call {
	return &MockClientWithResponsesInterface_TestQueryWithResponse_Call{Call: _e.mock.On("TestQueryWithResponse",
		append([]interface{}{ctx, id, body}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_TestQueryWithResponse_Call) Return(_a0 *queryservice.TestQueryResponse, _a1 error) *MockClientWithResponsesInterface_TestQueryWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_TestQueryWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, queryservice.QueryTestRequest, ...queryservice.RequestEditorFn) (*queryservice.TestQueryResponse, error)) *MockClientWithResponsesInterface_TestQueryWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// TriggerExportWithBodyWithResponse provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientWithResponsesInterface) TriggerExportWithBodyWithResponse(ctx context.Context, id string, contentType string, body io.Reader, reqEditors ...queryservice.RequestEditorFn) (*queryservice.TriggerExportResponse, 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 TriggerExportWithBodyWithResponse")
	}

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

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

	return r0, r1
}

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

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

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

func (_c *MockClientWithResponsesInterface_TriggerExportWithBodyWithResponse_Call) Return(_a0 *queryservice.TriggerExportResponse, _a1 error) *MockClientWithResponsesInterface_TriggerExportWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_TriggerExportWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, string, io.Reader, ...queryservice.RequestEditorFn) (*queryservice.TriggerExportResponse, error)) *MockClientWithResponsesInterface_TriggerExportWithBodyWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// TriggerExportWithResponse provides a mock function with given fields: ctx, id, body, reqEditors
func (_m *MockClientWithResponsesInterface) TriggerExportWithResponse(ctx context.Context, id string, body queryservice.ExportTrigger, reqEditors ...queryservice.RequestEditorFn) (*queryservice.TriggerExportResponse, 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 TriggerExportWithResponse")
	}

	var r0 *queryservice.TriggerExportResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, queryservice.ExportTrigger, ...queryservice.RequestEditorFn) (*queryservice.TriggerExportResponse, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, queryservice.ExportTrigger, ...queryservice.RequestEditorFn) *queryservice.TriggerExportResponse); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryservice.TriggerExportResponse)
		}
	}

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

	return r0, r1
}

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

// TriggerExportWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - body queryservice.ExportTrigger
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) TriggerExportWithResponse(ctx interface{}, id interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_TriggerExportWithResponse_Call {
	return &MockClientWithResponsesInterface_TriggerExportWithResponse_Call{Call: _e.mock.On("TriggerExportWithResponse",
		append([]interface{}{ctx, id, body}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_TriggerExportWithResponse_Call) Return(_a0 *queryservice.TriggerExportResponse, _a1 error) *MockClientWithResponsesInterface_TriggerExportWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_TriggerExportWithResponse_Call) RunAndReturn(run func(context.Context, string, queryservice.ExportTrigger, ...queryservice.RequestEditorFn) (*queryservice.TriggerExportResponse, error)) *MockClientWithResponsesInterface_TriggerExportWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClientWithBodyWithResponse provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientWithResponsesInterface) UpdateClientWithBodyWithResponse(ctx context.Context, id string, contentType string, body io.Reader, reqEditors ...queryservice.RequestEditorFn) (*queryservice.UpdateClientResponse, 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 UpdateClientWithBodyWithResponse")
	}

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

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

	return r0, r1
}

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

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

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

func (_c *MockClientWithResponsesInterface_UpdateClientWithBodyWithResponse_Call) Return(_a0 *queryservice.UpdateClientResponse, _a1 error) *MockClientWithResponsesInterface_UpdateClientWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_UpdateClientWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, string, io.Reader, ...queryservice.RequestEditorFn) (*queryservice.UpdateClientResponse, error)) *MockClientWithResponsesInterface_UpdateClientWithBodyWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClientWithResponse provides a mock function with given fields: ctx, id, body, reqEditors
func (_m *MockClientWithResponsesInterface) UpdateClientWithResponse(ctx context.Context, id string, body queryservice.ClientUpdate, reqEditors ...queryservice.RequestEditorFn) (*queryservice.UpdateClientResponse, 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 UpdateClientWithResponse")
	}

	var r0 *queryservice.UpdateClientResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, queryservice.ClientUpdate, ...queryservice.RequestEditorFn) (*queryservice.UpdateClientResponse, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, queryservice.ClientUpdate, ...queryservice.RequestEditorFn) *queryservice.UpdateClientResponse); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryservice.UpdateClientResponse)
		}
	}

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

	return r0, r1
}

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

// UpdateClientWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - body queryservice.ClientUpdate
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) UpdateClientWithResponse(ctx interface{}, id interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_UpdateClientWithResponse_Call {
	return &MockClientWithResponsesInterface_UpdateClientWithResponse_Call{Call: _e.mock.On("UpdateClientWithResponse",
		append([]interface{}{ctx, id, body}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_UpdateClientWithResponse_Call) Return(_a0 *queryservice.UpdateClientResponse, _a1 error) *MockClientWithResponsesInterface_UpdateClientWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_UpdateClientWithResponse_Call) RunAndReturn(run func(context.Context, string, queryservice.ClientUpdate, ...queryservice.RequestEditorFn) (*queryservice.UpdateClientResponse, error)) *MockClientWithResponsesInterface_UpdateClientWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateQueryWithBodyWithResponse provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientWithResponsesInterface) UpdateQueryWithBodyWithResponse(ctx context.Context, id uuid.UUID, contentType string, body io.Reader, reqEditors ...queryservice.RequestEditorFn) (*queryservice.UpdateQueryResponse, 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 UpdateQueryWithBodyWithResponse")
	}

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

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

	return r0, r1
}

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

// UpdateQueryWithBodyWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id uuid.UUID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) UpdateQueryWithBodyWithResponse(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_UpdateQueryWithBodyWithResponse_Call {
	return &MockClientWithResponsesInterface_UpdateQueryWithBodyWithResponse_Call{Call: _e.mock.On("UpdateQueryWithBodyWithResponse",
		append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_UpdateQueryWithBodyWithResponse_Call) Return(_a0 *queryservice.UpdateQueryResponse, _a1 error) *MockClientWithResponsesInterface_UpdateQueryWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_UpdateQueryWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, string, io.Reader, ...queryservice.RequestEditorFn) (*queryservice.UpdateQueryResponse, error)) *MockClientWithResponsesInterface_UpdateQueryWithBodyWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateQueryWithResponse provides a mock function with given fields: ctx, id, body, reqEditors
func (_m *MockClientWithResponsesInterface) UpdateQueryWithResponse(ctx context.Context, id uuid.UUID, body queryservice.QueryUpdate, reqEditors ...queryservice.RequestEditorFn) (*queryservice.UpdateQueryResponse, 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 UpdateQueryWithResponse")
	}

	var r0 *queryservice.UpdateQueryResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, queryservice.QueryUpdate, ...queryservice.RequestEditorFn) (*queryservice.UpdateQueryResponse, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, queryservice.QueryUpdate, ...queryservice.RequestEditorFn) *queryservice.UpdateQueryResponse); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryservice.UpdateQueryResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID, queryservice.QueryUpdate, ...queryservice.RequestEditorFn) error); ok {
		r1 = rf(ctx, id, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateQueryWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - id uuid.UUID
//   - body queryservice.QueryUpdate
//   - reqEditors ...queryservice.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) UpdateQueryWithResponse(ctx interface{}, id interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_UpdateQueryWithResponse_Call {
	return &MockClientWithResponsesInterface_UpdateQueryWithResponse_Call{Call: _e.mock.On("UpdateQueryWithResponse",
		append([]interface{}{ctx, id, body}, reqEditors...)...)}
}

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

func (_c *MockClientWithResponsesInterface_UpdateQueryWithResponse_Call) Return(_a0 *queryservice.UpdateQueryResponse, _a1 error) *MockClientWithResponsesInterface_UpdateQueryWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_UpdateQueryWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, queryservice.QueryUpdate, ...queryservice.RequestEditorFn) (*queryservice.UpdateQueryResponse, error)) *MockClientWithResponsesInterface_UpdateQueryWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}