jacob-mathison/query-orchestration
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

swagger part 1

Browse Source
This commit is contained in:
jay brown
2025-08-05 07:03:35 -07:00
parent 56fb9b4ab6
commit 3de3d0a7b3
27 changed files with 3128 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files
mocks/queryapi/mock_ClientInterface.go
+301
View File
@@ -26,6 +26,81 @@ func (_m *MockClientInterface) EXPECT() *MockClientInterface_Expecter {
return &MockClientInterface_Expecter{mock: &_m.Mock}
}
// CancelDocumentBatch provides a mock function with given fields: ctx, id, batchId, reqEditors
func (_m *MockClientInterface) CancelDocumentBatch(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, id, batchId)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for CancelDocumentBatch")
}
var r0 *http.Response
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
return rf(ctx, id, batchId, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) *http.Response); ok {
r0 = rf(ctx, id, batchId, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*http.Response)
}
}
if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, id, batchId, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientInterface_CancelDocumentBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelDocumentBatch'
type MockClientInterface_CancelDocumentBatch_Call struct {
*mock.Call
}
// CancelDocumentBatch is a helper method to define mock.On call
// - ctx context.Context
// - id queryapi.ClientID
// - batchId queryapi.BatchID
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) CancelDocumentBatch(ctx interface{}, id interface{}, batchId interface{}, reqEditors ...interface{}) *MockClientInterface_CancelDocumentBatch_Call {
return &MockClientInterface_CancelDocumentBatch_Call{Call: _e.mock.On("CancelDocumentBatch",
append([]interface{}{ctx, id, batchId}, reqEditors...)...)}
}
func (_c *MockClientInterface_CancelDocumentBatch_Call) Run(run func(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_CancelDocumentBatch_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
for i, a := range args[3:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(queryapi.BatchID), variadicArgs...)
})
return _c
}
func (_c *MockClientInterface_CancelDocumentBatch_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_CancelDocumentBatch_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientInterface_CancelDocumentBatch_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_CancelDocumentBatch_Call {
_c.Call.Return(run)
return _c
}
// CreateClient provides a mock function with given fields: ctx, body, reqEditors
func (_m *MockClientInterface) CreateClient(ctx context.Context, body queryapi.CreateClientJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
@@ -620,6 +695,81 @@ func (_c *MockClientInterface_GetDocument_Call) RunAndReturn(run func(context.Co
return _c
}
// GetDocumentBatch provides a mock function with given fields: ctx, id, batchId, reqEditors
func (_m *MockClientInterface) GetDocumentBatch(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, id, batchId)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for GetDocumentBatch")
}
var r0 *http.Response
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
return rf(ctx, id, batchId, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) *http.Response); ok {
r0 = rf(ctx, id, batchId, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*http.Response)
}
}
if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, id, batchId, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientInterface_GetDocumentBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDocumentBatch'
type MockClientInterface_GetDocumentBatch_Call struct {
*mock.Call
}
// GetDocumentBatch is a helper method to define mock.On call
// - ctx context.Context
// - id queryapi.ClientID
// - batchId queryapi.BatchID
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetDocumentBatch(ctx interface{}, id interface{}, batchId interface{}, reqEditors ...interface{}) *MockClientInterface_GetDocumentBatch_Call {
return &MockClientInterface_GetDocumentBatch_Call{Call: _e.mock.On("GetDocumentBatch",
append([]interface{}{ctx, id, batchId}, reqEditors...)...)}
}
func (_c *MockClientInterface_GetDocumentBatch_Call) Run(run func(ctx context.Context, id queryapi.ClientID, batchId queryapi.BatchID, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetDocumentBatch_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
for i, a := range args[3:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(queryapi.BatchID), variadicArgs...)
})
return _c
}
func (_c *MockClientInterface_GetDocumentBatch_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetDocumentBatch_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientInterface_GetDocumentBatch_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, queryapi.BatchID, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetDocumentBatch_Call {
_c.Call.Return(run)
return _c
}
// GetHomePage provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientInterface) GetHomePage(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
@@ -841,6 +991,81 @@ func (_c *MockClientInterface_GetStatusByClientId_Call) RunAndReturn(run func(co
return _c
}
// ListDocumentBatches provides a mock function with given fields: ctx, id, params, reqEditors
func (_m *MockClientInterface) ListDocumentBatches(ctx context.Context, id queryapi.ClientID, params *queryapi.ListDocumentBatchesParams, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, id, params)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for ListDocumentBatches")
}
var r0 *http.Response
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, *queryapi.ListDocumentBatchesParams, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
return rf(ctx, id, params, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, *queryapi.ListDocumentBatchesParams, ...queryapi.RequestEditorFn) *http.Response); ok {
r0 = rf(ctx, id, params, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*http.Response)
}
}
if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, *queryapi.ListDocumentBatchesParams, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, id, params, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientInterface_ListDocumentBatches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDocumentBatches'
type MockClientInterface_ListDocumentBatches_Call struct {
*mock.Call
}
// ListDocumentBatches is a helper method to define mock.On call
// - ctx context.Context
// - id queryapi.ClientID
// - params *queryapi.ListDocumentBatchesParams
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) ListDocumentBatches(ctx interface{}, id interface{}, params interface{}, reqEditors ...interface{}) *MockClientInterface_ListDocumentBatches_Call {
return &MockClientInterface_ListDocumentBatches_Call{Call: _e.mock.On("ListDocumentBatches",
append([]interface{}{ctx, id, params}, reqEditors...)...)}
}
func (_c *MockClientInterface_ListDocumentBatches_Call) Run(run func(ctx context.Context, id queryapi.ClientID, params *queryapi.ListDocumentBatchesParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_ListDocumentBatches_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
for i, a := range args[3:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(*queryapi.ListDocumentBatchesParams), variadicArgs...)
})
return _c
}
func (_c *MockClientInterface_ListDocumentBatches_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_ListDocumentBatches_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientInterface_ListDocumentBatches_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, *queryapi.ListDocumentBatchesParams, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_ListDocumentBatches_Call {
_c.Call.Return(run)
return _c
}
// ListDocumentsByClientId provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientInterface) ListDocumentsByClientId(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
@@ -1963,6 +2188,82 @@ func (_c *MockClientInterface_UpdateQueryWithBody_Call) RunAndReturn(run func(co
return _c
}
// UploadDocumentBatchWithBody provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientInterface) UploadDocumentBatchWithBody(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx, id, contentType, body)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for UploadDocumentBatchWithBody")
}
var r0 *http.Response
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
return rf(ctx, id, contentType, body, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) *http.Response); ok {
r0 = rf(ctx, id, contentType, body, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*http.Response)
}
}
if rf, ok := ret.Get(1).(func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, id, contentType, body, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientInterface_UploadDocumentBatchWithBody_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadDocumentBatchWithBody'
type MockClientInterface_UploadDocumentBatchWithBody_Call struct {
*mock.Call
}
// UploadDocumentBatchWithBody is a helper method to define mock.On call
// - ctx context.Context
// - id queryapi.ClientID
// - contentType string
// - body io.Reader
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) UploadDocumentBatchWithBody(ctx interface{}, id interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientInterface_UploadDocumentBatchWithBody_Call {
return &MockClientInterface_UploadDocumentBatchWithBody_Call{Call: _e.mock.On("UploadDocumentBatchWithBody",
append([]interface{}{ctx, id, contentType, body}, reqEditors...)...)}
}
func (_c *MockClientInterface_UploadDocumentBatchWithBody_Call) Run(run func(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_UploadDocumentBatchWithBody_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
for i, a := range args[4:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), args[1].(queryapi.ClientID), args[2].(string), args[3].(io.Reader), variadicArgs...)
})
return _c
}
func (_c *MockClientInterface_UploadDocumentBatchWithBody_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_UploadDocumentBatchWithBody_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientInterface_UploadDocumentBatchWithBody_Call) RunAndReturn(run func(context.Context, queryapi.ClientID, string, io.Reader, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_UploadDocumentBatchWithBody_Call {
_c.Call.Return(run)
return _c
}
// UploadDocumentWithBody provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientInterface) UploadDocumentWithBody(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
mocks/queryapi/mock_ClientWithResponsesInterface.go
+301
View File
@@ -24,6 +24,81 @@ func (_m *MockClientWithResponsesInterface) EXPECT() *MockClientWithResponsesInt
return &MockClientWithResponsesInterface_Expecter{mock: &_m.Mock}
}
// 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
}
// 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))
@@ -544,6 +619,81 @@ func (_c *MockClientWithResponsesInterface_GetCollectorByClientIdWithResponse_Ca
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
}
// 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))
@@ -839,6 +989,81 @@ func (_c *MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_Call)
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))
@@ -1961,6 +2186,82 @@ func (_c *MockClientWithResponsesInterface_UpdateQueryWithResponse_Call) RunAndR
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))