// Code generated by MockGen. DO NOT EDIT.
// Source: git.blender.org/flamenco/internal/worker (interfaces: FlamencoClient)

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	io "io"
	reflect "reflect"

	api "git.blender.org/flamenco/pkg/api"
	gomock "github.com/golang/mock/gomock"
)

// MockFlamencoClient is a mock of FlamencoClient interface.
type MockFlamencoClient struct {
	ctrl     *gomock.Controller
	recorder *MockFlamencoClientMockRecorder
}

// MockFlamencoClientMockRecorder is the mock recorder for MockFlamencoClient.
type MockFlamencoClientMockRecorder struct {
	mock *MockFlamencoClient
}

// NewMockFlamencoClient creates a new mock instance.
func NewMockFlamencoClient(ctrl *gomock.Controller) *MockFlamencoClient {
	mock := &MockFlamencoClient{ctrl: ctrl}
	mock.recorder = &MockFlamencoClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockFlamencoClient) EXPECT() *MockFlamencoClientMockRecorder {
	return m.recorder
}

// FetchJobTasksWithResponse mocks base method.
func (m *MockFlamencoClient) FetchJobTasksWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchJobTasksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FetchJobTasksWithResponse", varargs...)
	ret0, _ := ret[0].(*api.FetchJobTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchJobTasksWithResponse indicates an expected call of FetchJobTasksWithResponse.
func (mr *MockFlamencoClientMockRecorder) FetchJobTasksWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchJobTasksWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchJobTasksWithResponse), varargs...)
}

// FetchJobWithResponse mocks base method.
func (m *MockFlamencoClient) FetchJobWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchJobResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FetchJobWithResponse", varargs...)
	ret0, _ := ret[0].(*api.FetchJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchJobWithResponse indicates an expected call of FetchJobWithResponse.
func (mr *MockFlamencoClientMockRecorder) FetchJobWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchJobWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchJobWithResponse), varargs...)
}

// GetConfigurationWithResponse mocks base method.
func (m *MockFlamencoClient) GetConfigurationWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.GetConfigurationResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConfigurationWithResponse", varargs...)
	ret0, _ := ret[0].(*api.GetConfigurationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigurationWithResponse indicates an expected call of GetConfigurationWithResponse.
func (mr *MockFlamencoClientMockRecorder) GetConfigurationWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigurationWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetConfigurationWithResponse), varargs...)
}

// GetJobTypeWithResponse mocks base method.
func (m *MockFlamencoClient) GetJobTypeWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.GetJobTypeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetJobTypeWithResponse", varargs...)
	ret0, _ := ret[0].(*api.GetJobTypeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetJobTypeWithResponse indicates an expected call of GetJobTypeWithResponse.
func (mr *MockFlamencoClientMockRecorder) GetJobTypeWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobTypeWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetJobTypeWithResponse), varargs...)
}

// GetJobTypesWithResponse mocks base method.
func (m *MockFlamencoClient) GetJobTypesWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.GetJobTypesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetJobTypesWithResponse", varargs...)
	ret0, _ := ret[0].(*api.GetJobTypesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetJobTypesWithResponse indicates an expected call of GetJobTypesWithResponse.
func (mr *MockFlamencoClientMockRecorder) GetJobTypesWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobTypesWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetJobTypesWithResponse), varargs...)
}

// GetVersionWithResponse mocks base method.
func (m *MockFlamencoClient) GetVersionWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.GetVersionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetVersionWithResponse", varargs...)
	ret0, _ := ret[0].(*api.GetVersionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVersionWithResponse indicates an expected call of GetVersionWithResponse.
func (mr *MockFlamencoClientMockRecorder) GetVersionWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersionWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetVersionWithResponse), varargs...)
}

// QueryJobsWithBodyWithResponse mocks base method.
func (m *MockFlamencoClient) QueryJobsWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.QueryJobsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryJobsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*api.QueryJobsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryJobsWithBodyWithResponse indicates an expected call of QueryJobsWithBodyWithResponse.
func (mr *MockFlamencoClientMockRecorder) QueryJobsWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryJobsWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).QueryJobsWithBodyWithResponse), varargs...)
}

// QueryJobsWithResponse mocks base method.
func (m *MockFlamencoClient) QueryJobsWithResponse(arg0 context.Context, arg1 api.QueryJobsJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.QueryJobsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryJobsWithResponse", varargs...)
	ret0, _ := ret[0].(*api.QueryJobsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryJobsWithResponse indicates an expected call of QueryJobsWithResponse.
func (mr *MockFlamencoClientMockRecorder) QueryJobsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryJobsWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).QueryJobsWithResponse), varargs...)
}

// RegisterWorkerWithBodyWithResponse mocks base method.
func (m *MockFlamencoClient) RegisterWorkerWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.RegisterWorkerResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterWorkerWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*api.RegisterWorkerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterWorkerWithBodyWithResponse indicates an expected call of RegisterWorkerWithBodyWithResponse.
func (mr *MockFlamencoClientMockRecorder) RegisterWorkerWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkerWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).RegisterWorkerWithBodyWithResponse), varargs...)
}

// RegisterWorkerWithResponse mocks base method.
func (m *MockFlamencoClient) RegisterWorkerWithResponse(arg0 context.Context, arg1 api.RegisterWorkerJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.RegisterWorkerResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterWorkerWithResponse", varargs...)
	ret0, _ := ret[0].(*api.RegisterWorkerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterWorkerWithResponse indicates an expected call of RegisterWorkerWithResponse.
func (mr *MockFlamencoClientMockRecorder) RegisterWorkerWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkerWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).RegisterWorkerWithResponse), varargs...)
}

// ScheduleTaskWithResponse mocks base method.
func (m *MockFlamencoClient) ScheduleTaskWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.ScheduleTaskResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScheduleTaskWithResponse", varargs...)
	ret0, _ := ret[0].(*api.ScheduleTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ScheduleTaskWithResponse indicates an expected call of ScheduleTaskWithResponse.
func (mr *MockFlamencoClientMockRecorder) ScheduleTaskWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleTaskWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ScheduleTaskWithResponse), varargs...)
}

// SetJobStatusWithBodyWithResponse mocks base method.
func (m *MockFlamencoClient) SetJobStatusWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.SetJobStatusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetJobStatusWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*api.SetJobStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetJobStatusWithBodyWithResponse indicates an expected call of SetJobStatusWithBodyWithResponse.
func (mr *MockFlamencoClientMockRecorder) SetJobStatusWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetJobStatusWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetJobStatusWithBodyWithResponse), varargs...)
}

// SetJobStatusWithResponse mocks base method.
func (m *MockFlamencoClient) SetJobStatusWithResponse(arg0 context.Context, arg1 string, arg2 api.SetJobStatusJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.SetJobStatusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetJobStatusWithResponse", varargs...)
	ret0, _ := ret[0].(*api.SetJobStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetJobStatusWithResponse indicates an expected call of SetJobStatusWithResponse.
func (mr *MockFlamencoClientMockRecorder) SetJobStatusWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetJobStatusWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetJobStatusWithResponse), varargs...)
}

// ShamanCheckoutRequirementsWithBodyWithResponse mocks base method.
func (m *MockFlamencoClient) ShamanCheckoutRequirementsWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.ShamanCheckoutRequirementsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ShamanCheckoutRequirementsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*api.ShamanCheckoutRequirementsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ShamanCheckoutRequirementsWithBodyWithResponse indicates an expected call of ShamanCheckoutRequirementsWithBodyWithResponse.
func (mr *MockFlamencoClientMockRecorder) ShamanCheckoutRequirementsWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanCheckoutRequirementsWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanCheckoutRequirementsWithBodyWithResponse), varargs...)
}

// ShamanCheckoutRequirementsWithResponse mocks base method.
func (m *MockFlamencoClient) ShamanCheckoutRequirementsWithResponse(arg0 context.Context, arg1 api.ShamanCheckoutRequirementsJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.ShamanCheckoutRequirementsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ShamanCheckoutRequirementsWithResponse", varargs...)
	ret0, _ := ret[0].(*api.ShamanCheckoutRequirementsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ShamanCheckoutRequirementsWithResponse indicates an expected call of ShamanCheckoutRequirementsWithResponse.
func (mr *MockFlamencoClientMockRecorder) ShamanCheckoutRequirementsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanCheckoutRequirementsWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanCheckoutRequirementsWithResponse), varargs...)
}

// ShamanCheckoutWithBodyWithResponse mocks base method.
func (m *MockFlamencoClient) ShamanCheckoutWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.ShamanCheckoutResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ShamanCheckoutWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*api.ShamanCheckoutResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ShamanCheckoutWithBodyWithResponse indicates an expected call of ShamanCheckoutWithBodyWithResponse.
func (mr *MockFlamencoClientMockRecorder) ShamanCheckoutWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanCheckoutWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanCheckoutWithBodyWithResponse), varargs...)
}

// ShamanCheckoutWithResponse mocks base method.
func (m *MockFlamencoClient) ShamanCheckoutWithResponse(arg0 context.Context, arg1 api.ShamanCheckoutJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.ShamanCheckoutResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ShamanCheckoutWithResponse", varargs...)
	ret0, _ := ret[0].(*api.ShamanCheckoutResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ShamanCheckoutWithResponse indicates an expected call of ShamanCheckoutWithResponse.
func (mr *MockFlamencoClientMockRecorder) ShamanCheckoutWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanCheckoutWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanCheckoutWithResponse), varargs...)
}

// ShamanFileStoreCheckWithResponse mocks base method.
func (m *MockFlamencoClient) ShamanFileStoreCheckWithResponse(arg0 context.Context, arg1 string, arg2 int, arg3 ...api.RequestEditorFn) (*api.ShamanFileStoreCheckResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ShamanFileStoreCheckWithResponse", varargs...)
	ret0, _ := ret[0].(*api.ShamanFileStoreCheckResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ShamanFileStoreCheckWithResponse indicates an expected call of ShamanFileStoreCheckWithResponse.
func (mr *MockFlamencoClientMockRecorder) ShamanFileStoreCheckWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanFileStoreCheckWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanFileStoreCheckWithResponse), varargs...)
}

// ShamanFileStoreWithBodyWithResponse mocks base method.
func (m *MockFlamencoClient) ShamanFileStoreWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 int, arg3 *api.ShamanFileStoreParams, arg4 string, arg5 io.Reader, arg6 ...api.RequestEditorFn) (*api.ShamanFileStoreResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3, arg4, arg5}
	for _, a := range arg6 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ShamanFileStoreWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*api.ShamanFileStoreResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ShamanFileStoreWithBodyWithResponse indicates an expected call of ShamanFileStoreWithBodyWithResponse.
func (mr *MockFlamencoClientMockRecorder) ShamanFileStoreWithBodyWithResponse(arg0, arg1, arg2, arg3, arg4, arg5 interface{}, arg6 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5}, arg6...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanFileStoreWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanFileStoreWithBodyWithResponse), varargs...)
}

// SignOffWithResponse mocks base method.
func (m *MockFlamencoClient) SignOffWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.SignOffResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SignOffWithResponse", varargs...)
	ret0, _ := ret[0].(*api.SignOffResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignOffWithResponse indicates an expected call of SignOffWithResponse.
func (mr *MockFlamencoClientMockRecorder) SignOffWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignOffWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SignOffWithResponse), varargs...)
}

// SignOnWithBodyWithResponse mocks base method.
func (m *MockFlamencoClient) SignOnWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.SignOnResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SignOnWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*api.SignOnResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignOnWithBodyWithResponse indicates an expected call of SignOnWithBodyWithResponse.
func (mr *MockFlamencoClientMockRecorder) SignOnWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignOnWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SignOnWithBodyWithResponse), varargs...)
}

// SignOnWithResponse mocks base method.
func (m *MockFlamencoClient) SignOnWithResponse(arg0 context.Context, arg1 api.SignOnJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.SignOnResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SignOnWithResponse", varargs...)
	ret0, _ := ret[0].(*api.SignOnResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignOnWithResponse indicates an expected call of SignOnWithResponse.
func (mr *MockFlamencoClientMockRecorder) SignOnWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignOnWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SignOnWithResponse), varargs...)
}

// SubmitJobWithBodyWithResponse mocks base method.
func (m *MockFlamencoClient) SubmitJobWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.SubmitJobResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubmitJobWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*api.SubmitJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitJobWithBodyWithResponse indicates an expected call of SubmitJobWithBodyWithResponse.
func (mr *MockFlamencoClientMockRecorder) SubmitJobWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitJobWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SubmitJobWithBodyWithResponse), varargs...)
}

// SubmitJobWithResponse mocks base method.
func (m *MockFlamencoClient) SubmitJobWithResponse(arg0 context.Context, arg1 api.SubmitJobJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.SubmitJobResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubmitJobWithResponse", varargs...)
	ret0, _ := ret[0].(*api.SubmitJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SubmitJobWithResponse indicates an expected call of SubmitJobWithResponse.
func (mr *MockFlamencoClientMockRecorder) SubmitJobWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitJobWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SubmitJobWithResponse), varargs...)
}

// TaskUpdateWithBodyWithResponse mocks base method.
func (m *MockFlamencoClient) TaskUpdateWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.TaskUpdateResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TaskUpdateWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*api.TaskUpdateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TaskUpdateWithBodyWithResponse indicates an expected call of TaskUpdateWithBodyWithResponse.
func (mr *MockFlamencoClientMockRecorder) TaskUpdateWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskUpdateWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).TaskUpdateWithBodyWithResponse), varargs...)
}

// TaskUpdateWithResponse mocks base method.
func (m *MockFlamencoClient) TaskUpdateWithResponse(arg0 context.Context, arg1 string, arg2 api.TaskUpdateJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.TaskUpdateResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TaskUpdateWithResponse", varargs...)
	ret0, _ := ret[0].(*api.TaskUpdateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TaskUpdateWithResponse indicates an expected call of TaskUpdateWithResponse.
func (mr *MockFlamencoClientMockRecorder) TaskUpdateWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskUpdateWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).TaskUpdateWithResponse), varargs...)
}

// WorkerStateChangedWithBodyWithResponse mocks base method.
func (m *MockFlamencoClient) WorkerStateChangedWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.WorkerStateChangedResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WorkerStateChangedWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*api.WorkerStateChangedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WorkerStateChangedWithBodyWithResponse indicates an expected call of WorkerStateChangedWithBodyWithResponse.
func (mr *MockFlamencoClientMockRecorder) WorkerStateChangedWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerStateChangedWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).WorkerStateChangedWithBodyWithResponse), varargs...)
}

// WorkerStateChangedWithResponse mocks base method.
func (m *MockFlamencoClient) WorkerStateChangedWithResponse(arg0 context.Context, arg1 api.WorkerStateChangedJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.WorkerStateChangedResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WorkerStateChangedWithResponse", varargs...)
	ret0, _ := ret[0].(*api.WorkerStateChangedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WorkerStateChangedWithResponse indicates an expected call of WorkerStateChangedWithResponse.
func (mr *MockFlamencoClientMockRecorder) WorkerStateChangedWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerStateChangedWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).WorkerStateChangedWithResponse), varargs...)
}

// WorkerStateWithResponse mocks base method.
func (m *MockFlamencoClient) WorkerStateWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.WorkerStateResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WorkerStateWithResponse", varargs...)
	ret0, _ := ret[0].(*api.WorkerStateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WorkerStateWithResponse indicates an expected call of WorkerStateWithResponse.
func (mr *MockFlamencoClientMockRecorder) WorkerStateWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerStateWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).WorkerStateWithResponse), varargs...)
}