query-orchestration/mocks/queryapi/mock_ClientWithResponsesInterface.go

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

package queryapimock

import (
	context "context"
	io "io"

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

	queryapi "queryorchestration/pkg/queryAPI"

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

// 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}
}

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

	var r0 *queryapi.ApplyLabelResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.ApplyLabelResponse, 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) *queryapi.ApplyLabelResponse); ok {
		r0 = rf(ctx, documentId, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.ApplyLabelResponse)
		}
	}

	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
}

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

// ApplyLabelWithBodyWithResponse 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 *MockClientWithResponsesInterface_Expecter) ApplyLabelWithBodyWithResponse(ctx interface{}, documentId interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_ApplyLabelWithBodyWithResponse_Call {
	return &MockClientWithResponsesInterface_ApplyLabelWithBodyWithResponse_Call{Call: _e.mock.On("ApplyLabelWithBodyWithResponse",
		append([]interface{}{ctx, documentId, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientWithResponsesInterface_ApplyLabelWithBodyWithResponse_Call) Run(run func(ctx context.Context, documentId types.UUID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_ApplyLabelWithBodyWithResponse_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 *MockClientWithResponsesInterface_ApplyLabelWithBodyWithResponse_Call) Return(_a0 *queryapi.ApplyLabelResponse, _a1 error) *MockClientWithResponsesInterface_ApplyLabelWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// ApplyLabelWithResponse provides a mock function with given fields: ctx, documentId, body, reqEditors
func (_m *MockClientWithResponsesInterface) ApplyLabelWithResponse(ctx context.Context, documentId types.UUID, body queryapi.ApplyLabelJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.ApplyLabelResponse, 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 ApplyLabelWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_ApplyLabelWithResponse_Call) Run(run func(ctx context.Context, documentId types.UUID, body queryapi.ApplyLabelJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_ApplyLabelWithResponse_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 *MockClientWithResponsesInterface_ApplyLabelWithResponse_Call) Return(_a0 *queryapi.ApplyLabelResponse, _a1 error) *MockClientWithResponsesInterface_ApplyLabelWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// CancelDocumentBatchWithResponse provides a mock function with given fields: ctx, id, batchId, reqEditors
func (_m *MockClientWithResponsesInterface) CancelDocumentBatchWithResponse(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.CancelDocumentBatchResponse, 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 CancelDocumentBatchWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_CancelDocumentBatchWithResponse_Call) Run(run func(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CancelDocumentBatchWithResponse_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 *MockClientWithResponsesInterface_CancelDocumentBatchWithResponse_Call) Return(_a0 *queryapi.CancelDocumentBatchResponse, _a1 error) *MockClientWithResponsesInterface_CancelDocumentBatchWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_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 *MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call) Return(_a0 *queryapi.CheckAdminUserExistsResponse, _a1 error) *MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_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 *MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call) Return(_a0 *queryapi.CreateAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call) Run(run func(ctx context.Context, body queryapi.CreateAdminUserJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateAdminUserWithResponse_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 *MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call) Return(_a0 *queryapi.CreateAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// 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 ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.CreateClientResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.CreateClientResponse, error)); ok {
		return rf(ctx, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) *queryapi.CreateClientResponse); ok {
		r0 = rf(ctx, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.CreateClientResponse)
		}
	}

	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
}

// 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 ...queryapi.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 ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateClientWithBodyWithResponse_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 *MockClientWithResponsesInterface_CreateClientWithBodyWithResponse_Call) Return(_a0 *queryapi.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, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.CreateClientJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.CreateClientResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateClientJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.CreateClientResponse, error)); ok {
		return rf(ctx, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateClientJSONRequestBody, ...queryapi.RequestEditorFn) *queryapi.CreateClientResponse); ok {
		r0 = rf(ctx, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.CreateClientResponse)
		}
	}

	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
}

// 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 queryapi.CreateClientJSONRequestBody
//   - reqEditors ...queryapi.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 queryapi.CreateClientJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateClientWithResponse_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 *MockClientWithResponsesInterface_CreateClientWithResponse_Call) Return(_a0 *queryapi.CreateClientResponse, _a1 error) *MockClientWithResponsesInterface_CreateClientWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_CreateFieldExtractionWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateFieldExtractionWithBodyWithResponse_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 *MockClientWithResponsesInterface_CreateFieldExtractionWithBodyWithResponse_Call) Return(_a0 *queryapi.CreateFieldExtractionResponse, _a1 error) *MockClientWithResponsesInterface_CreateFieldExtractionWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_CreateFieldExtractionWithResponse_Call) Run(run func(ctx context.Context, body queryapi.CreateFieldExtractionJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateFieldExtractionWithResponse_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 *MockClientWithResponsesInterface_CreateFieldExtractionWithResponse_Call) Return(_a0 *queryapi.CreateFieldExtractionResponse, _a1 error) *MockClientWithResponsesInterface_CreateFieldExtractionWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_CreateFolderWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateFolderWithBodyWithResponse_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 *MockClientWithResponsesInterface_CreateFolderWithBodyWithResponse_Call) Return(_a0 *queryapi.CreateFolderResponse, _a1 error) *MockClientWithResponsesInterface_CreateFolderWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_CreateFolderWithResponse_Call) Run(run func(ctx context.Context, body queryapi.CreateFolderJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateFolderWithResponse_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 *MockClientWithResponsesInterface_CreateFolderWithResponse_Call) Return(_a0 *queryapi.CreateFolderResponse, _a1 error) *MockClientWithResponsesInterface_CreateFolderWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_CreateFolderWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.CreateFolderJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.CreateFolderResponse, error)) *MockClientWithResponsesInterface_CreateFolderWithResponse_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 ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.CreateQueryResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.CreateQueryResponse, error)); ok {
		return rf(ctx, contentType, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) *queryapi.CreateQueryResponse); ok {
		r0 = rf(ctx, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.CreateQueryResponse)
		}
	}

	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
}

// 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 ...queryapi.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 ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateQueryWithBodyWithResponse_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 *MockClientWithResponsesInterface_CreateQueryWithBodyWithResponse_Call) Return(_a0 *queryapi.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, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.CreateQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.CreateQueryResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateQueryJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.CreateQueryResponse, error)); ok {
		return rf(ctx, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateQueryJSONRequestBody, ...queryapi.RequestEditorFn) *queryapi.CreateQueryResponse); ok {
		r0 = rf(ctx, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.CreateQueryResponse)
		}
	}

	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
}

// 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 queryapi.CreateQueryJSONRequestBody
//   - reqEditors ...queryapi.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 queryapi.CreateQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateQueryWithResponse_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 *MockClientWithResponsesInterface_CreateQueryWithResponse_Call) Return(_a0 *queryapi.CreateQueryResponse, _a1 error) *MockClientWithResponsesInterface_CreateQueryWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// DeleteAdminUserWithResponse provides a mock function with given fields: ctx, email, params, reqEditors
func (_m *MockClientWithResponsesInterface) DeleteAdminUserWithResponse(ctx context.Context, email queryapi.UserEmail, params *queryapi.DeleteAdminUserParams, reqEditors ...queryapi.RequestEditorFn) (*queryapi.DeleteAdminUserResponse, 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 DeleteAdminUserWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, params *queryapi.DeleteAdminUserParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_DeleteAdminUserWithResponse_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 *MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call) Return(_a0 *queryapi.DeleteAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_DisableAdminUserWithResponse_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 *MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call) Return(_a0 *queryapi.DisableAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_EnableAdminUserWithResponse_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 *MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call) Return(_a0 *queryapi.EnableAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*queryapi.EnableAdminUserResponse, error)) *MockClientWithResponsesInterface_EnableAdminUserWithResponse_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 queryapi.ExportID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.ExportStateResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ExportID, ...queryapi.RequestEditorFn) (*queryapi.ExportStateResponse, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ExportID, ...queryapi.RequestEditorFn) *queryapi.ExportStateResponse); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.ExportStateResponse)
		}
	}

	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
}

// 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 queryapi.ExportID
//   - reqEditors ...queryapi.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 queryapi.ExportID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_ExportStateWithResponse_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 *MockClientWithResponsesInterface_ExportStateWithResponse_Call) Return(_a0 *queryapi.ExportStateResponse, _a1 error) *MockClientWithResponsesInterface_ExportStateWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_GetAdminUserWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetAdminUserWithResponse_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 *MockClientWithResponsesInterface_GetAdminUserWithResponse_Call) Return(_a0 *queryapi.GetAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_GetAdminUserWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_GetAdminUserWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*queryapi.GetAdminUserResponse, error)) *MockClientWithResponsesInterface_GetAdminUserWithResponse_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 queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.GetClientResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*queryapi.GetClientResponse, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) *queryapi.GetClientResponse); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.GetClientResponse)
		}
	}

	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
}

// 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 queryapi.ClientID
//   - reqEditors ...queryapi.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 queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetClientWithResponse_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 *MockClientWithResponsesInterface_GetClientWithResponse_Call) Return(_a0 *queryapi.GetClientResponse, _a1 error) *MockClientWithResponsesInterface_GetClientWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_GetClientWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.GetCollectorByClientIdResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*queryapi.GetCollectorByClientIdResponse, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) *queryapi.GetCollectorByClientIdResponse); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.GetCollectorByClientIdResponse)
		}
	}

	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
}

// 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 queryapi.ClientID
//   - reqEditors ...queryapi.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 queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetCollectorByClientIdWithResponse_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 *MockClientWithResponsesInterface_GetCollectorByClientIdWithResponse_Call) Return(_a0 *queryapi.GetCollectorByClientIdResponse, _a1 error) *MockClientWithResponsesInterface_GetCollectorByClientIdWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_GetCurrentFieldExtractionWithResponse_Call) Run(run func(ctx context.Context, params *queryapi.GetCurrentFieldExtractionParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetCurrentFieldExtractionWithResponse_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 *MockClientWithResponsesInterface_GetCurrentFieldExtractionWithResponse_Call) Return(_a0 *queryapi.GetCurrentFieldExtractionResponse, _a1 error) *MockClientWithResponsesInterface_GetCurrentFieldExtractionWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetDocumentBatchWithResponse provides a mock function with given fields: ctx, id, batchId, reqEditors
func (_m *MockClientWithResponsesInterface) GetDocumentBatchWithResponse(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.GetDocumentBatchResponse, 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 GetDocumentBatchWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_GetDocumentBatchWithResponse_Call) Run(run func(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetDocumentBatchWithResponse_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 *MockClientWithResponsesInterface_GetDocumentBatchWithResponse_Call) Return(_a0 *queryapi.GetDocumentBatchResponse, _a1 error) *MockClientWithResponsesInterface_GetDocumentBatchWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetDocumentLabelsWithResponse provides a mock function with given fields: ctx, documentId, reqEditors
func (_m *MockClientWithResponsesInterface) GetDocumentLabelsWithResponse(ctx context.Context, documentId types.UUID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.GetDocumentLabelsResponse, 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 GetDocumentLabelsWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_GetDocumentLabelsWithResponse_Call) Run(run func(ctx context.Context, documentId types.UUID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetDocumentLabelsWithResponse_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 *MockClientWithResponsesInterface_GetDocumentLabelsWithResponse_Call) Return(_a0 *queryapi.GetDocumentLabelsResponse, _a1 error) *MockClientWithResponsesInterface_GetDocumentLabelsWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_GetDocumentWithResponse_Call) Run(run func(ctx context.Context, id queryapi.DocumentID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetDocumentWithResponse_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 *MockClientWithResponsesInterface_GetDocumentWithResponse_Call) Return(_a0 *queryapi.GetDocumentResponse, _a1 error) *MockClientWithResponsesInterface_GetDocumentWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetDocumentsByLabelWithResponse provides a mock function with given fields: ctx, labelName, params, reqEditors
func (_m *MockClientWithResponsesInterface) GetDocumentsByLabelWithResponse(ctx context.Context, labelName string, params *queryapi.GetDocumentsByLabelParams, reqEditors ...queryapi.RequestEditorFn) (*queryapi.GetDocumentsByLabelResponse, 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 GetDocumentsByLabelWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_GetDocumentsByLabelWithResponse_Call) Run(run func(ctx context.Context, labelName string, params *queryapi.GetDocumentsByLabelParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetDocumentsByLabelWithResponse_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 *MockClientWithResponsesInterface_GetDocumentsByLabelWithResponse_Call) Return(_a0 *queryapi.GetDocumentsByLabelResponse, _a1 error) *MockClientWithResponsesInterface_GetDocumentsByLabelWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_GetFieldExtractionByVersionWithResponse_Call) Run(run func(ctx context.Context, params *queryapi.GetFieldExtractionByVersionParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetFieldExtractionByVersionWithResponse_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 *MockClientWithResponsesInterface_GetFieldExtractionByVersionWithResponse_Call) Return(_a0 *queryapi.GetFieldExtractionByVersionResponse, _a1 error) *MockClientWithResponsesInterface_GetFieldExtractionByVersionWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_GetFieldExtractionHistoryWithResponse_Call) Run(run func(ctx context.Context, params *queryapi.GetFieldExtractionHistoryParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetFieldExtractionHistoryWithResponse_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 *MockClientWithResponsesInterface_GetFieldExtractionHistoryWithResponse_Call) Return(_a0 *queryapi.GetFieldExtractionHistoryResponse, _a1 error) *MockClientWithResponsesInterface_GetFieldExtractionHistoryWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetFolderDocumentsWithResponse provides a mock function with given fields: ctx, folderId, reqEditors
func (_m *MockClientWithResponsesInterface) GetFolderDocumentsWithResponse(ctx context.Context, folderId types.UUID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.GetFolderDocumentsResponse, 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 GetFolderDocumentsWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_GetFolderDocumentsWithResponse_Call) Run(run func(ctx context.Context, folderId types.UUID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetFolderDocumentsWithResponse_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 *MockClientWithResponsesInterface_GetFolderDocumentsWithResponse_Call) Return(_a0 *queryapi.GetFolderDocumentsResponse, _a1 error) *MockClientWithResponsesInterface_GetFolderDocumentsWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetFolderMetricsWithResponse provides a mock function with given fields: ctx, folderId, reqEditors
func (_m *MockClientWithResponsesInterface) GetFolderMetricsWithResponse(ctx context.Context, folderId types.UUID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.GetFolderMetricsResponse, 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 GetFolderMetricsWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_GetFolderMetricsWithResponse_Call) Run(run func(ctx context.Context, folderId types.UUID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetFolderMetricsWithResponse_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 *MockClientWithResponsesInterface_GetFolderMetricsWithResponse_Call) Return(_a0 *queryapi.GetFolderMetricsResponse, _a1 error) *MockClientWithResponsesInterface_GetFolderMetricsWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_GetHomePageWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetHomePageWithResponse_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 *MockClientWithResponsesInterface_GetHomePageWithResponse_Call) Return(_a0 *queryapi.GetHomePageResponse, _a1 error) *MockClientWithResponsesInterface_GetHomePageWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_GetHomePageWithResponse_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.GetHomePageResponse, error)) *MockClientWithResponsesInterface_GetHomePageWithResponse_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 queryapi.QueryID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.GetQueryResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, ...queryapi.RequestEditorFn) (*queryapi.GetQueryResponse, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, ...queryapi.RequestEditorFn) *queryapi.GetQueryResponse); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.GetQueryResponse)
		}
	}

	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
}

// 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 queryapi.QueryID
//   - reqEditors ...queryapi.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 queryapi.QueryID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetQueryWithResponse_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 *MockClientWithResponsesInterface_GetQueryWithResponse_Call) Return(_a0 *queryapi.GetQueryResponse, _a1 error) *MockClientWithResponsesInterface_GetQueryWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_GetQueryWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.QueryID, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.GetStatusByClientIdResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*queryapi.GetStatusByClientIdResponse, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) *queryapi.GetStatusByClientIdResponse); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.GetStatusByClientIdResponse)
		}
	}

	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
}

// 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 queryapi.ClientID
//   - reqEditors ...queryapi.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 queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_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 *MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_Call) Return(_a0 *queryapi.GetStatusByClientIdResponse, _a1 error) *MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call) Run(run func(ctx context.Context, params *queryapi.ListAdminUsersParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_ListAdminUsersWithResponse_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 *MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call) Return(_a0 *queryapi.ListAdminUsersResponse, _a1 error) *MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// ListClientFoldersWithResponse provides a mock function with given fields: ctx, id, params, reqEditors
func (_m *MockClientWithResponsesInterface) ListClientFoldersWithResponse(ctx context.Context, id queryapi.ClientID, params *queryapi.ListClientFoldersParams, reqEditors ...queryapi.RequestEditorFn) (*queryapi.ListClientFoldersResponse, 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 ListClientFoldersWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_ListClientFoldersWithResponse_Call) Run(run func(ctx context.Context, id queryapi.ClientID, params *queryapi.ListClientFoldersParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_ListClientFoldersWithResponse_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 *MockClientWithResponsesInterface_ListClientFoldersWithResponse_Call) Return(_a0 *queryapi.ListClientFoldersResponse, _a1 error) *MockClientWithResponsesInterface_ListClientFoldersWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_ListClientsWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_ListClientsWithResponse_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 *MockClientWithResponsesInterface_ListClientsWithResponse_Call) Return(_a0 *queryapi.ListClientsResponse, _a1 error) *MockClientWithResponsesInterface_ListClientsWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_ListClientsWithResponse_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.ListClientsResponse, error)) *MockClientWithResponsesInterface_ListClientsWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// ListDocumentBatchesWithResponse provides a mock function with given fields: ctx, id, params, reqEditors
func (_m *MockClientWithResponsesInterface) ListDocumentBatchesWithResponse(ctx context.Context, id queryapi.ClientID, params *queryapi.ListDocumentBatchesParams, reqEditors ...queryapi.RequestEditorFn) (*queryapi.ListDocumentBatchesResponse, 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 ListDocumentBatchesWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_ListDocumentBatchesWithResponse_Call) Run(run func(ctx context.Context, id queryapi.ClientID, params *queryapi.ListDocumentBatchesParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_ListDocumentBatchesWithResponse_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 *MockClientWithResponsesInterface_ListDocumentBatchesWithResponse_Call) Return(_a0 *queryapi.ListDocumentBatchesResponse, _a1 error) *MockClientWithResponsesInterface_ListDocumentBatchesWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_ListDocumentBatchesWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, *queryapi.ListDocumentBatchesParams, ...queryapi.RequestEditorFn) (*queryapi.ListDocumentBatchesResponse, error)) *MockClientWithResponsesInterface_ListDocumentBatchesWithResponse_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 queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.ListDocumentsByClientIdResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*queryapi.ListDocumentsByClientIdResponse, error)); ok {
		return rf(ctx, id, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) *queryapi.ListDocumentsByClientIdResponse); ok {
		r0 = rf(ctx, id, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.ListDocumentsByClientIdResponse)
		}
	}

	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
}

// 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 queryapi.ClientID
//   - reqEditors ...queryapi.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 queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_ListDocumentsByClientIdWithResponse_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 *MockClientWithResponsesInterface_ListDocumentsByClientIdWithResponse_Call) Return(_a0 *queryapi.ListDocumentsByClientIdResponse, _a1 error) *MockClientWithResponsesInterface_ListDocumentsByClientIdWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_ListDocumentsByClientIdWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, ...queryapi.RequestEditorFn) (*queryapi.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 ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.ListQueriesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.ListQueriesResponse, error)); ok {
		return rf(ctx, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) *queryapi.ListQueriesResponse); ok {
		r0 = rf(ctx, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.ListQueriesResponse)
		}
	}

	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
}

// 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 ...queryapi.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 ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_ListQueriesWithResponse_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 *MockClientWithResponsesInterface_ListQueriesWithResponse_Call) Return(_a0 *queryapi.ListQueriesResponse, _a1 error) *MockClientWithResponsesInterface_ListQueriesWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_LoginCallbackWithResponse_Call) Run(run func(ctx context.Context, params *queryapi.LoginCallbackParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_LoginCallbackWithResponse_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 *MockClientWithResponsesInterface_LoginCallbackWithResponse_Call) Return(_a0 *queryapi.LoginCallbackResponse, _a1 error) *MockClientWithResponsesInterface_LoginCallbackWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_LoginWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_LoginWithResponse_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 *MockClientWithResponsesInterface_LoginWithResponse_Call) Return(_a0 *queryapi.LoginResponse, _a1 error) *MockClientWithResponsesInterface_LoginWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_LoginWithResponse_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.LoginResponse, error)) *MockClientWithResponsesInterface_LoginWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_LogoutWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_LogoutWithResponse_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 *MockClientWithResponsesInterface_LogoutWithResponse_Call) Return(_a0 *queryapi.LogoutResponse, _a1 error) *MockClientWithResponsesInterface_LogoutWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_LogoutWithResponse_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.LogoutResponse, error)) *MockClientWithResponsesInterface_LogoutWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

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

	var r0 *queryapi.RenameFolderResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, types.UUID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.RenameFolderResponse, 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) *queryapi.RenameFolderResponse); ok {
		r0 = rf(ctx, folderId, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.RenameFolderResponse)
		}
	}

	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
}

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

// RenameFolderWithBodyWithResponse 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 *MockClientWithResponsesInterface_Expecter) RenameFolderWithBodyWithResponse(ctx interface{}, folderId interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_RenameFolderWithBodyWithResponse_Call {
	return &MockClientWithResponsesInterface_RenameFolderWithBodyWithResponse_Call{Call: _e.mock.On("RenameFolderWithBodyWithResponse",
		append([]interface{}{ctx, folderId, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientWithResponsesInterface_RenameFolderWithBodyWithResponse_Call) Run(run func(ctx context.Context, folderId types.UUID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_RenameFolderWithBodyWithResponse_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 *MockClientWithResponsesInterface_RenameFolderWithBodyWithResponse_Call) Return(_a0 *queryapi.RenameFolderResponse, _a1 error) *MockClientWithResponsesInterface_RenameFolderWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// RenameFolderWithResponse provides a mock function with given fields: ctx, folderId, body, reqEditors
func (_m *MockClientWithResponsesInterface) RenameFolderWithResponse(ctx context.Context, folderId types.UUID, body queryapi.RenameFolderJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.RenameFolderResponse, 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 RenameFolderWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_RenameFolderWithResponse_Call) Run(run func(ctx context.Context, folderId types.UUID, body queryapi.RenameFolderJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_RenameFolderWithResponse_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 *MockClientWithResponsesInterface_RenameFolderWithResponse_Call) Return(_a0 *queryapi.RenameFolderResponse, _a1 error) *MockClientWithResponsesInterface_RenameFolderWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_RenameFolderWithResponse_Call) RunAndReturn(run func(context.Context, types.UUID, queryapi.RenameFolderJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.RenameFolderResponse, error)) *MockClientWithResponsesInterface_RenameFolderWithResponse_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 queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.SetCollectorByClientIdResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.SetCollectorByClientIdResponse, 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) *queryapi.SetCollectorByClientIdResponse); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.SetCollectorByClientIdResponse)
		}
	}

	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
}

// 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 queryapi.ClientID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.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 queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_SetCollectorByClientIdWithBodyWithResponse_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 *MockClientWithResponsesInterface_SetCollectorByClientIdWithBodyWithResponse_Call) Return(_a0 *queryapi.SetCollectorByClientIdResponse, _a1 error) *MockClientWithResponsesInterface_SetCollectorByClientIdWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_SetCollectorByClientIdWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.ClientID, body queryapi.SetCollectorByClientIdJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.SetCollectorByClientIdResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.SetCollectorByClientIdJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.SetCollectorByClientIdResponse, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.SetCollectorByClientIdJSONRequestBody, ...queryapi.RequestEditorFn) *queryapi.SetCollectorByClientIdResponse); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.SetCollectorByClientIdResponse)
		}
	}

	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
}

// 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 queryapi.ClientID
//   - body queryapi.SetCollectorByClientIdJSONRequestBody
//   - reqEditors ...queryapi.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 queryapi.ClientID, body queryapi.SetCollectorByClientIdJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_SetCollectorByClientIdWithResponse_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 *MockClientWithResponsesInterface_SetCollectorByClientIdWithResponse_Call) Return(_a0 *queryapi.SetCollectorByClientIdResponse, _a1 error) *MockClientWithResponsesInterface_SetCollectorByClientIdWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_SetCollectorByClientIdWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, queryapi.SetCollectorByClientIdJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.QueryID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.TestQueryResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.TestQueryResponse, 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) *queryapi.TestQueryResponse); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.TestQueryResponse)
		}
	}

	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
}

// 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 queryapi.QueryID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.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 queryapi.QueryID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_TestQueryWithBodyWithResponse_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 *MockClientWithResponsesInterface_TestQueryWithBodyWithResponse_Call) Return(_a0 *queryapi.TestQueryResponse, _a1 error) *MockClientWithResponsesInterface_TestQueryWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_TestQueryWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.QueryID, body queryapi.TestQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.TestQueryResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, queryapi.TestQueryJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.TestQueryResponse, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, queryapi.TestQueryJSONRequestBody, ...queryapi.RequestEditorFn) *queryapi.TestQueryResponse); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.TestQueryResponse)
		}
	}

	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
}

// 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 queryapi.QueryID
//   - body queryapi.TestQueryJSONRequestBody
//   - reqEditors ...queryapi.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 queryapi.QueryID, body queryapi.TestQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_TestQueryWithResponse_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 *MockClientWithResponsesInterface_TestQueryWithResponse_Call) Return(_a0 *queryapi.TestQueryResponse, _a1 error) *MockClientWithResponsesInterface_TestQueryWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_TestQueryWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.QueryID, queryapi.TestQueryJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.TriggerExportResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.TriggerExportResponse, 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) *queryapi.TriggerExportResponse); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.TriggerExportResponse)
		}
	}

	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
}

// 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 queryapi.ClientID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.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 queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_TriggerExportWithBodyWithResponse_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 *MockClientWithResponsesInterface_TriggerExportWithBodyWithResponse_Call) Return(_a0 *queryapi.TriggerExportResponse, _a1 error) *MockClientWithResponsesInterface_TriggerExportWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_TriggerExportWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.ClientID, body queryapi.TriggerExportJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.TriggerExportResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.TriggerExportJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.TriggerExportResponse, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.TriggerExportJSONRequestBody, ...queryapi.RequestEditorFn) *queryapi.TriggerExportResponse); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.TriggerExportResponse)
		}
	}

	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
}

// 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 queryapi.ClientID
//   - body queryapi.TriggerExportJSONRequestBody
//   - reqEditors ...queryapi.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 queryapi.ClientID, body queryapi.TriggerExportJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_TriggerExportWithResponse_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 *MockClientWithResponsesInterface_TriggerExportWithResponse_Call) Return(_a0 *queryapi.TriggerExportResponse, _a1 error) *MockClientWithResponsesInterface_TriggerExportWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

	var r0 *queryapi.UpdateAdminUserResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.UpdateAdminUserResponse, 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) *queryapi.UpdateAdminUserResponse); ok {
		r0 = rf(ctx, email, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.UpdateAdminUserResponse)
		}
	}

	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
}

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

// UpdateAdminUserWithBodyWithResponse 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 *MockClientWithResponsesInterface_Expecter) UpdateAdminUserWithBodyWithResponse(ctx interface{}, email interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call {
	return &MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call{Call: _e.mock.On("UpdateAdminUserWithBodyWithResponse",
		append([]interface{}{ctx, email, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_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 *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call) Return(_a0 *queryapi.UpdateAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// UpdateAdminUserWithResponse provides a mock function with given fields: ctx, email, body, reqEditors
func (_m *MockClientWithResponsesInterface) UpdateAdminUserWithResponse(ctx context.Context, email queryapi.UserEmail, body queryapi.UpdateAdminUserJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.UpdateAdminUserResponse, 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 UpdateAdminUserWithResponse")
	}

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

	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
}

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

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

func (_c *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, body queryapi.UpdateAdminUserJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_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 *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call) Return(_a0 *queryapi.UpdateAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, queryapi.UpdateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.UpdateAdminUserResponse, error)) *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_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 queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.UpdateClientResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.UpdateClientResponse, 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) *queryapi.UpdateClientResponse); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.UpdateClientResponse)
		}
	}

	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
}

// 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 queryapi.ClientID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.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 queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_UpdateClientWithBodyWithResponse_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 *MockClientWithResponsesInterface_UpdateClientWithBodyWithResponse_Call) Return(_a0 *queryapi.UpdateClientResponse, _a1 error) *MockClientWithResponsesInterface_UpdateClientWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_UpdateClientWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.ClientID, body queryapi.UpdateClientJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.UpdateClientResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.UpdateClientJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.UpdateClientResponse, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.UpdateClientJSONRequestBody, ...queryapi.RequestEditorFn) *queryapi.UpdateClientResponse); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.UpdateClientResponse)
		}
	}

	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
}

// 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 queryapi.ClientID
//   - body queryapi.UpdateClientJSONRequestBody
//   - reqEditors ...queryapi.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 queryapi.ClientID, body queryapi.UpdateClientJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_UpdateClientWithResponse_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 *MockClientWithResponsesInterface_UpdateClientWithResponse_Call) Return(_a0 *queryapi.UpdateClientResponse, _a1 error) *MockClientWithResponsesInterface_UpdateClientWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_UpdateClientWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, queryapi.UpdateClientJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.QueryID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.UpdateQueryResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.UpdateQueryResponse, 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) *queryapi.UpdateQueryResponse); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.UpdateQueryResponse)
		}
	}

	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
}

// 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 queryapi.QueryID
//   - contentType string
//   - body io.Reader
//   - reqEditors ...queryapi.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 queryapi.QueryID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_UpdateQueryWithBodyWithResponse_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 *MockClientWithResponsesInterface_UpdateQueryWithBodyWithResponse_Call) Return(_a0 *queryapi.UpdateQueryResponse, _a1 error) *MockClientWithResponsesInterface_UpdateQueryWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_UpdateQueryWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.QueryID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.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 queryapi.QueryID, body queryapi.UpdateQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.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 *queryapi.UpdateQueryResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, queryapi.UpdateQueryJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.UpdateQueryResponse, error)); ok {
		return rf(ctx, id, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.QueryID, queryapi.UpdateQueryJSONRequestBody, ...queryapi.RequestEditorFn) *queryapi.UpdateQueryResponse); ok {
		r0 = rf(ctx, id, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.UpdateQueryResponse)
		}
	}

	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
}

// 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 queryapi.QueryID
//   - body queryapi.UpdateQueryJSONRequestBody
//   - reqEditors ...queryapi.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 queryapi.QueryID, body queryapi.UpdateQueryJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_UpdateQueryWithResponse_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 *MockClientWithResponsesInterface_UpdateQueryWithResponse_Call) Return(_a0 *queryapi.UpdateQueryResponse, _a1 error) *MockClientWithResponsesInterface_UpdateQueryWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

	var r0 *queryapi.UploadDocumentBatchResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.UploadDocumentBatchResponse, 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) *queryapi.UploadDocumentBatchResponse); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.UploadDocumentBatchResponse)
		}
	}

	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
}

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

// UploadDocumentBatchWithBodyWithResponse 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 *MockClientWithResponsesInterface_Expecter) UploadDocumentBatchWithBodyWithResponse(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_UploadDocumentBatchWithBodyWithResponse_Call {
	return &MockClientWithResponsesInterface_UploadDocumentBatchWithBodyWithResponse_Call{Call: _e.mock.On("UploadDocumentBatchWithBodyWithResponse",
		append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientWithResponsesInterface_UploadDocumentBatchWithBodyWithResponse_Call) Run(run func(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_UploadDocumentBatchWithBodyWithResponse_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 *MockClientWithResponsesInterface_UploadDocumentBatchWithBodyWithResponse_Call) Return(_a0 *queryapi.UploadDocumentBatchResponse, _a1 error) *MockClientWithResponsesInterface_UploadDocumentBatchWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

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

	var r0 *queryapi.UploadDocumentResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.UploadDocumentResponse, 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) *queryapi.UploadDocumentResponse); ok {
		r0 = rf(ctx, id, contentType, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*queryapi.UploadDocumentResponse)
		}
	}

	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
}

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

// UploadDocumentWithBodyWithResponse 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 *MockClientWithResponsesInterface_Expecter) UploadDocumentWithBodyWithResponse(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_UploadDocumentWithBodyWithResponse_Call {
	return &MockClientWithResponsesInterface_UploadDocumentWithBodyWithResponse_Call{Call: _e.mock.On("UploadDocumentWithBodyWithResponse",
		append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}

func (_c *MockClientWithResponsesInterface_UploadDocumentWithBodyWithResponse_Call) Run(run func(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_UploadDocumentWithBodyWithResponse_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 *MockClientWithResponsesInterface_UploadDocumentWithBodyWithResponse_Call) Return(_a0 *queryapi.UploadDocumentResponse, _a1 error) *MockClientWithResponsesInterface_UploadDocumentWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClientWithResponsesInterface_UploadDocumentWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.UploadDocumentResponse, error)) *MockClientWithResponsesInterface_UploadDocumentWithBodyWithResponse_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
}